id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c5600 | return fmt.Sprintf("ArangoError: Code %d, ErrorNum %d", ae.Code, ae.ErrorNum)
} | |
c5601 | || ae.Code == http.StatusGatewayTimeout)
} | |
c5602 | http.StatusServiceUnavailable
} | |
c5603 | code,
ErrorNum: errorNum,
ErrorMessage: errorMessage,
}
} | |
c5604 | Cause(err).(ArangoError)
return ok && ae.HasError
} | |
c5605 | := Cause(err).(ArangoError)
return ok && ae.Code == code
} | |
c5606 | if !ok {
return false
}
for _, x := range errorNum {
if ae.ErrorNum == x {
return true
}
}
return false
} | |
c5607 | (IsArangoErrorWithErrorNum(err, 1495) || IsArangoErrorWithErrorNum(err, 1496))
} | |
c5608 | := Cause(err).(InvalidArgumentError)
return ok
} | |
c5609 | := Cause(err).(NoMoreDocumentsError)
return ok
} | |
c5610 | return e == context.Canceled })
} | |
c5611 | return e == context.DeadlineExceeded })
} | |
c5612 | err.(*net.OpError); ok {
err = xerr.Err
} else if xerr, ok := err.(*os.SyscallError); ok {
err = xerr.Err
} else {
return false
}
}
} | |
c5613 | e != nil {
return e
}
}
return nil
} | |
c5614 | tlsConn
}
// Send protocol header
switch version {
case Version1_0:
if _, err := conn.Write(vstProtocolHeader1_0); err != nil {
return nil, driver.WithStack(err)
}
case Version1_1:
if _, err := conn.Write(vstProtocolHeader1_1); err != nil {
return nil, driver.WithStack(err)
}
default:
return nil... | |
c5615 |
}
c.msgStore.ForEach(func(m *Message) {
m.closeResponseChan()
})
}
return nil
} | |
c5616 |
err = driver.WithStack(fmt.Errorf("Unknown protocol version %d", int(c.version)))
}
c.updateLastActivity()
if err != nil {
return driver.WithStack(err)
}
return nil
} | |
c5617 | recentErrors > maxRecentErrors {
// When we get to many errors in a row, close this connection
c.Close()
} else {
// Backoff a bit, so we allow things to settle.
time.Sleep(time.Millisecond * time.Duration(recentErrors*5))
}
}
}
} else {
// Process chunk
recentErrors = ... | |
c5618 | // Remove message from store
c.msgStore.Remove(m.ID)
//fmt.Println("Chunk: " + hex.EncodeToString(chunk.Data) + "\nMessage: " + hex.EncodeToString(m.Data))
// Notify listener
m.notifyListener()
}
} | |
c5619 | > idleTimeout && c.msgStore.Size() == 0
} | |
c5620 | nil
case string(GeoIndex), "geo1", "geo2":
return GeoIndex, nil
case string(EdgeIndex):
return EdgeIndex, nil
default:
return "", WithStack(InvalidArgumentError{Message: "unknown index type"})
}
} | |
c5621 | is nil"})
}
indexType, err := indexStringToType(indexTypeString)
if err != nil {
return nil, WithStack(err)
}
return &index{
id: id,
indexType: indexType,
col: col,
db: col.db,
conn: col.conn,
}, nil
} | |
c5622 | := strings.Split(i.id, "/")
return parts[1]
} | |
c5623 | nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | |
c5624 | id = hex.EncodeToString(randBytes)
}
return &lock{
log: log,
api: api,
key: key,
id: id,
ttl: ttl,
}, nil
} | |
c5625 | return driver.WithStack(AlreadyLockedError)
}
return driver.WithStack(err)
}
// Success
l.locked = true
// Keep renewing
renewCtx, renewCancel := context.WithCancel(context.Background())
go l.renewLock(renewCtx)
l.cancelRenewal = renewCancel
return nil
} | |
c5626 | return driver.WithStack(err)
}
// Cleanup
l.locked = false
if l.cancelRenewal != nil {
l.cancelRenewal()
l.cancelRenewal = nil
}
return nil
} | |
c5627 | l.mutex.Unlock()
return l.locked
} | |
c5628 | stop, err := op()
if stop || driver.Cause(err) == context.Canceled {
return
}
if err != nil {
if l.log != nil {
l.log.Errorf("Failed to renew lock %s. %v", l.key, err)
}
delay = time.Second
}
select {
case <-ctx.Done():
// we're done
return
case <-time.After(delay):
// Try to re... | |
c5629 |
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
u, err := newUser(data, c.conn)
if err != nil {
return nil, WithStack(err)
}
return u, nil
} | |
c5630 | {
return false, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return false, WithStack(err)
}
if err := resp.CheckStatus(200); err == nil {
return true, nil
} else if IsNotFound(err) {
return false, nil
} else {
return false, WithStack(err)
}
} | |
c5631 | 0, len(data.Result))
for _, userData := range data.Result {
u, err := newUser(userData, c.conn)
if err != nil {
return nil, WithStack(err)
}
result = append(result, u)
}
return result, nil
} | |
c5632 |
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
var data userData
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
u, err := newUser(data, c.conn)
if err != nil {
return nil, WithStack(err)
}
return u, nil
} | |
c5633 | is empty"})
}
if g == nil {
return nil, WithStack(InvalidArgumentError{Message: "g is nil"})
}
return &edgeCollection{
name: name,
g: g,
conn: g.db.conn,
}, nil
} | |
c5634 | := newCollection(c.name, c.g.db)
return result
} | |
c5635 |
return CollectionStatistics{}, WithStack(err)
}
return result, nil
} | |
c5636 |
var err error
slices[i], err = velocypack.Marshal(b)
if err != nil {
return r, driver.WithStack(err)
}
}
merged, err := velocypack.Merge(slices...)
if err != nil {
return r, driver.WithStack(err)
}
r.body = merged
return r, nil
}
} | |
c5637 |
case "PATCH":
return 5
case "OPTIONS":
return 6
default:
panic(fmt.Errorf("Unknown method '%s'", r.method))
}
} | |
c5638 | endpoint: endpoint,
db: db,
conn: db.conn,
allowDirtyReads: allowDirtyReads,
}, nil
} | |
c5639 | len(c.Result) || c.cursorData.HasMore
} | |
c5640 | nil {
return WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(202); err != nil {
return WithStack(err)
}
}
atomic.StoreInt32(&c.closed, 1)
}
return nil
} | |
c5641 | hence update the bool reference
if c.allowDirtyReads {
setDirtyReadFlagIfRequired(ctx, c.lastReadWasDirty)
}
index := c.resultIndex
if index >= len(c.Result) {
// Out of data
return DocumentMeta{}, WithStack(NoMoreDocumentsError{})
}
c.resultIndex++
var meta DocumentMeta
resultPtr := c.Result[index]
if... | |
c5642 | r.q = url.Values{}
}
r.q.Set(key, value)
return r
} | |
c5643 | r.hdr = make(map[string]string)
}
r.hdr[key] = value
return r
} | |
c5644 | }
return context.WithValue(parent, keyAllowNoLeader, true)
} | |
c5645 | {
return ctx != nil && ctx.Value(keyAllowNoLeader) != nil
} | |
c5646 |
if !status.IsResponding {
return driver.WithStack(fmt.Errorf("Agent %s is not responding", strings.Join(clients[i].Endpoints(), ",")))
}
if status.IsLeader {
noLeaders++
}
if i > 0 {
// Compare leader endpoint with previous
prev := statuses[i-1].LeaderEndpoint
if !IsSameEndpoint(prev, status.L... | |
c5647 | if err != nil {
return false
}
return ua.Hostname() == ub.Hostname()
} | |
c5648 | return nil, WithStack(err)
}
result := make([]Index, 0, len(data.Indexes))
for _, x := range data.Indexes {
idx, err := newIndex(x.ID, x.Type, c)
if err != nil {
return nil, WithStack(err)
}
result = append(result, idx)
}
return result, nil
} | |
c5649 | is empty"})
}
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &user{
data: data,
conn: conn,
}, nil
} | |
c5650 | WithStack(err)
}
if err := resp.CheckStatus(202); err != nil {
return WithStack(err)
}
return nil
} | |
c5651 | {
return WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
var data userData
if err := resp.ParseBody("", &data); err != nil {
return WithStack(err)
}
u.data = data
return nil
} | |
c5652 | result := make([]Database, 0, len(data.Result))
for name := range data.Result {
db, err := newDatabase(name, u.conn)
if err != nil {
return nil, WithStack(err)
}
result = append(result, db)
}
return result, nil
} | |
c5653 | := req.SetBody(input); err != nil {
return WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | |
c5654 |
if err := resp.CheckStatus(200); err != nil {
return GrantNone, WithStack(err)
}
var data getAccessResponse
if err := resp.ParseBody("", &data); err != nil {
return GrantNone, WithStack(err)
}
return Grant(data.Result), nil
} | |
c5655 | _, err := req.SetBody(input); err != nil {
return WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | |
c5656 |
}
if err := resp.CheckStatus(200); err != nil {
return GrantNone, WithStack(err)
}
var data getAccessResponse
if err := resp.ParseBody("", &data); err != nil {
return GrantNone, WithStack(err)
}
return Grant(data.Result), nil
} | |
c5657 | return WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200, 202); err != nil {
return WithStack(err)
}
return nil
} | |
c5658 |
return x.Name(), "*", nil
}
return "", "", WithStack(InvalidArgumentError{"Need Collection or Database or nil"})
} | |
c5659 |
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryCount, v)
} | |
c5660 | {
return context.WithValue(contextOrBackground(parent), keyQueryBatchSize, value)
} | |
c5661 |
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryCache, v)
} | |
c5662 | {
return context.WithValue(contextOrBackground(parent), keyQueryMemoryLimit, value)
} | |
c5663 | context.WithValue(contextOrBackground(parent), keyQueryTTL, value)
} | |
c5664 | context.WithValue(contextOrBackground(parent), keyQueryOptSatSyncWait, value)
} | |
c5665 |
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryOptFullCount, v)
} | |
c5666 | nil {
if value, ok := rawValue.(int64); ok {
q.MemoryLimit = value
}
}
if rawValue := ctx.Value(keyQueryTTL); rawValue != nil {
if value, ok := rawValue.(time.Duration); ok {
q.TTL = value.Seconds()
}
}
if rawValue := ctx.Value(keyQueryOptSatSyncWait); rawValue != nil {
if value, ok := rawValue.(ti... | |
c5667 | nil {
return nil, WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
g, err := newGraph(name, d)
if err != nil {
return nil, WithStack(err)
}
return g, nil
} | |
c5668 | }
result := make([]Graph, 0, len(data.Graphs))
for _, info := range data.Graphs {
g, err := newGraph(info.Key, d)
if err != nil {
return nil, WithStack(err)
}
result = append(result, g)
}
return result, nil
} | |
c5669 | if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201, 202); err != nil {
return nil, WithStack(err)
}
g, err := newGraph(name,... | |
c5670 | clone.hdr != nil {
clone.hdr = make(map[string]string)
for k, v := range r.hdr {
clone.hdr[k] = v
}
}
return &clone
} | |
c5671 | body[0]}
if data, err := velocypack.Marshal(mo); err != nil {
return r, driver.WithStack(err)
} else {
r.body = data
}
return r, nil
default:
return r, driver.WithStack(fmt.Errorf("Must provide at most 2 bodies"))
}
} | |
c5672 | if x == p {
return true
}
}
return false
} | |
c5673 | == y {
return true
}
}
}
return false
} | |
c5674 |
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | |
c5675 | if n.Collection == name {
ec, err := newEdgeCollection(name, g)
if err != nil {
return nil, VertexConstraints{}, WithStack(err)
}
constraints := VertexConstraints{
From: n.From,
To: n.To,
}
return ec, constraints, nil
}
}
return nil, VertexConstraints{}, WithStack(newArangoError(40... | |
c5676 | return false, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return false, WithStack(err)
}
var data getGraphResponse
if err := resp.ParseBody("", &data); err != nil {
return false, WithStack(err)
}
for _, n := range data.Graph.EdgeDefinitions {
if n.Collection == name {
return true, n... | |
c5677 | := range data.Graph.EdgeDefinitions {
ec, err := newEdgeCollection(n.Collection, g)
if err != nil {
return nil, nil, WithStack(err)
}
result = append(result, ec)
constraints = append(constraints, VertexConstraints{
From: n.From,
To: n.To,
})
}
return result, constraints, nil
} | |
c5678 |
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &view{
name: name,
viewType: viewType,
db: db,
conn: db.conn,
}, nil
} | |
c5679 | WithStack(newArangoError(http.StatusConflict, 0, fmt.Sprintf("Type must be '%s', got '%s'", ViewTypeArangoSearch, v.viewType)))
}
return &viewArangoSearch{view: *v}, nil
} | |
c5680 | return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | |
c5681 | "conn is nil"})
}
return &cluster{
conn: conn,
}, nil
} | |
c5682 | nil {
return WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(202); err != nil {
return WithStack(err)
}
return nil
} | |
c5683 | resp.CheckStatus(200, 202); err != nil {
return WithStack(err)
}
var result cleanOutServerResponse
if err := resp.ParseBody("", &result); err != nil {
return WithStack(err)
}
if cs.JobIDResponse != nil {
*cs.JobIDResponse = result.JobID
}
return nil
} | |
c5684 | range r.CleanedServerIDs {
if id == serverID {
return true, nil
}
}
return false, nil
} | |
c5685 | resp, err := c.conn.Do(ctx, req)
if err != nil {
return NumberOfServersResponse{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return NumberOfServersResponse{}, WithStack(err)
}
var result NumberOfServersResponse
if err := resp.ParseBody("", &result); err != nil {
return NumberOfServersR... | |
c5686 |
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200, 202); err != nil {
return WithStack(err)
}
return nil
} | |
c5687 | json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(internal)
return nil
} | |
c5688 | {
replicationFactor = replicationFactorSatelliteString
} else {
replicationFactor = int(r)
}
return json.Marshal(replicationFactor)
} | |
c5689 | ok && str == replicationFactorSatelliteString {
*r = replicationFactor(ReplicationFactorSatellite)
return nil
}
}
return &json.UnmarshalTypeError{
Value: string(d),
Type: reflect.TypeOf(r).Elem(),
}
} | |
c5690 | return &agency{
conn: conn,
}, nil
} | |
c5691 | return driver.WithStack(err)
}
var rawMsg interface{}
for keyIndex := 0; keyIndex < len(key); keyIndex++ {
if keyIndex > 0 {
var ok bool
rawObject, ok = rawMsg.(map[string]interface{})
if !ok {
return driver.WithStack(fmt.Errorf("Data is not an object at key %s", key[:keyIndex+1]))
}
... | |
c5692 | if err := c.write(ctx, "set", key, value, cond, ttl); err != nil {
return driver.WithStack(err)
}
return nil
} | |
c5693 |
var cond WriteCondition
cond = cond.IfEqualTo(key, oldValue)
if err := c.write(ctx, "set", key, newValue, cond, ttl); err != nil {
return driver.WithStack(err)
}
return nil
} | |
c5694 | }
if err := resp.ParseBody("", &result); err != nil {
return driver.WithStack(err)
}
// "results" should be 1 long
if len(result.Results) != 1 {
return driver.WithStack(fmt.Errorf("Expected results of 1 long, got %d", len(result.Results)))
}
// If results[0] == 0, condition failed, otherwise success
if re... | |
c5695 | c.write(ctx, "delete", key, nil, cond, 0); err != nil {
return driver.WithStack(err)
}
return nil
} | |
c5696 | != nil {
return driver.WithStack(err)
}
if err := resp.ParseBody("", &result); err != nil {
return driver.WithStack(err)
}
// "results" should be 1 long
if len(result.Results) != 1 {
return driver.WithStack(fmt.Errorf("Expected results of 1 long, got %d", len(result.Results)))
}
// Success
return nil
} | |
c5697 |
token := jg.NewWithClaims(jg.SigningMethodHS256, jg.MapClaims{
"iss": issArangod,
"server_id": serverID,
})
// Sign and get the complete encoded token as a string using the secret
signedToken, err := token.SignedString([]byte(jwtSecret))
if err != nil {
return "", driver.WithStack(err)
}
return "b... | |
c5698 | if jsonName == "" {
jsonName = f.Name
} else if jsonName == "-" {
continue
}
raw, ok := body[jsonName]
if ok && raw != nil {
field := objValue.Field(i)
if err := json.Unmarshal(*raw, field.Addr().Interface()); err != nil {
return driver.WithStack(err)
}
}
}
}
return nil
} | |
c5699 |
}
for jsonName, raw := range body {
var value interface{}
if raw != nil {
if err := json.Unmarshal(*raw, &value); err != nil {
return driver.WithStack(err)
}
}
mapVal.SetMapIndex(reflect.ValueOf(jsonName), reflect.ValueOf(value))
}
val.Set(mapVal)
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.