_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q5600
|
Error
|
train
|
func (ae ArangoError) Error() string {
if ae.ErrorMessage != "" {
return ae.ErrorMessage
}
return fmt.Sprintf("ArangoError: Code %d, ErrorNum %d", ae.Code, ae.ErrorNum)
}
|
go
|
{
"resource": ""
}
|
q5601
|
Timeout
|
train
|
func (ae ArangoError) Timeout() bool {
return ae.HasError && (ae.Code == http.StatusRequestTimeout || ae.Code == http.StatusGatewayTimeout)
}
|
go
|
{
"resource": ""
}
|
q5602
|
Temporary
|
train
|
func (ae ArangoError) Temporary() bool {
return ae.HasError && ae.Code == http.StatusServiceUnavailable
}
|
go
|
{
"resource": ""
}
|
q5603
|
newArangoError
|
train
|
func newArangoError(code, errorNum int, errorMessage string) error {
return ArangoError{
HasError: true,
Code: code,
ErrorNum: errorNum,
ErrorMessage: errorMessage,
}
}
|
go
|
{
"resource": ""
}
|
q5604
|
IsArangoError
|
train
|
func IsArangoError(err error) bool {
ae, ok := Cause(err).(ArangoError)
return ok && ae.HasError
}
|
go
|
{
"resource": ""
}
|
q5605
|
IsArangoErrorWithCode
|
train
|
func IsArangoErrorWithCode(err error, code int) bool {
ae, ok := Cause(err).(ArangoError)
return ok && ae.Code == code
}
|
go
|
{
"resource": ""
}
|
q5606
|
IsArangoErrorWithErrorNum
|
train
|
func IsArangoErrorWithErrorNum(err error, errorNum ...int) bool {
ae, ok := Cause(err).(ArangoError)
if !ok {
return false
}
for _, x := range errorNum {
if ae.ErrorNum == x {
return true
}
}
return false
}
|
go
|
{
"resource": ""
}
|
q5607
|
IsNoLeaderOrOngoing
|
train
|
func IsNoLeaderOrOngoing(err error) bool {
return IsArangoErrorWithCode(err, 503) && (IsArangoErrorWithErrorNum(err, 1495) || IsArangoErrorWithErrorNum(err, 1496))
}
|
go
|
{
"resource": ""
}
|
q5608
|
IsInvalidArgument
|
train
|
func IsInvalidArgument(err error) bool {
_, ok := Cause(err).(InvalidArgumentError)
return ok
}
|
go
|
{
"resource": ""
}
|
q5609
|
IsNoMoreDocuments
|
train
|
func IsNoMoreDocuments(err error) bool {
_, ok := Cause(err).(NoMoreDocumentsError)
return ok
}
|
go
|
{
"resource": ""
}
|
q5610
|
IsCanceled
|
train
|
func IsCanceled(err error) bool {
return isCausedBy(err, func(e error) bool { return e == context.Canceled })
}
|
go
|
{
"resource": ""
}
|
q5611
|
IsTimeout
|
train
|
func IsTimeout(err error) bool {
return isCausedBy(err, func(e error) bool { return e == context.DeadlineExceeded })
}
|
go
|
{
"resource": ""
}
|
q5612
|
isCausedBy
|
train
|
func isCausedBy(err error, p func(error) bool) bool {
if p(err) {
return true
}
err = Cause(err)
for {
if p(err) {
return true
} else if err == nil {
return false
}
if xerr, ok := err.(*ResponseError); ok {
err = xerr.Err
} else if xerr, ok := err.(*url.Error); ok {
err = xerr.Err
} else if xerr, ok := err.(*net.OpError); ok {
err = xerr.Err
} else if xerr, ok := err.(*os.SyscallError); ok {
err = xerr.Err
} else {
return false
}
}
}
|
go
|
{
"resource": ""
}
|
q5613
|
FirstNonNil
|
train
|
func (l ErrorSlice) FirstNonNil() error {
for _, e := range l {
if e != nil {
return e
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5614
|
dial
|
train
|
func dial(version Version, addr string, tlsConfig *tls.Config) (*Connection, error) {
// Create TCP connection
conn, err := net.Dial("tcp", addr)
if err != nil {
return nil, driver.WithStack(err)
}
// Configure connection
if tcpConn, ok := conn.(*net.TCPConn); ok {
tcpConn.SetKeepAlive(true)
tcpConn.SetNoDelay(true)
}
// Add TLS if needed
if tlsConfig != nil {
tlsConn := tls.Client(conn, tlsConfig)
conn = 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, driver.WithStack(fmt.Errorf("Unknown protocol version %d", int(version)))
}
// prepare connection
c := &Connection{
version: version,
maxChunkSize: defaultMaxChunkSize,
conn: conn,
}
c.updateLastActivity()
// Start reading responses
go c.readChunkLoop()
return c, nil
}
|
go
|
{
"resource": ""
}
|
q5615
|
Close
|
train
|
func (c *Connection) Close() error {
if atomic.CompareAndSwapInt32(&c.closing, 0, 1) {
if err := c.conn.Close(); err != nil {
return driver.WithStack(err)
}
c.msgStore.ForEach(func(m *Message) {
m.closeResponseChan()
})
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5616
|
sendChunk
|
train
|
func (c *Connection) sendChunk(deadline time.Time, chunk chunk) error {
c.writeMutex.Lock()
defer c.writeMutex.Unlock()
c.conn.SetWriteDeadline(deadline)
var err error
switch c.version {
case Version1_0:
_, err = chunk.WriteToVST1_0(c.conn)
case Version1_1:
_, err = chunk.WriteToVST1_1(c.conn)
default:
err = driver.WithStack(fmt.Errorf("Unknown protocol version %d", int(c.version)))
}
c.updateLastActivity()
if err != nil {
return driver.WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5617
|
readChunkLoop
|
train
|
func (c *Connection) readChunkLoop() {
recentErrors := 0
goodChunks := 0
for {
if c.IsClosed() {
// Closing, we're done
return
}
var chunk chunk
var err error
switch c.version {
case Version1_0:
chunk, err = readChunkVST1_0(c.conn)
case Version1_1:
chunk, err = readChunkVST1_1(c.conn)
default:
err = driver.WithStack(fmt.Errorf("Unknown protocol version %d", int(c.version)))
}
c.updateLastActivity()
if err != nil {
if !c.IsClosed() {
// Handle error
if driver.Cause(err) == io.EOF {
// Connection closed
c.Close()
} else {
recentErrors++
fmt.Printf("readChunkLoop error: %#v (goodChunks=%d)\n", err, goodChunks)
if 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 = 0
goodChunks++
go c.processChunk(chunk)
}
}
}
|
go
|
{
"resource": ""
}
|
q5618
|
processChunk
|
train
|
func (c *Connection) processChunk(chunk chunk) {
m := c.msgStore.Get(chunk.MessageID)
if m == nil {
// Unexpected chunk, ignore it
return
}
// Add chunk to message
m.addChunk(chunk)
// Try to assembly
if m.assemble() {
// Message is complete
// 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()
}
}
|
go
|
{
"resource": ""
}
|
q5619
|
IsIdle
|
train
|
func (c *Connection) IsIdle(idleTimeout time.Duration) bool {
return time.Since(c.lastActivity) > idleTimeout && c.msgStore.Size() == 0
}
|
go
|
{
"resource": ""
}
|
q5620
|
indexStringToType
|
train
|
func indexStringToType(indexTypeString string) (IndexType, error) {
switch indexTypeString {
case string(FullTextIndex):
return FullTextIndex, nil
case string(HashIndex):
return HashIndex, nil
case string(SkipListIndex):
return SkipListIndex, nil
case string(PrimaryIndex):
return PrimaryIndex, nil
case string(PersistentIndex):
return PersistentIndex, nil
case string(GeoIndex), "geo1", "geo2":
return GeoIndex, nil
case string(EdgeIndex):
return EdgeIndex, nil
default:
return "", WithStack(InvalidArgumentError{Message: "unknown index type"})
}
}
|
go
|
{
"resource": ""
}
|
q5621
|
newIndex
|
train
|
func newIndex(id string, indexTypeString string, col *collection) (Index, error) {
if id == "" {
return nil, WithStack(InvalidArgumentError{Message: "id is empty"})
}
parts := strings.Split(id, "/")
if len(parts) != 2 {
return nil, WithStack(InvalidArgumentError{Message: "id must be `collection/name`"})
}
if col == nil {
return nil, WithStack(InvalidArgumentError{Message: "col 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
}
|
go
|
{
"resource": ""
}
|
q5622
|
Name
|
train
|
func (i *index) Name() string {
parts := strings.Split(i.id, "/")
return parts[1]
}
|
go
|
{
"resource": ""
}
|
q5623
|
Remove
|
train
|
func (i *index) Remove(ctx context.Context) error {
req, err := i.conn.NewRequest("DELETE", path.Join(i.relPath(), i.id))
if err != nil {
return WithStack(err)
}
resp, err := i.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5624
|
NewLock
|
train
|
func NewLock(log Logger, api Agency, key []string, id string, ttl time.Duration) (Lock, error) {
if ttl < minLockTTL {
ttl = minLockTTL
}
if id == "" {
randBytes := make([]byte, 16)
rand.Read(randBytes)
id = hex.EncodeToString(randBytes)
}
return &lock{
log: log,
api: api,
key: key,
id: id,
ttl: ttl,
}, nil
}
|
go
|
{
"resource": ""
}
|
q5625
|
Lock
|
train
|
func (l *lock) Lock(ctx context.Context) error {
l.mutex.Lock()
defer l.mutex.Unlock()
if l.locked {
return driver.WithStack(AlreadyLockedError)
}
// Try to claim lock
ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if err := l.api.WriteKeyIfEmpty(ctx, l.key, l.id, l.ttl); err != nil {
if driver.IsPreconditionFailed(err) {
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
}
|
go
|
{
"resource": ""
}
|
q5626
|
Unlock
|
train
|
func (l *lock) Unlock(ctx context.Context) error {
l.mutex.Lock()
defer l.mutex.Unlock()
if !l.locked {
return driver.WithStack(NotLockedError)
}
// Release the lock
ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if err := l.api.RemoveKeyIfEqualTo(ctx, l.key, l.id); err != nil {
return driver.WithStack(err)
}
// Cleanup
l.locked = false
if l.cancelRenewal != nil {
l.cancelRenewal()
l.cancelRenewal = nil
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5627
|
IsLocked
|
train
|
func (l *lock) IsLocked() bool {
l.mutex.Lock()
defer l.mutex.Unlock()
return l.locked
}
|
go
|
{
"resource": ""
}
|
q5628
|
renewLock
|
train
|
func (l *lock) renewLock(ctx context.Context) {
// op performs a renewal once.
// returns stop, error
op := func() (bool, error) {
l.mutex.Lock()
defer l.mutex.Unlock()
if !l.locked {
return true, driver.WithStack(NotLockedError)
}
// Update key in agency
ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if err := l.api.WriteKeyIfEqualTo(ctx, l.key, l.id, l.id, l.ttl); err != nil {
if driver.IsPreconditionFailed(err) {
// We're not longer the leader
l.locked = false
l.cancelRenewal = nil
return true, driver.WithStack(err)
}
return false, driver.WithStack(err)
}
return false, nil
}
for {
delay := l.ttl / 2
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 renew
}
}
}
|
go
|
{
"resource": ""
}
|
q5629
|
User
|
train
|
func (c *client) User(ctx context.Context, name string) (User, error) {
escapedName := pathEscape(name)
req, err := c.conn.NewRequest("GET", path.Join("_api/user", escapedName))
if err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); 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
}
|
go
|
{
"resource": ""
}
|
q5630
|
UserExists
|
train
|
func (c *client) UserExists(ctx context.Context, name string) (bool, error) {
escapedName := pathEscape(name)
req, err := c.conn.NewRequest("GET", path.Join("_api", "user", escapedName))
if err != nil {
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)
}
}
|
go
|
{
"resource": ""
}
|
q5631
|
Users
|
train
|
func (c *client) Users(ctx context.Context) ([]User, error) {
req, err := c.conn.NewRequest("GET", "/_api/user")
if err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data listUsersResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]User, 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
}
|
go
|
{
"resource": ""
}
|
q5632
|
CreateUser
|
train
|
func (c *client) CreateUser(ctx context.Context, name string, options *UserOptions) (User, error) {
input := struct {
UserOptions
Name string `json:"user"`
}{
Name: name,
}
if options != nil {
input.UserOptions = *options
}
req, err := c.conn.NewRequest("POST", path.Join("_api/user"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
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
}
|
go
|
{
"resource": ""
}
|
q5633
|
newEdgeCollection
|
train
|
func newEdgeCollection(name string, g *graph) (Collection, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if g == nil {
return nil, WithStack(InvalidArgumentError{Message: "g is nil"})
}
return &edgeCollection{
name: name,
g: g,
conn: g.db.conn,
}, nil
}
|
go
|
{
"resource": ""
}
|
q5634
|
rawCollection
|
train
|
func (c *edgeCollection) rawCollection() Collection {
result, _ := newCollection(c.name, c.g.db)
return result
}
|
go
|
{
"resource": ""
}
|
q5635
|
Statistics
|
train
|
func (c *edgeCollection) Statistics(ctx context.Context) (CollectionStatistics, error) {
result, err := c.rawCollection().Statistics(ctx)
if err != nil {
return CollectionStatistics{}, WithStack(err)
}
return result, nil
}
|
go
|
{
"resource": ""
}
|
q5636
|
SetBody
|
train
|
func (r *vstRequest) SetBody(body ...interface{}) (driver.Request, error) {
switch len(body) {
case 0:
return r, driver.WithStack(fmt.Errorf("Must provide at least 1 body"))
case 1:
if data, err := velocypack.Marshal(body[0]); err != nil {
return r, driver.WithStack(err)
} else {
r.body = data
}
return r, nil
default:
slices := make([]velocypack.Slice, len(body))
for i, b := range body {
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
}
}
|
go
|
{
"resource": ""
}
|
q5637
|
requestType
|
train
|
func (r *vstRequest) requestType() int64 {
switch r.method {
case "DELETE":
return 0
case "GET":
return 1
case "POST":
return 2
case "PUT":
return 3
case "HEAD":
return 4
case "PATCH":
return 5
case "OPTIONS":
return 6
default:
panic(fmt.Errorf("Unknown method '%s'", r.method))
}
}
|
go
|
{
"resource": ""
}
|
q5638
|
newCursor
|
train
|
func newCursor(data cursorData, endpoint string, db *database, allowDirtyReads bool) (Cursor, error) {
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &cursor{
cursorData: data,
endpoint: endpoint,
db: db,
conn: db.conn,
allowDirtyReads: allowDirtyReads,
}, nil
}
|
go
|
{
"resource": ""
}
|
q5639
|
HasMore
|
train
|
func (c *cursor) HasMore() bool {
return c.resultIndex < len(c.Result) || c.cursorData.HasMore
}
|
go
|
{
"resource": ""
}
|
q5640
|
Close
|
train
|
func (c *cursor) Close() error {
if c == nil {
// Avoid panics in the case that someone defer's a close before checking that the cursor is not nil.
return nil
}
if c := atomic.LoadInt32(&c.closed); c != 0 {
return nil
}
c.closeMutex.Lock()
defer c.closeMutex.Unlock()
if c.closed == 0 {
if c.cursorData.ID != "" {
// Force use of initial endpoint
ctx := WithEndpoint(nil, c.endpoint)
req, err := c.conn.NewRequest("DELETE", path.Join(c.relPath(), c.cursorData.ID))
if err != 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
}
|
go
|
{
"resource": ""
}
|
q5641
|
ReadDocument
|
train
|
func (c *cursor) ReadDocument(ctx context.Context, result interface{}) (DocumentMeta, error) {
// Force use of initial endpoint
ctx = WithEndpoint(ctx, c.endpoint)
if c.resultIndex >= len(c.Result) && c.cursorData.HasMore {
// This is required since we are interested if this was a dirty read
// but we do not want to trash the users bool reference.
var wasDirtyRead bool
fetchctx := ctx
if c.allowDirtyReads {
fetchctx = WithAllowDirtyReads(ctx, &wasDirtyRead)
}
// Fetch next batch
req, err := c.conn.NewRequest("PUT", path.Join(c.relPath(), c.cursorData.ID))
if err != nil {
return DocumentMeta{}, WithStack(err)
}
cs := applyContextSettings(fetchctx, req)
resp, err := c.conn.Do(fetchctx, req)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return DocumentMeta{}, WithStack(err)
}
loadContextResponseValues(cs, resp)
var data cursorData
if err := resp.ParseBody("", &data); err != nil {
return DocumentMeta{}, WithStack(err)
}
c.cursorData = data
c.resultIndex = 0
c.lastReadWasDirty = wasDirtyRead
}
// ReadDocument should act as if it would actually do a read
// 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 resultPtr == nil {
// Got NULL result
rv := reflect.ValueOf(result)
if rv.Kind() != reflect.Ptr || rv.IsNil() {
return DocumentMeta{}, WithStack(&json.InvalidUnmarshalError{Type: reflect.TypeOf(result)})
}
e := rv.Elem()
e.Set(reflect.Zero(e.Type()))
} else {
if err := c.conn.Unmarshal(*resultPtr, &meta); err != nil {
// If a cursor returns something other than a document, this will fail.
// Just ignore it.
}
if err := c.conn.Unmarshal(*resultPtr, result); err != nil {
return DocumentMeta{}, WithStack(err)
}
}
return meta, nil
}
|
go
|
{
"resource": ""
}
|
q5642
|
SetQuery
|
train
|
func (r *httpJSONRequest) SetQuery(key, value string) driver.Request {
if r.q == nil {
r.q = url.Values{}
}
r.q.Set(key, value)
return r
}
|
go
|
{
"resource": ""
}
|
q5643
|
SetHeader
|
train
|
func (r *httpJSONRequest) SetHeader(key, value string) driver.Request {
if r.hdr == nil {
r.hdr = make(map[string]string)
}
r.hdr[key] = value
return r
}
|
go
|
{
"resource": ""
}
|
q5644
|
WithAllowNoLeader
|
train
|
func WithAllowNoLeader(parent context.Context) context.Context {
if parent == nil {
parent = context.Background()
}
return context.WithValue(parent, keyAllowNoLeader, true)
}
|
go
|
{
"resource": ""
}
|
q5645
|
hasAllowNoLeader
|
train
|
func hasAllowNoLeader(ctx context.Context) bool {
return ctx != nil && ctx.Value(keyAllowNoLeader) != nil
}
|
go
|
{
"resource": ""
}
|
q5646
|
AreAgentsHealthy
|
train
|
func AreAgentsHealthy(ctx context.Context, clients []driver.Connection) error {
wg := sync.WaitGroup{}
invalidKey := []string{"does-not-exist-70ddb948-59ea-52f3-9a19-baaca18de7ae"}
statuses := make([]agentStatus, len(clients))
for i, c := range clients {
wg.Add(1)
go func(i int, c driver.Connection) {
defer wg.Done()
lctx, cancel := context.WithTimeout(ctx, maxAgentResponseTime)
defer cancel()
var result interface{}
a, err := NewAgency(c)
if err == nil {
var resp driver.Response
lctx = driver.WithResponse(lctx, &resp)
if err := a.ReadKey(lctx, invalidKey, &result); err == nil || IsKeyNotFound(err) {
// We got a valid read from the leader
statuses[i].IsLeader = true
statuses[i].LeaderEndpoint = strings.Join(c.Endpoints(), ",")
statuses[i].IsResponding = true
} else {
if driver.IsArangoErrorWithCode(err, 307) && resp != nil {
location := resp.Header("Location")
// Valid response from a follower
statuses[i].IsLeader = false
statuses[i].LeaderEndpoint = location
statuses[i].IsResponding = true
} else {
// Unexpected / invalid response
statuses[i].IsResponding = false
}
}
}
}(i, c)
}
wg.Wait()
// Check the results
noLeaders := 0
for i, status := range statuses {
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.LeaderEndpoint) {
return driver.WithStack(fmt.Errorf("Not all agents report the same leader endpoint"))
}
}
}
if noLeaders != 1 && !hasAllowNoLeader(ctx) {
return driver.WithStack(fmt.Errorf("Unexpected number of agency leaders: %d", noLeaders))
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5647
|
IsSameEndpoint
|
train
|
func IsSameEndpoint(a, b string) bool {
if a == b {
return true
}
ua, err := url.Parse(a)
if err != nil {
return false
}
ub, err := url.Parse(b)
if err != nil {
return false
}
return ua.Hostname() == ub.Hostname()
}
|
go
|
{
"resource": ""
}
|
q5648
|
Indexes
|
train
|
func (c *collection) Indexes(ctx context.Context) ([]Index, error) {
req, err := c.conn.NewRequest("GET", path.Join(c.db.relPath(), "_api", "index"))
if err != nil {
return nil, WithStack(err)
}
req.SetQuery("collection", c.name)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data indexListResponse
if err := resp.ParseBody("", &data); err != nil {
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
}
|
go
|
{
"resource": ""
}
|
q5649
|
newUser
|
train
|
func newUser(data userData, conn Connection) (User, error) {
if data.Name == "" {
return nil, WithStack(InvalidArgumentError{Message: "data.Name is empty"})
}
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &user{
data: data,
conn: conn,
}, nil
}
|
go
|
{
"resource": ""
}
|
q5650
|
Remove
|
train
|
func (u *user) Remove(ctx context.Context) error {
req, err := u.conn.NewRequest("DELETE", u.relPath())
if err != nil {
return WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(202); err != nil {
return WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5651
|
Update
|
train
|
func (u *user) Update(ctx context.Context, options UserOptions) error {
req, err := u.conn.NewRequest("PATCH", u.relPath())
if err != nil {
return WithStack(err)
}
if _, err := req.SetBody(options); 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)
}
var data userData
if err := resp.ParseBody("", &data); err != nil {
return WithStack(err)
}
u.data = data
return nil
}
|
go
|
{
"resource": ""
}
|
q5652
|
AccessibleDatabases
|
train
|
func (u *user) AccessibleDatabases(ctx context.Context) ([]Database, error) {
req, err := u.conn.NewRequest("GET", path.Join(u.relPath(), "database"))
if err != nil {
return nil, WithStack(err)
}
resp, err := u.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data userAccessibleDatabasesResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
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
}
|
go
|
{
"resource": ""
}
|
q5653
|
SetDatabaseAccess
|
train
|
func (u *user) SetDatabaseAccess(ctx context.Context, db Database, access Grant) error {
dbName, _, err := getDatabaseAndCollectionName(db)
if err != nil {
return WithStack(err)
}
escapedDbName := pathEscape(dbName)
req, err := u.conn.NewRequest("PUT", path.Join(u.relPath(), "database", escapedDbName))
if err != nil {
return WithStack(err)
}
input := struct {
Grant Grant `json:"grant"`
}{
Grant: access,
}
if _, 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
}
|
go
|
{
"resource": ""
}
|
q5654
|
GetDatabaseAccess
|
train
|
func (u *user) GetDatabaseAccess(ctx context.Context, db Database) (Grant, error) {
dbName, _, err := getDatabaseAndCollectionName(db)
if err != nil {
return GrantNone, WithStack(err)
}
escapedDbName := pathEscape(dbName)
req, err := u.conn.NewRequest("GET", path.Join(u.relPath(), "database", escapedDbName))
if err != nil {
return GrantNone, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := u.conn.Do(ctx, req)
if err != nil {
return GrantNone, WithStack(err)
}
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
}
|
go
|
{
"resource": ""
}
|
q5655
|
SetCollectionAccess
|
train
|
func (u *user) SetCollectionAccess(ctx context.Context, col AccessTarget, access Grant) error {
dbName, colName, err := getDatabaseAndCollectionName(col)
if err != nil {
return WithStack(err)
}
escapedDbName := pathEscape(dbName)
escapedColName := pathEscape(colName)
req, err := u.conn.NewRequest("PUT", path.Join(u.relPath(), "database", escapedDbName, escapedColName))
if err != nil {
return WithStack(err)
}
input := struct {
Grant Grant `json:"grant"`
}{
Grant: access,
}
if _, 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
}
|
go
|
{
"resource": ""
}
|
q5656
|
GetCollectionAccess
|
train
|
func (u *user) GetCollectionAccess(ctx context.Context, col AccessTarget) (Grant, error) {
dbName, colName, err := getDatabaseAndCollectionName(col)
if err != nil {
return GrantNone, WithStack(err)
}
escapedDbName := pathEscape(dbName)
escapedColName := pathEscape(colName)
req, err := u.conn.NewRequest("GET", path.Join(u.relPath(), "database", escapedDbName, escapedColName))
if err != nil {
return GrantNone, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := u.conn.Do(ctx, req)
if err != nil {
return GrantNone, WithStack(err)
}
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
}
|
go
|
{
"resource": ""
}
|
q5657
|
RemoveCollectionAccess
|
train
|
func (u *user) RemoveCollectionAccess(ctx context.Context, col AccessTarget) error {
dbName, colName, err := getDatabaseAndCollectionName(col)
if err != nil {
return WithStack(err)
}
escapedDbName := pathEscape(dbName)
escapedColName := pathEscape(colName)
req, err := u.conn.NewRequest("DELETE", path.Join(u.relPath(), "database", escapedDbName, escapedColName))
if err != nil {
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
}
|
go
|
{
"resource": ""
}
|
q5658
|
getDatabaseAndCollectionName
|
train
|
func getDatabaseAndCollectionName(col AccessTarget) (string, string, error) {
if col == nil {
return "*", "*", nil
}
if x, ok := col.(Collection); ok {
return x.Database().Name(), x.Name(), nil
}
if x, ok := col.(Database); ok {
return x.Name(), "*", nil
}
return "", "", WithStack(InvalidArgumentError{"Need Collection or Database or nil"})
}
|
go
|
{
"resource": ""
}
|
q5659
|
WithQueryCount
|
train
|
func WithQueryCount(parent context.Context, value ...bool) context.Context {
v := true
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryCount, v)
}
|
go
|
{
"resource": ""
}
|
q5660
|
WithQueryBatchSize
|
train
|
func WithQueryBatchSize(parent context.Context, value int) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryBatchSize, value)
}
|
go
|
{
"resource": ""
}
|
q5661
|
WithQueryCache
|
train
|
func WithQueryCache(parent context.Context, value ...bool) context.Context {
v := true
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryCache, v)
}
|
go
|
{
"resource": ""
}
|
q5662
|
WithQueryMemoryLimit
|
train
|
func WithQueryMemoryLimit(parent context.Context, value int64) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryMemoryLimit, value)
}
|
go
|
{
"resource": ""
}
|
q5663
|
WithQueryTTL
|
train
|
func WithQueryTTL(parent context.Context, value time.Duration) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryTTL, value)
}
|
go
|
{
"resource": ""
}
|
q5664
|
WithQuerySatelliteSyncWait
|
train
|
func WithQuerySatelliteSyncWait(parent context.Context, value time.Duration) context.Context {
return context.WithValue(contextOrBackground(parent), keyQueryOptSatSyncWait, value)
}
|
go
|
{
"resource": ""
}
|
q5665
|
WithQueryFullCount
|
train
|
func WithQueryFullCount(parent context.Context, value ...bool) context.Context {
v := true
if len(value) > 0 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyQueryOptFullCount, v)
}
|
go
|
{
"resource": ""
}
|
q5666
|
applyContextSettings
|
train
|
func (q *queryRequest) applyContextSettings(ctx context.Context) {
if ctx == nil {
return
}
if rawValue := ctx.Value(keyQueryCount); rawValue != nil {
if value, ok := rawValue.(bool); ok {
q.Count = value
}
}
if rawValue := ctx.Value(keyQueryBatchSize); rawValue != nil {
if value, ok := rawValue.(int); ok {
q.BatchSize = value
}
}
if rawValue := ctx.Value(keyQueryCache); rawValue != nil {
if value, ok := rawValue.(bool); ok {
q.Cache = value
}
}
if rawValue := ctx.Value(keyQueryMemoryLimit); rawValue != 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.(time.Duration); ok {
q.Options.SatelliteSyncWait = value.Seconds()
}
}
if rawValue := ctx.Value(keyQueryOptFullCount); rawValue != nil {
if value, ok := rawValue.(bool); ok {
q.Options.FullCount = value
}
}
if rawValue := ctx.Value(keyQueryOptStream); rawValue != nil {
if value, ok := rawValue.(bool); ok {
q.Options.Stream = value
}
}
}
|
go
|
{
"resource": ""
}
|
q5667
|
Graph
|
train
|
func (d *database) Graph(ctx context.Context, name string) (Graph, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/gharial", escapedName))
if err != 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
}
|
go
|
{
"resource": ""
}
|
q5668
|
Graphs
|
train
|
func (d *database) Graphs(ctx context.Context) ([]Graph, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/gharial"))
if err != 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)
}
var data getGraphsResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
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
}
|
go
|
{
"resource": ""
}
|
q5669
|
CreateGraph
|
train
|
func (d *database) CreateGraph(ctx context.Context, name string, options *CreateGraphOptions) (Graph, error) {
input := createGraphOptions{
Name: name,
}
if options != nil {
input.OrphanVertexCollections = options.OrphanVertexCollections
input.EdgeDefinitions = options.EdgeDefinitions
input.IsSmart = options.IsSmart
if options.SmartGraphAttribute != "" || options.NumberOfShards != 0 {
input.Options = &createGraphAdditionalOptions{
SmartGraphAttribute: options.SmartGraphAttribute,
NumberOfShards: options.NumberOfShards,
}
}
}
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/gharial"))
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, d)
if err != nil {
return nil, WithStack(err)
}
return g, nil
}
|
go
|
{
"resource": ""
}
|
q5670
|
Clone
|
train
|
func (r *httpVPackRequest) Clone() driver.Request {
clone := *r
clone.q = url.Values{}
for k, v := range r.q {
for _, x := range v {
clone.q.Add(k, x)
}
}
if clone.hdr != nil {
clone.hdr = make(map[string]string)
for k, v := range r.hdr {
clone.hdr[k] = v
}
}
return &clone
}
|
go
|
{
"resource": ""
}
|
q5671
|
SetBody
|
train
|
func (r *httpVPackRequest) SetBody(body ...interface{}) (driver.Request, error) {
switch len(body) {
case 0:
return r, driver.WithStack(fmt.Errorf("Must provide at least 1 body"))
case 1:
if data, err := velocypack.Marshal(body[0]); err != nil {
return r, driver.WithStack(err)
} else {
r.body = data
}
return r, nil
case 2:
mo := mergeObject{Object: body[1], Merge: 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"))
}
}
|
go
|
{
"resource": ""
}
|
q5672
|
Contains
|
train
|
func (ps ProtocolSet) Contains(p Protocol) bool {
for _, x := range ps {
if x == p {
return true
}
}
return false
}
|
go
|
{
"resource": ""
}
|
q5673
|
ContainsAny
|
train
|
func (ps ProtocolSet) ContainsAny(p ...Protocol) bool {
for _, x := range ps {
for _, y := range p {
if x == y {
return true
}
}
}
return false
}
|
go
|
{
"resource": ""
}
|
q5674
|
Shutdown
|
train
|
func (c *client) Shutdown(ctx context.Context, removeFromCluster bool) error {
req, err := c.conn.NewRequest("DELETE", "_admin/shutdown")
if err != nil {
return WithStack(err)
}
if removeFromCluster {
req.SetQuery("remove_from_cluster", "1")
}
resp, err := c.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5675
|
EdgeCollection
|
train
|
func (g *graph) EdgeCollection(ctx context.Context, name string) (Collection, VertexConstraints, error) {
req, err := g.conn.NewRequest("GET", g.relPath())
if err != nil {
return nil, VertexConstraints{}, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, VertexConstraints{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, VertexConstraints{}, WithStack(err)
}
var data getGraphResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, VertexConstraints{}, WithStack(err)
}
for _, n := range data.Graph.EdgeDefinitions {
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(404, 0, "not found"))
}
|
go
|
{
"resource": ""
}
|
q5676
|
EdgeCollectionExists
|
train
|
func (g *graph) EdgeCollectionExists(ctx context.Context, name string) (bool, error) {
req, err := g.conn.NewRequest("GET", g.relPath())
if err != nil {
return false, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
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, nil
}
}
return false, nil
}
|
go
|
{
"resource": ""
}
|
q5677
|
EdgeCollections
|
train
|
func (g *graph) EdgeCollections(ctx context.Context) ([]Collection, []VertexConstraints, error) {
req, err := g.conn.NewRequest("GET", g.relPath())
if err != nil {
return nil, nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, nil, WithStack(err)
}
var data getGraphResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, nil, WithStack(err)
}
result := make([]Collection, 0, len(data.Graph.EdgeDefinitions))
constraints := make([]VertexConstraints, 0, len(data.Graph.EdgeDefinitions))
for _, n := 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
}
|
go
|
{
"resource": ""
}
|
q5678
|
newView
|
train
|
func newView(name string, viewType ViewType, db *database) (View, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if viewType == "" {
return nil, WithStack(InvalidArgumentError{Message: "viewType is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &view{
name: name,
viewType: viewType,
db: db,
conn: db.conn,
}, nil
}
|
go
|
{
"resource": ""
}
|
q5679
|
ArangoSearchView
|
train
|
func (v *view) ArangoSearchView() (ArangoSearchView, error) {
if v.viewType != ViewTypeArangoSearch {
return nil, WithStack(newArangoError(http.StatusConflict, 0, fmt.Sprintf("Type must be '%s', got '%s'", ViewTypeArangoSearch, v.viewType)))
}
return &viewArangoSearch{view: *v}, nil
}
|
go
|
{
"resource": ""
}
|
q5680
|
Remove
|
train
|
func (v *view) Remove(ctx context.Context) error {
req, err := v.conn.NewRequest("DELETE", v.relPath())
if err != nil {
return WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := v.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5681
|
newCluster
|
train
|
func newCluster(conn Connection) (Cluster, error) {
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &cluster{
conn: conn,
}, nil
}
|
go
|
{
"resource": ""
}
|
q5682
|
MoveShard
|
train
|
func (c *cluster) MoveShard(ctx context.Context, col Collection, shard ShardID, fromServer, toServer ServerID) error {
req, err := c.conn.NewRequest("POST", "_admin/cluster/moveShard")
if err != nil {
return WithStack(err)
}
input := moveShardRequest{
Database: col.Database().Name(),
Collection: col.Name(),
Shard: shard,
FromServer: fromServer,
ToServer: toServer,
}
if _, err := req.SetBody(input); err != 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
}
|
go
|
{
"resource": ""
}
|
q5683
|
CleanOutServer
|
train
|
func (c *cluster) CleanOutServer(ctx context.Context, serverID string) error {
req, err := c.conn.NewRequest("POST", "_admin/cluster/cleanOutServer")
if err != nil {
return WithStack(err)
}
input := cleanOutServerRequest{
Server: serverID,
}
if _, err := req.SetBody(input); err != nil {
return WithStack(err)
}
cs := 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)
}
var result cleanOutServerResponse
if err := resp.ParseBody("", &result); err != nil {
return WithStack(err)
}
if cs.JobIDResponse != nil {
*cs.JobIDResponse = result.JobID
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5684
|
IsCleanedOut
|
train
|
func (c *cluster) IsCleanedOut(ctx context.Context, serverID string) (bool, error) {
r, err := c.NumberOfServers(ctx)
if err != nil {
return false, WithStack(err)
}
for _, id := range r.CleanedServerIDs {
if id == serverID {
return true, nil
}
}
return false, nil
}
|
go
|
{
"resource": ""
}
|
q5685
|
NumberOfServers
|
train
|
func (c *cluster) NumberOfServers(ctx context.Context) (NumberOfServersResponse, error) {
req, err := c.conn.NewRequest("GET", "_admin/cluster/numberOfServers")
if err != nil {
return NumberOfServersResponse{}, WithStack(err)
}
applyContextSettings(ctx, req)
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 NumberOfServersResponse{}, WithStack(err)
}
return result, nil
}
|
go
|
{
"resource": ""
}
|
q5686
|
RemoveServer
|
train
|
func (c *cluster) RemoveServer(ctx context.Context, serverID ServerID) error {
req, err := c.conn.NewRequest("POST", "_admin/cluster/removeServer")
if err != nil {
return WithStack(err)
}
if _, err := req.SetBody(serverID); err != nil {
return WithStack(err)
}
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
}
|
go
|
{
"resource": ""
}
|
q5687
|
UnmarshalJSON
|
train
|
func (p *InventoryCollectionParameters) UnmarshalJSON(d []byte) error {
var internal inventoryCollectionParametersInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(internal)
return nil
}
|
go
|
{
"resource": ""
}
|
q5688
|
MarshalJSON
|
train
|
func (r replicationFactor) MarshalJSON() ([]byte, error) {
var replicationFactor interface{}
if int(r) == ReplicationFactorSatellite {
replicationFactor = replicationFactorSatelliteString
} else {
replicationFactor = int(r)
}
return json.Marshal(replicationFactor)
}
|
go
|
{
"resource": ""
}
|
q5689
|
UnmarshalJSON
|
train
|
func (r *replicationFactor) UnmarshalJSON(d []byte) error {
var internal interface{}
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
if i, ok := internal.(float64); ok {
*r = replicationFactor(i)
return nil
} else if str, ok := internal.(string); ok {
if ok && str == replicationFactorSatelliteString {
*r = replicationFactor(ReplicationFactorSatellite)
return nil
}
}
return &json.UnmarshalTypeError{
Value: string(d),
Type: reflect.TypeOf(r).Elem(),
}
}
|
go
|
{
"resource": ""
}
|
q5690
|
NewAgency
|
train
|
func NewAgency(conn driver.Connection) (Agency, error) {
return &agency{
conn: conn,
}, nil
}
|
go
|
{
"resource": ""
}
|
q5691
|
ReadKey
|
train
|
func (c *agency) ReadKey(ctx context.Context, key []string, value interface{}) error {
conn := c.conn
req, err := conn.NewRequest("POST", "_api/agency/read")
if err != nil {
return driver.WithStack(err)
}
fullKey := createFullKey(key)
input := [][]string{{fullKey}}
req, err = req.SetBody(input)
if err != nil {
return driver.WithStack(err)
}
//var raw []byte
//ctx = driver.WithRawResponse(ctx, &raw)
resp, err := conn.Do(ctx, req)
if err != nil {
return driver.WithStack(err)
}
if err := resp.CheckStatus(200, 201, 202); err != nil {
return driver.WithStack(err)
}
//fmt.Printf("Agent response: %s\n", string(raw))
elems, err := resp.ParseArrayBody()
if err != nil {
return driver.WithStack(err)
}
if len(elems) != 1 {
return driver.WithStack(fmt.Errorf("Expected 1 element, got %d", len(elems)))
}
// If empty key parse directly
if len(key) == 0 {
if err := elems[0].ParseBody("", &value); err != nil {
return driver.WithStack(err)
}
} else {
// Now remove all wrapping objects for each key element
var rawObject map[string]interface{}
if err := elems[0].ParseBody("", &rawObject); err != nil {
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]))
}
}
var found bool
rawMsg, found = rawObject[key[keyIndex]]
if !found {
return driver.WithStack(KeyNotFoundError{Key: key[:keyIndex+1]})
}
}
// Encode to json ...
encoded, err := json.Marshal(rawMsg)
if err != nil {
return driver.WithStack(err)
}
// and decode back into result
if err := json.Unmarshal(encoded, &value); err != nil {
return driver.WithStack(err)
}
}
// fmt.Printf("result as JSON: %s\n", rawResult)
return nil
}
|
go
|
{
"resource": ""
}
|
q5692
|
WriteKeyIfEmpty
|
train
|
func (c *agency) WriteKeyIfEmpty(ctx context.Context, key []string, value interface{}, ttl time.Duration) error {
var cond WriteCondition
cond = cond.IfEmpty(key)
if err := c.write(ctx, "set", key, value, cond, ttl); err != nil {
return driver.WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5693
|
WriteKeyIfEqualTo
|
train
|
func (c *agency) WriteKeyIfEqualTo(ctx context.Context, key []string, newValue, oldValue interface{}, ttl time.Duration) error {
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
}
|
go
|
{
"resource": ""
}
|
q5694
|
write
|
train
|
func (c *agency) write(ctx context.Context, operation string, key []string, value interface{}, condition WriteCondition, ttl time.Duration) error {
conn := c.conn
req, err := conn.NewRequest("POST", "_api/agency/write")
if err != nil {
return driver.WithStack(err)
}
fullKey := createFullKey(key)
writeTxs := writeTransactions{
writeTransaction{
// Update
map[string]interface{}{
fullKey: writeUpdate{
Operation: operation,
New: value,
TTL: int64(ttl.Seconds()),
},
},
// Condition
condition.toMap(),
},
}
req, err = req.SetBody(writeTxs)
if err != nil {
return driver.WithStack(err)
}
resp, err := conn.Do(ctx, req)
if err != nil {
return driver.WithStack(err)
}
var result writeResult
if err := resp.CheckStatus(200, 201, 202); err != 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)))
}
// If results[0] == 0, condition failed, otherwise success
if result.Results[0] == 0 {
// Condition failed
return driver.WithStack(preconditionFailedError)
}
// Success
return nil
}
|
go
|
{
"resource": ""
}
|
q5695
|
RemoveKeyIfEqualTo
|
train
|
func (c *agency) RemoveKeyIfEqualTo(ctx context.Context, key []string, oldValue interface{}) error {
var cond WriteCondition
cond = cond.IfEqualTo(key, oldValue)
if err := c.write(ctx, "delete", key, nil, cond, 0); err != nil {
return driver.WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5696
|
RegisterChangeCallback
|
train
|
func (c *agency) RegisterChangeCallback(ctx context.Context, key []string, cbURL string) error {
conn := c.conn
req, err := conn.NewRequest("POST", "_api/agency/write")
if err != nil {
return driver.WithStack(err)
}
fullKey := createFullKey(key)
writeTxs := writeTransactions{
writeTransaction{
// Update
map[string]interface{}{
fullKey: writeUpdate{
Operation: "observe",
URL: cbURL,
},
},
},
}
req, err = req.SetBody(writeTxs)
if err != nil {
return driver.WithStack(err)
}
resp, err := conn.Do(ctx, req)
if err != nil {
return driver.WithStack(err)
}
var result writeResult
if err := resp.CheckStatus(200, 201, 202); err != 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
}
|
go
|
{
"resource": ""
}
|
q5697
|
CreateArangodJwtAuthorizationHeader
|
train
|
func CreateArangodJwtAuthorizationHeader(jwtSecret, serverID string) (string, error) {
if jwtSecret == "" || serverID == "" {
return "", nil
}
// Create a new token object, specifying signing method and the claims
// you would like it to contain.
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 "bearer " + signedToken, nil
}
|
go
|
{
"resource": ""
}
|
q5698
|
decodeObjectFields
|
train
|
func decodeObjectFields(objValue reflect.Value, body map[string]*json.RawMessage) error {
objValueType := objValue.Type()
for i := 0; i != objValue.NumField(); i++ {
f := objValueType.Field(i)
if f.Anonymous {
// Recurse into fields of anonymous field
if err := decodeObjectFields(objValue.Field(i), body); err != nil {
return driver.WithStack(err)
}
} else {
// Decode individual field
jsonName := strings.Split(f.Tag.Get("json"), ",")[0]
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
}
|
go
|
{
"resource": ""
}
|
q5699
|
decodeMapFields
|
train
|
func decodeMapFields(val reflect.Value, body map[string]*json.RawMessage) error {
mapVal := val
if mapVal.IsNil() {
valType := val.Type()
mapType := reflect.MapOf(valType.Key(), valType.Elem())
mapVal = reflect.MakeMap(mapType)
}
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
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.