_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q5700 | newDatabase | train | func newDatabase(name string, conn Connection) (Database, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if conn == nil {
return nil, WithStack(InvalidArgumentError{Message: "conn is nil"})
}
return &database{
name: name,
conn: conn,
}, nil
} | go | {
"resource": ""
} |
q5701 | Info | train | func (d *database) Info(ctx context.Context) (DatabaseInfo, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/database/current"))
if err != nil {
return DatabaseInfo{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return DatabaseInfo{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return DatabaseInfo{}, WithStack(err)
}
var data DatabaseInfo
if err := resp.ParseBody("result", &data); err != nil {
return DatabaseInfo{}, WithStack(err)
}
return data, nil
} | go | {
"resource": ""
} |
q5702 | Remove | train | func (d *database) Remove(ctx context.Context) error {
req, err := d.conn.NewRequest("DELETE", path.Join("_db/_system/_api/database", pathEscape(d.name)))
if err != nil {
return WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5703 | Query | train | func (d *database) Query(ctx context.Context, query string, bindVars map[string]interface{}) (Cursor, error) {
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/cursor"))
if err != nil {
return nil, WithStack(err)
}
input := queryRequest{
Query: query,
BindVars: bindVars,
}
input.applyContextSettings(ctx)
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
cs := applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
var data cursorData
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
col, err := newCursor(data, resp.Endpoint(), d, cs.AllowDirtyReads)
if err != nil {
return nil, WithStack(err)
}
return col, nil
} | go | {
"resource": ""
} |
q5704 | ValidateQuery | train | func (d *database) ValidateQuery(ctx context.Context, query string) error {
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/query"))
if err != nil {
return WithStack(err)
}
input := parseQueryRequest{
Query: query,
}
if _, err := req.SetBody(input); err != nil {
return WithStack(err)
}
resp, err := d.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5705 | Database | train | func (c *client) Database(ctx context.Context, name string) (Database, error) {
escapedName := pathEscape(name)
req, err := c.conn.NewRequest("GET", path.Join("_db", escapedName, "_api/database/current"))
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)
}
db, err := newDatabase(name, c.conn)
if err != nil {
return nil, WithStack(err)
}
return db, nil
} | go | {
"resource": ""
} |
q5706 | AccessibleDatabases | train | func (c *client) AccessibleDatabases(ctx context.Context) ([]Database, error) {
result, err := listDatabases(ctx, c.conn, path.Join("/_db/_system/_api/database/user"))
if err != nil {
return nil, WithStack(err)
}
return result, nil
} | go | {
"resource": ""
} |
q5707 | listDatabases | train | func listDatabases(ctx context.Context, conn Connection, path string) ([]Database, error) {
req, err := conn.NewRequest("GET", path)
if err != nil {
return nil, WithStack(err)
}
resp, err := conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data getDatabaseResponse
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, conn)
if err != nil {
return nil, WithStack(err)
}
result = append(result, db)
}
return result, nil
} | go | {
"resource": ""
} |
q5708 | CreateDatabase | train | func (c *client) CreateDatabase(ctx context.Context, name string, options *CreateDatabaseOptions) (Database, error) {
input := struct {
CreateDatabaseOptions
Name string `json:"name"`
}{
Name: name,
}
if options != nil {
input.CreateDatabaseOptions = *options
}
req, err := c.conn.NewRequest("POST", path.Join("_db/_system/_api/database"))
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)
}
db, err := newDatabase(name, c.conn)
if err != nil {
return nil, WithStack(err)
}
return db, nil
} | go | {
"resource": ""
} |
q5709 | Cluster | train | func (c *client) Cluster(ctx context.Context) (Cluster, error) {
role, err := c.ServerRole(ctx)
if err != nil {
return nil, WithStack(err)
}
if role == ServerRoleSingle || role == ServerRoleSingleActive || role == ServerRoleSinglePassive {
// Standalone server, this is wrong
return nil, WithStack(newArangoError(412, 0, "Cluster expected, found SINGLE server"))
}
cl, err := newCluster(c.conn)
if err != nil {
return nil, WithStack(err)
}
return cl, nil
} | go | {
"resource": ""
} |
q5710 | CreateBatch | train | func (c *client) CreateBatch(ctx context.Context, db Database, serverID int64, ttl time.Duration) (Batch, error) {
req, err := c.conn.NewRequest("POST", path.Join("_db", db.Name(), "_api/replication/batch"))
if err != nil {
return nil, WithStack(err)
}
req = req.SetQuery("serverId", strconv.FormatInt(serverID, 10))
params := struct {
TTL float64 `json:"ttl"`
}{TTL: ttl.Seconds()} // just use a default ttl value
req, err = req.SetBody(params)
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 batch batchMetadata
if err := resp.ParseBody("", &batch); err != nil {
return nil, WithStack(err)
}
batch.cl = c
batch.serverID = serverID
batch.database = db.Name()
return &batch, nil
} | go | {
"resource": ""
} |
q5711 | Extend | train | func (b batchMetadata) Extend(ctx context.Context, ttl time.Duration) error {
if !atomic.CompareAndSwapInt32(&b.closed, 0, 0) {
return WithStack(errors.New("Batch already closed"))
}
req, err := b.cl.conn.NewRequest("PUT", path.Join("_db", b.database, "_api/replication/batch", b.ID))
if err != nil {
return WithStack(err)
}
req = req.SetQuery("serverId", strconv.FormatInt(b.serverID, 10))
input := struct {
TTL int64 `json:"ttl"`
}{
TTL: int64(ttl.Seconds()),
}
req, err = req.SetBody(input)
if err != nil {
return WithStack(err)
}
resp, err := b.cl.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(204); err != nil {
return WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5712 | Delete | train | func (b *batchMetadata) Delete(ctx context.Context) error {
if !atomic.CompareAndSwapInt32(&b.closed, 0, 1) {
return WithStack(errors.New("Batch already closed"))
}
req, err := b.cl.conn.NewRequest("DELETE", path.Join("_db", b.database, "_api/replication/batch", b.ID))
if err != nil {
return WithStack(err)
}
resp, err := b.cl.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(204); err != nil {
return WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5713 | NewConnection | train | func NewConnection(config ConnectionConfig) (driver.Connection, error) {
c, err := cluster.NewConnection(config.ConnectionConfig, func(endpoint string) (driver.Connection, error) {
conn, err := newVSTConnection(endpoint, config)
if err != nil {
return nil, driver.WithStack(err)
}
return conn, nil
}, config.Endpoints)
if err != nil {
return nil, driver.WithStack(err)
}
return c, nil
} | go | {
"resource": ""
} |
q5714 | newVSTConnection | train | func newVSTConnection(endpoint string, config ConnectionConfig) (driver.Connection, error) {
endpoint = util.FixupEndpointURLScheme(endpoint)
u, err := url.Parse(endpoint)
if err != nil {
return nil, driver.WithStack(err)
}
hostAddr := u.Host
tlsConfig := config.TLSConfig
switch strings.ToLower(u.Scheme) {
case "http":
tlsConfig = nil
case "https":
if tlsConfig == nil {
tlsConfig = &tls.Config{}
}
}
c := &vstConnection{
endpoint: *u,
transport: protocol.NewTransport(hostAddr, tlsConfig, config.Transport),
}
return c, nil
} | go | {
"resource": ""
} |
q5715 | closeResponseChan | train | func (m *Message) closeResponseChan() {
if atomic.CompareAndSwapInt32(&m.responseChanClosed, 0, 1) {
if ch := m.responseChan; ch != nil {
m.responseChan = nil
close(ch)
}
}
} | go | {
"resource": ""
} |
q5716 | addChunk | train | func (m *Message) addChunk(c chunk) {
m.chunksMutex.Lock()
defer m.chunksMutex.Unlock()
m.chunks = append(m.chunks, c)
if c.IsFirst() {
m.numberOfChunks = c.NumberOfChunks()
}
} | go | {
"resource": ""
} |
q5717 | assemble | train | func (m *Message) assemble() bool {
m.chunksMutex.Lock()
defer m.chunksMutex.Unlock()
if m.Data != nil {
// Already assembled
return true
}
if m.numberOfChunks == 0 {
// We don't have the first chunk yet
return false
}
if len(m.chunks) < int(m.numberOfChunks) {
// Not all chunks have arrived yet
return false
}
// Fast path, only 1 chunk
if m.numberOfChunks == 1 {
m.Data = m.chunks[0].Data
return true
}
// Sort chunks by index
sort.Sort(chunkByIndex(m.chunks))
// Build data buffer and copy chunks into it
data := make([]byte, m.chunks[0].MessageLength)
offset := 0
for _, c := range m.chunks {
copy(data[offset:], c.Data)
offset += len(c.Data)
}
m.Data = data
return true
} | go | {
"resource": ""
} |
q5718 | IsReady | train | func (i DatabaseInventory) IsReady() bool {
for _, c := range i.Collections {
if !c.IsReady {
return false
}
}
return true
} | go | {
"resource": ""
} |
q5719 | PlanVersion | train | func (i DatabaseInventory) PlanVersion() int64 {
if len(i.Collections) == 0 {
return 0
}
return i.Collections[0].PlanVersion
} | go | {
"resource": ""
} |
q5720 | CollectionByName | train | func (i DatabaseInventory) CollectionByName(name string) (InventoryCollection, bool) {
for _, c := range i.Collections {
if c.Parameters.Name == name {
return c, true
}
}
return InventoryCollection{}, false
} | go | {
"resource": ""
} |
q5721 | ViewByName | train | func (i DatabaseInventory) ViewByName(name string) (InventoryView, bool) {
for _, v := range i.Views {
if v.Name == name {
return v, true
}
}
return InventoryView{}, false
} | go | {
"resource": ""
} |
q5722 | IndexByFieldsAndType | train | func (i InventoryCollection) IndexByFieldsAndType(fields []string, indexType string) (InventoryIndex, bool) {
for _, idx := range i.Indexes {
if idx.Type == indexType && idx.FieldsEqual(fields) {
return idx, true
}
}
return InventoryIndex{}, false
} | go | {
"resource": ""
} |
q5723 | FieldsEqual | train | func (i InventoryIndex) FieldsEqual(fields []string) bool {
return stringSliceEqualsIgnoreOrder(i.Fields, fields)
} | go | {
"resource": ""
} |
q5724 | stringSliceEqualsIgnoreOrder | train | func stringSliceEqualsIgnoreOrder(a, b []string) bool {
if len(a) != len(b) {
return false
}
bMap := make(map[string]struct{})
for _, x := range b {
bMap[x] = struct{}{}
}
for _, x := range a {
if _, found := bMap[x]; !found {
return false
}
}
return true
} | go | {
"resource": ""
} |
q5725 | Size | train | func (s *messageStore) Size() int {
s.mutex.RLock()
defer s.mutex.RUnlock()
return len(s.messages)
} | go | {
"resource": ""
} |
q5726 | Get | train | func (s *messageStore) Get(id uint64) *Message {
s.mutex.RLock()
defer s.mutex.RUnlock()
m, ok := s.messages[id]
if ok {
return m
}
return nil
} | go | {
"resource": ""
} |
q5727 | Add | train | func (s *messageStore) Add(id uint64) *Message {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.messages == nil {
s.messages = make(map[uint64]*Message)
}
if _, ok := s.messages[id]; ok {
panic(fmt.Sprintf("ID %v is not unique", id))
}
m := &Message{
ID: id,
responseChan: make(chan Message),
}
s.messages[id] = m
return m
} | go | {
"resource": ""
} |
q5728 | Remove | train | func (s *messageStore) Remove(id uint64) {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.messages, id)
} | go | {
"resource": ""
} |
q5729 | ForEach | train | func (s *messageStore) ForEach(cb func(*Message)) {
s.mutex.RLock()
defer s.mutex.RUnlock()
for _, m := range s.messages {
cb(m)
}
} | go | {
"resource": ""
} |
q5730 | ReadDocument | train | func (c *edgeCollection) ReadDocument(ctx context.Context, key string, result interface{}) (DocumentMeta, error) {
meta, _, err := c.readDocument(ctx, key, result)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | {
"resource": ""
} |
q5731 | UpdateDocument | train | func (c *edgeCollection) UpdateDocument(ctx context.Context, key string, update interface{}) (DocumentMeta, error) {
meta, _, err := c.updateDocument(ctx, key, update)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | {
"resource": ""
} |
q5732 | getKeyFromDocument | train | func getKeyFromDocument(doc reflect.Value) (string, error) {
if doc.IsNil() {
return "", WithStack(InvalidArgumentError{Message: "Document is nil"})
}
if doc.Kind() == reflect.Ptr {
doc = doc.Elem()
}
switch doc.Kind() {
case reflect.Struct:
structType := doc.Type()
fieldCount := structType.NumField()
for i := 0; i < fieldCount; i++ {
f := structType.Field(i)
tagParts := strings.Split(f.Tag.Get("json"), ",")
if tagParts[0] == "_key" {
// We found the _key field
keyVal := doc.Field(i)
return keyVal.String(), nil
}
}
return "", WithStack(InvalidArgumentError{Message: "Document contains no '_key' field"})
case reflect.Map:
keyVal := doc.MapIndex(reflect.ValueOf("_key"))
if keyVal.IsNil() {
return "", WithStack(InvalidArgumentError{Message: "Document contains no '_key' entry"})
}
return keyVal.String(), nil
default:
return "", WithStack(InvalidArgumentError{Message: fmt.Sprintf("Document must be struct or map. Got %s", doc.Kind())})
}
} | go | {
"resource": ""
} |
q5733 | newAuthenticatedConnection | train | func newAuthenticatedConnection(conn driver.Connection, auth httpAuthentication) (driver.Connection, error) {
if conn == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "conn is nil"})
}
if auth == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "auth is nil"})
}
return &authenticatedConnection{
conn: conn,
auth: auth,
}, nil
} | go | {
"resource": ""
} |
q5734 | prepare | train | func (c *authenticatedConnection) prepare(ctx context.Context) error {
c.prepareMutex.Lock()
defer c.prepareMutex.Unlock()
if c.prepared == 0 {
// We need to prepare first
if err := c.auth.Prepare(ctx, c.conn); err != nil {
// Authentication failed
return driver.WithStack(err)
}
// We're now prepared
atomic.StoreInt32(&c.prepared, 1)
} else {
// We're already prepared, do nothing
}
return nil
} | go | {
"resource": ""
} |
q5735 | NewTransport | train | func NewTransport(hostAddr string, tlsConfig *tls.Config, config TransportConfig) *Transport {
if config.IdleConnTimeout == 0 {
config.IdleConnTimeout = DefaultIdleConnTimeout
}
if config.ConnLimit == 0 {
config.ConnLimit = DefaultConnLimit
}
return &Transport{
TransportConfig: config,
hostAddr: hostAddr,
tlsConfig: tlsConfig,
}
} | go | {
"resource": ""
} |
q5736 | CloseIdleConnections | train | func (c *Transport) CloseIdleConnections() (closed, remaining int) {
c.connMutex.Lock()
defer c.connMutex.Unlock()
for i := 0; i < len(c.connections); {
conn := c.connections[i]
if conn.IsClosed() || conn.IsIdle(c.IdleConnTimeout) {
// Remove connection from list
c.connections = append(c.connections[:i], c.connections[i+1:]...)
// Close connection
go conn.Close()
closed++
} else {
i++
}
}
remaining = len(c.connections)
return closed, remaining
} | go | {
"resource": ""
} |
q5737 | CloseAllConnections | train | func (c *Transport) CloseAllConnections() {
c.connMutex.Lock()
defer c.connMutex.Unlock()
for _, conn := range c.connections {
// Close connection
go conn.Close()
}
} | go | {
"resource": ""
} |
q5738 | SetOnConnectionCreated | train | func (c *Transport) SetOnConnectionCreated(handler func(context.Context, *Connection) error) {
c.onConnectionCreated = handler
} | go | {
"resource": ""
} |
q5739 | getConnection | train | func (c *Transport) getConnection(ctx context.Context) (*Connection, error) {
conn := c.getAvailableConnection()
if conn != nil {
return conn, nil
}
// No connections available, make a new one
conn, err := c.createConnection()
if err != nil {
if conn != nil {
conn.Close()
}
return nil, driver.WithStack(err)
}
// Invoke callback
if cb := c.onConnectionCreated; cb != nil {
if err := cb(ctx, conn); err != nil {
conn.Close()
return nil, driver.WithStack(err)
}
}
// Mark the connection as ready
atomic.StoreInt32(&conn.configured, 1)
return conn, nil
} | go | {
"resource": ""
} |
q5740 | getAvailableConnection | train | func (c *Transport) getAvailableConnection() *Connection {
c.connMutex.Lock()
defer c.connMutex.Unlock()
// Select the connection with the least amount of traffic
var bestConn *Connection
bestConnLoad := 0
activeConnCount := 0
for _, conn := range c.connections {
if !conn.IsClosed() {
activeConnCount++
if conn.IsConfigured() {
connLoad := conn.load()
if bestConn == nil || connLoad < bestConnLoad {
bestConn = conn
bestConnLoad = connLoad
}
}
}
}
if bestConn == nil {
// No connections available
return nil
}
// Is load is >0 AND the number of connections is below the limit, create a new one
if bestConnLoad > 0 && activeConnCount < c.ConnLimit {
return nil
}
// Use the best connection found
bestConn.updateLastActivity()
return bestConn
} | go | {
"resource": ""
} |
q5741 | createConnection | train | func (c *Transport) createConnection() (*Connection, error) {
conn, err := dial(c.Version, c.hostAddr, c.tlsConfig)
if err != nil {
return nil, driver.WithStack(err)
}
// Record connection
c.connMutex.Lock()
c.connections = append(c.connections, conn)
startCleanup := len(c.connections) == 1
c.connMutex.Unlock()
if startCleanup {
// TODO enable cleanup
go c.cleanup()
}
return conn, nil
} | go | {
"resource": ""
} |
q5742 | cleanup | train | func (c *Transport) cleanup() {
for {
time.Sleep(c.IdleConnTimeout / 10)
_, remaining := c.CloseIdleConnections()
if remaining == 0 {
return
}
}
} | go | {
"resource": ""
} |
q5743 | Do | train | func (c *agencyConnection) Do(ctx context.Context, req driver.Request) (driver.Response, error) {
if ctx == nil {
ctx = context.Background()
}
deadline, ok := ctx.Deadline()
if !ok {
deadline = time.Now().Add(time.Second * 30)
}
timeout := time.Until(deadline)
if timeout < minAgencyTimeout {
timeout = minAgencyTimeout
}
attempt := 1
delay := agencyConnectionFailureBackoff(0)
for {
lctx, cancel := context.WithTimeout(ctx, timeout/3)
resp, isPerm, err := c.doOnce(lctx, req)
cancel()
if err == nil {
// Success
return resp, nil
} else if isPerm {
// Permanent error
return nil, driver.WithStack(err)
}
// Is deadline exceeded?
if time.Now().After(deadline) {
return nil, driver.WithStack(fmt.Errorf("All %d attemps resulted in temporary failure", attempt))
}
// Just retry
attempt++
delay = agencyConnectionFailureBackoff(delay)
// Wait a bit so we don't hammer the agency
select {
case <-time.After(delay):
// Continue
case <-ctx.Done():
// Context canceled
return nil, driver.WithStack(ctx.Err())
}
}
} | go | {
"resource": ""
} |
q5744 | agencyConnectionFailureBackoff | train | func agencyConnectionFailureBackoff(lastDelay time.Duration) time.Duration {
return increaseDelay(lastDelay, 1.5, time.Millisecond, time.Second*2)
} | go | {
"resource": ""
} |
q5745 | increaseDelay | train | func increaseDelay(oldDelay time.Duration, factor float64, min, max time.Duration) time.Duration {
delay := time.Duration(float64(oldDelay) * factor)
if delay < min {
delay = min
}
if delay > max {
delay = max
}
return delay
} | go | {
"resource": ""
} |
q5746 | Properties | train | func (v *viewArangoSearch) Properties(ctx context.Context) (ArangoSearchViewProperties, error) {
req, err := v.conn.NewRequest("GET", path.Join(v.relPath(), "properties"))
if err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := v.conn.Do(ctx, req)
if err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
var data ArangoSearchViewProperties
if err := resp.ParseBody("", &data); err != nil {
return ArangoSearchViewProperties{}, WithStack(err)
}
return data, nil
} | go | {
"resource": ""
} |
q5747 | SetProperties | train | func (v *viewArangoSearch) SetProperties(ctx context.Context, options ArangoSearchViewProperties) error {
req, err := v.conn.NewRequest("PUT", path.Join(v.relPath(), "properties"))
if err != nil {
return WithStack(err)
}
if _, err := req.SetBody(options); 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": ""
} |
q5748 | NewConnection | train | func NewConnection(config ConnectionConfig, connectionBuilder ServerConnectionBuilder, endpoints []string) (driver.Connection, error) {
if connectionBuilder == nil {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "Must a connection builder"})
}
if len(endpoints) == 0 {
return nil, driver.WithStack(driver.InvalidArgumentError{Message: "Must provide at least 1 endpoint"})
}
if config.DefaultTimeout == 0 {
config.DefaultTimeout = defaultTimeout
}
cConn := &clusterConnection{
connectionBuilder: connectionBuilder,
defaultTimeout: config.DefaultTimeout,
}
// Initialize endpoints
if err := cConn.UpdateEndpoints(endpoints); err != nil {
return nil, driver.WithStack(err)
}
return cConn, nil
} | go | {
"resource": ""
} |
q5749 | getCurrentServer | train | func (c *clusterConnection) getCurrentServer() driver.Connection {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.servers[c.current]
} | go | {
"resource": ""
} |
q5750 | getSpecificServer | train | func (c *clusterConnection) getSpecificServer(endpoint string) (driver.Connection, error) {
c.mutex.RLock()
defer c.mutex.RUnlock()
for _, s := range c.servers {
endpoints := s.Endpoints()
found := false
for _, x := range endpoints {
if x == endpoint {
found = true
break
}
}
if found {
return s, nil
}
}
return nil, driver.WithStack(driver.InvalidArgumentError{Message: fmt.Sprintf("unknown endpoint: %s", endpoint)})
} | go | {
"resource": ""
} |
q5751 | getNextServer | train | func (c *clusterConnection) getNextServer() driver.Connection {
c.mutex.Lock()
defer c.mutex.Unlock()
c.current = (c.current + 1) % len(c.servers)
return c.servers[c.current]
} | go | {
"resource": ""
} |
q5752 | newCollection | train | func newCollection(name string, db *database) (Collection, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &collection{
name: name,
db: db,
conn: db.conn,
}, nil
} | go | {
"resource": ""
} |
q5753 | Unload | train | func (c *collection) Unload(ctx context.Context) error {
req, err := c.conn.NewRequest("PUT", path.Join(c.relPath("collection"), "unload"))
if err != nil {
return WithStack(err)
}
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": ""
} |
q5754 | UnmarshalJSON | train | func (p *CollectionProperties) UnmarshalJSON(d []byte) error {
var internal collectionPropertiesInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | go | {
"resource": ""
} |
q5755 | UnmarshalJSON | train | func (p *SetCollectionPropertiesOptions) UnmarshalJSON(d []byte) error {
var internal setCollectionPropertiesOptionsInternal
if err := json.Unmarshal(d, &internal); err != nil {
return err
}
p.fromInternal(&internal)
return nil
} | go | {
"resource": ""
} |
q5756 | newHTTPConnection | train | func newHTTPConnection(endpoint string, config ConnectionConfig) (driver.Connection, error) {
if config.ConnLimit == 0 {
config.ConnLimit = DefaultConnLimit
}
endpoint = util.FixupEndpointURLScheme(endpoint)
u, err := url.Parse(endpoint)
if err != nil {
return nil, driver.WithStack(err)
}
var httpTransport *http.Transport
if config.Transport != nil {
httpTransport, _ = config.Transport.(*http.Transport)
} else {
httpTransport = &http.Transport{
// Copy default values from http.DefaultTransport
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
config.Transport = httpTransport
}
if httpTransport != nil {
if httpTransport.MaxIdleConnsPerHost == 0 {
// Raise the default number of idle connections per host since in a database application
// it is very likely that you want more than 2 concurrent connections to a host.
// We raise it to avoid the extra concurrent connections being closed directly
// after use, resulting in a lot of connection in `TIME_WAIT` state.
httpTransport.MaxIdleConnsPerHost = DefaultMaxIdleConnsPerHost
}
defaultMaxIdleConns := 3 * DefaultMaxIdleConnsPerHost
if httpTransport.MaxIdleConns > 0 && httpTransport.MaxIdleConns < defaultMaxIdleConns {
// For a cluster scenario we assume the use of 3 coordinators (don't know the exact number here)
// and derive the maximum total number of idle connections from that.
httpTransport.MaxIdleConns = defaultMaxIdleConns
}
if config.TLSConfig != nil {
httpTransport.TLSClientConfig = config.TLSConfig
}
}
httpClient := &http.Client{
Transport: config.Transport,
}
if config.DontFollowRedirect {
httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse // Do not wrap, standard library will not understand
}
} else if config.FailOnRedirect {
httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return driver.ArangoError{
HasError: true,
Code: http.StatusFound,
ErrorNum: 0,
ErrorMessage: "Redirect not allowed",
}
}
}
var connPool chan int
if config.ConnLimit > 0 {
connPool = make(chan int, config.ConnLimit)
// Fill with available tokens
for i := 0; i < config.ConnLimit; i++ {
connPool <- i
}
}
c := &httpConnection{
endpoint: *u,
contentType: config.ContentType,
client: httpClient,
connPool: connPool,
}
return c, nil
} | go | {
"resource": ""
} |
q5757 | readBody | train | func readBody(resp *http.Response) ([]byte, error) {
defer resp.Body.Close()
contentLength := resp.ContentLength
if contentLength < 0 {
// Don't know the content length, do it the slowest way
result, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, driver.WithStack(err)
}
return result, nil
}
buf := &bytes.Buffer{}
if int64(int(contentLength)) == contentLength {
// contentLength is an int64. If we can safely cast to int, use Grow.
buf.Grow(int(contentLength))
}
if _, err := buf.ReadFrom(resp.Body); err != nil {
return nil, driver.WithStack(err)
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q5758 | parseResponseArray | train | func parseResponseArray(resp Response, count int, cs contextSettings, results interface{}) (DocumentMetaSlice, ErrorSlice, error) {
resps, err := resp.ParseArrayBody()
if err != nil {
return nil, nil, WithStack(err)
}
metas := make(DocumentMetaSlice, count)
errs := make(ErrorSlice, count)
returnOldVal := reflect.ValueOf(cs.ReturnOld)
returnNewVal := reflect.ValueOf(cs.ReturnNew)
resultsVal := reflect.ValueOf(results)
for i := 0; i < count; i++ {
resp := resps[i]
var meta DocumentMeta
if err := resp.CheckStatus(200, 201, 202); err != nil {
errs[i] = err
} else {
if err := resp.ParseBody("", &meta); err != nil {
errs[i] = err
} else {
metas[i] = meta
// Parse returnOld (if needed)
if cs.ReturnOld != nil {
returnOldEntryVal := returnOldVal.Index(i).Addr()
if err := resp.ParseBody("old", returnOldEntryVal.Interface()); err != nil {
errs[i] = err
}
}
// Parse returnNew (if needed)
if cs.ReturnNew != nil {
returnNewEntryVal := returnNewVal.Index(i).Addr()
if err := resp.ParseBody("new", returnNewEntryVal.Interface()); err != nil {
errs[i] = err
}
}
}
if results != nil {
// Parse compare result document
resultsEntryVal := resultsVal.Index(i).Addr()
if err := resp.ParseBody("", resultsEntryVal.Interface()); err != nil {
errs[i] = err
}
}
}
}
return metas, errs, nil
} | go | {
"resource": ""
} |
q5759 | newGraph | train | func newGraph(name string, db *database) (Graph, error) {
if name == "" {
return nil, WithStack(InvalidArgumentError{Message: "name is empty"})
}
if db == nil {
return nil, WithStack(InvalidArgumentError{Message: "db is nil"})
}
return &graph{
name: name,
db: db,
conn: db.conn,
}, nil
} | go | {
"resource": ""
} |
q5760 | Remove | train | func (g *graph) Remove(ctx context.Context) error {
req, err := g.conn.NewRequest("DELETE", g.relPath())
if err != nil {
return WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return WithStack(err)
}
if err := resp.CheckStatus(201, 202); err != nil {
return WithStack(err)
}
return nil
} | go | {
"resource": ""
} |
q5761 | readChunkVST1_1 | train | func readChunkVST1_1(r io.Reader) (chunk, error) {
hdr := [maxChunkHeaderSize]byte{}
if err := readBytes(hdr[:maxChunkHeaderSize], r); err != nil {
return chunk{}, driver.WithStack(err)
}
le := binary.LittleEndian
length := le.Uint32(hdr[0:])
chunkX := le.Uint32(hdr[4:])
messageID := le.Uint64(hdr[8:])
messageLength := le.Uint64(hdr[16:])
contentLength := length - maxChunkHeaderSize
data := make([]byte, contentLength)
if err := readBytes(data, r); err != nil {
return chunk{}, driver.WithStack(err)
}
//fmt.Printf("data: " + hex.EncodeToString(data) + "\n")
return chunk{
chunkX: chunkX,
MessageID: messageID,
MessageLength: messageLength,
Data: data,
}, nil
} | go | {
"resource": ""
} |
q5762 | WriteToVST1_1 | train | func (c chunk) WriteToVST1_1(w io.Writer) (int64, error) {
le := binary.LittleEndian
hdr := [maxChunkHeaderSize]byte{}
le.PutUint32(hdr[0:], uint32(len(c.Data)+len(hdr))) // length
le.PutUint32(hdr[4:], c.chunkX) // chunkX
le.PutUint64(hdr[8:], c.MessageID) // message ID
le.PutUint64(hdr[16:], c.MessageLength) // message length
// Write header
//fmt.Printf("Writing hdr: %s\n", hex.EncodeToString(hdr))
if n, err := w.Write(hdr[:]); err != nil {
return int64(n), driver.WithStack(err)
}
// Write data
//fmt.Printf("Writing data: %s\n", hex.EncodeToString(c.Data))
n, err := w.Write(c.Data)
result := int64(n) + int64(len(hdr))
if err != nil {
return result, driver.WithStack(err)
}
return result, nil
} | go | {
"resource": ""
} |
q5763 | Collection | train | func (d *database) Collection(ctx context.Context, name string) (Collection, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/collection", 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)
}
coll, err := newCollection(name, d)
if err != nil {
return nil, WithStack(err)
}
return coll, nil
} | go | {
"resource": ""
} |
q5764 | Collections | train | func (d *database) Collections(ctx context.Context) ([]Collection, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/collection"))
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 getCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Collection, 0, len(data.Result))
for _, info := range data.Result {
col, err := newCollection(info.Name, d)
if err != nil {
return nil, WithStack(err)
}
result = append(result, col)
}
return result, nil
} | go | {
"resource": ""
} |
q5765 | CreateCollection | train | func (d *database) CreateCollection(ctx context.Context, name string, options *CreateCollectionOptions) (Collection, error) {
input := createCollectionOptionsInternal{
Name: name,
}
if options != nil {
input.fromExternal(options)
}
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/collection"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
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)
}
col, err := newCollection(name, d)
if err != nil {
return nil, WithStack(err)
}
return col, nil
} | go | {
"resource": ""
} |
q5766 | newResponse | train | func newResponse(msgData []byte, endpoint string, rawResponse *[]byte) (*vstResponse, error) {
// Decode header
hdr := velocypack.Slice(msgData)
if err := hdr.AssertType(velocypack.Array); err != nil {
return nil, driver.WithStack(err)
}
//panic("hdr: " + hex.EncodeToString(hdr))
var hdrLen velocypack.ValueLength
if l, err := hdr.Length(); err != nil {
return nil, driver.WithStack(err)
} else if l < 3 {
return nil, driver.WithStack(fmt.Errorf("Expected a header of 3 elements, got %d", l))
} else {
hdrLen = l
}
resp := &vstResponse{
endpoint: endpoint,
}
// Decode version
if elem, err := hdr.At(0); err != nil {
return nil, driver.WithStack(err)
} else if version, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.Version = int(version)
}
// Decode type
if elem, err := hdr.At(1); err != nil {
return nil, driver.WithStack(err)
} else if tp, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.Type = int(tp)
}
// Decode responseCode
if elem, err := hdr.At(2); err != nil {
return nil, driver.WithStack(err)
} else if code, err := elem.GetInt(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.ResponseCode = int(code)
}
// Decode meta
if hdrLen >= 4 {
if elem, err := hdr.At(3); err != nil {
return nil, driver.WithStack(err)
} else if !elem.IsObject() {
return nil, driver.WithStack(fmt.Errorf("Expected meta field to be of type Object, got %s", elem.Type()))
} else {
resp.meta = elem
}
}
// Fetch body directly after hdr
if body, err := hdr.Next(); err != nil {
return nil, driver.WithStack(err)
} else {
resp.slice = body
if rawResponse != nil {
*rawResponse = body
}
}
//fmt.Printf("got response: code=%d, body=%s\n", resp.ResponseCode, hex.EncodeToString(resp.slice))
return resp, nil
} | go | {
"resource": ""
} |
q5767 | ReplaceDocument | train | func (c *vertexCollection) ReplaceDocument(ctx context.Context, key string, document interface{}) (DocumentMeta, error) {
meta, _, err := c.replaceDocument(ctx, key, document)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | {
"resource": ""
} |
q5768 | ReplaceDocuments | train | func (c *vertexCollection) ReplaceDocuments(ctx context.Context, keys []string, documents interface{}) (DocumentMetaSlice, ErrorSlice, error) {
documentsVal := reflect.ValueOf(documents)
switch documentsVal.Kind() {
case reflect.Array, reflect.Slice:
// OK
default:
return nil, nil, WithStack(InvalidArgumentError{Message: fmt.Sprintf("documents data must be of kind Array, got %s", documentsVal.Kind())})
}
documentCount := documentsVal.Len()
if keys != nil {
if len(keys) != documentCount {
return nil, nil, WithStack(InvalidArgumentError{Message: fmt.Sprintf("expected %d keys, got %d", documentCount, len(keys))})
}
for _, key := range keys {
if err := validateKey(key); err != nil {
return nil, nil, WithStack(err)
}
}
}
metas := make(DocumentMetaSlice, documentCount)
errs := make(ErrorSlice, documentCount)
silent := false
for i := 0; i < documentCount; i++ {
doc := documentsVal.Index(i)
ctx, err := withDocumentAt(ctx, i)
if err != nil {
return nil, nil, WithStack(err)
}
var key string
if keys != nil {
key = keys[i]
} else {
var err error
key, err = getKeyFromDocument(doc)
if err != nil {
errs[i] = err
continue
}
}
meta, cs, err := c.replaceDocument(ctx, key, doc.Interface())
if cs.Silent {
silent = true
} else {
metas[i], errs[i] = meta, err
}
}
if silent {
return nil, nil, nil
}
return metas, errs, nil
} | go | {
"resource": ""
} |
q5769 | RemoveDocument | train | func (c *vertexCollection) RemoveDocument(ctx context.Context, key string) (DocumentMeta, error) {
meta, _, err := c.removeDocument(ctx, key)
if err != nil {
return DocumentMeta{}, WithStack(err)
}
return meta, nil
} | go | {
"resource": ""
} |
q5770 | View | train | func (d *database) View(ctx context.Context, name string) (View, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view", escapedName))
if err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
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 viewInfo
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
view, err := newView(name, data.Type, d)
if err != nil {
return nil, WithStack(err)
}
return view, nil
} | go | {
"resource": ""
} |
q5771 | ViewExists | train | func (d *database) ViewExists(ctx context.Context, name string) (bool, error) {
escapedName := pathEscape(name)
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view", escapedName))
if err != nil {
return false, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.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": ""
} |
q5772 | Views | train | func (d *database) Views(ctx context.Context) ([]View, error) {
req, err := d.conn.NewRequest("GET", path.Join(d.relPath(), "_api/view"))
if err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
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 getViewResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]View, 0, len(data.Result))
for _, info := range data.Result {
view, err := newView(info.Name, info.Type, d)
if err != nil {
return nil, WithStack(err)
}
result = append(result, view)
}
return result, nil
} | go | {
"resource": ""
} |
q5773 | CreateArangoSearchView | train | func (d *database) CreateArangoSearchView(ctx context.Context, name string, options *ArangoSearchViewProperties) (ArangoSearchView, error) {
input := struct {
Name string `json:"name"`
Type ViewType `json:"type"`
ArangoSearchViewProperties // `json:"properties"`
}{
Name: name,
Type: ViewTypeArangoSearch,
}
if options != nil {
input.ArangoSearchViewProperties = *options
}
req, err := d.conn.NewRequest("POST", path.Join(d.relPath(), "_api/view"))
if err != nil {
return nil, WithStack(err)
}
if _, err := req.SetBody(input); err != nil {
return nil, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := d.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(201); err != nil {
return nil, WithStack(err)
}
view, err := newView(name, input.Type, d)
if err != nil {
return nil, WithStack(err)
}
result, err := view.ArangoSearchView()
if err != nil {
return nil, WithStack(err)
}
return result, nil
} | go | {
"resource": ""
} |
q5774 | VertexCollection | train | func (g *graph) VertexCollection(ctx context.Context, name string) (Collection, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
for _, n := range data.Collections {
if n == name {
ec, err := newVertexCollection(name, g)
if err != nil {
return nil, WithStack(err)
}
return ec, nil
}
}
return nil, WithStack(newArangoError(404, 0, "not found"))
} | go | {
"resource": ""
} |
q5775 | VertexCollectionExists | train | func (g *graph) VertexCollectionExists(ctx context.Context, name string) (bool, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
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 listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return false, WithStack(err)
}
for _, n := range data.Collections {
if n == name {
return true, nil
}
}
return false, nil
} | go | {
"resource": ""
} |
q5776 | VertexCollections | train | func (g *graph) VertexCollections(ctx context.Context) ([]Collection, error) {
req, err := g.conn.NewRequest("GET", path.Join(g.relPath(), "vertex"))
if err != nil {
return nil, WithStack(err)
}
resp, err := g.conn.Do(ctx, req)
if err != nil {
return nil, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return nil, WithStack(err)
}
var data listVertexCollectionResponse
if err := resp.ParseBody("", &data); err != nil {
return nil, WithStack(err)
}
result := make([]Collection, 0, len(data.Collections))
for _, name := range data.Collections {
ec, err := newVertexCollection(name, g)
if err != nil {
return nil, WithStack(err)
}
result = append(result, ec)
}
return result, nil
} | go | {
"resource": ""
} |
q5777 | Endpoint | train | func (r *httpVPackResponse) Endpoint() string {
u := *r.resp.Request.URL
u.Path = ""
return u.String()
} | go | {
"resource": ""
} |
q5778 | getSlice | train | func (r *httpVPackResponse) getSlice() (velocypack.Slice, error) {
if r.slice == nil {
r.slice = velocypack.Slice(r.rawResponse)
//fmt.Println(r.slice)
}
return r.slice, nil
} | go | {
"resource": ""
} |
q5779 | String | train | func (v VersionInfo) String() string {
result := fmt.Sprintf("%s, version %s, license %s", v.Server, v.Version, v.License)
if len(v.Details) > 0 {
lines := make([]string, 0, len(v.Details))
for k, v := range v.Details {
lines = append(lines, fmt.Sprintf("%s: %v", k, v))
}
sort.Strings(lines)
result = result + "\n" + strings.Join(lines, "\n")
}
return result
} | go | {
"resource": ""
} |
q5780 | buildChunks | train | func buildChunks(messageID uint64, maxChunkSize uint32, messageParts ...[]byte) ([]chunk, error) {
if maxChunkSize <= maxChunkHeaderSize {
return nil, fmt.Errorf("maxChunkSize is too small (%d)", maxChunkSize)
}
messageLength := uint64(0)
for _, m := range messageParts {
messageLength += uint64(len(m))
}
minChunkCount := int(messageLength / uint64(maxChunkSize))
maxDataLength := int(maxChunkSize - maxChunkHeaderSize)
chunks := make([]chunk, 0, minChunkCount+len(messageParts))
chunkIndex := uint32(0)
for _, m := range messageParts {
offset := 0
remaining := len(m)
for remaining > 0 {
dataLength := remaining
if dataLength > maxDataLength {
dataLength = maxDataLength
}
chunkX := chunkIndex << 1
c := chunk{
chunkX: chunkX,
MessageID: messageID,
MessageLength: messageLength,
Data: m[offset : offset+dataLength],
}
chunks = append(chunks, c)
remaining -= dataLength
offset += dataLength
chunkIndex++
}
}
// Set chunkX of first chunk
if len(chunks) == 1 {
chunks[0].chunkX = 3
} else {
chunks[0].chunkX = uint32((len(chunks) << 1) + 1)
}
return chunks, nil
} | go | {
"resource": ""
} |
q5781 | NewClient | train | func NewClient(config ClientConfig) (Client, error) {
if config.Connection == nil {
return nil, WithStack(InvalidArgumentError{Message: "Connection is not set"})
}
conn := config.Connection
if config.Authentication != nil {
var err error
conn, err = conn.SetAuthentication(config.Authentication)
if err != nil {
return nil, WithStack(err)
}
}
c := &client{
conn: conn,
}
if config.SynchronizeEndpointsInterval > 0 {
go c.autoSynchronizeEndpoints(config.SynchronizeEndpointsInterval)
}
return c, nil
} | go | {
"resource": ""
} |
q5782 | SynchronizeEndpoints | train | func (c *client) SynchronizeEndpoints(ctx context.Context) error {
return c.SynchronizeEndpoints2(ctx, "")
} | go | {
"resource": ""
} |
q5783 | autoSynchronizeEndpoints | train | func (c *client) autoSynchronizeEndpoints(interval time.Duration) {
for {
// SynchronizeEndpoints endpoints
c.SynchronizeEndpoints(nil)
// Wait a bit
time.Sleep(interval)
}
} | go | {
"resource": ""
} |
q5784 | add | train | func (c WriteCondition) add(key []string, updater func(wc *writeCondition)) WriteCondition {
if c.conditions == nil {
c.conditions = make(map[string]writeCondition)
}
fullKey := createFullKey(key)
wc := c.conditions[fullKey]
updater(&wc)
c.conditions[fullKey] = wc
return c
} | go | {
"resource": ""
} |
q5785 | toMap | train | func (c WriteCondition) toMap() map[string]interface{} {
result := make(map[string]interface{})
for k, v := range c.conditions {
result[k] = v
}
return result
} | go | {
"resource": ""
} |
q5786 | IfEmpty | train | func (c WriteCondition) IfEmpty(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.OldEmpty = &condTrue
})
} | go | {
"resource": ""
} |
q5787 | IfIsArray | train | func (c WriteCondition) IfIsArray(key []string) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.IsArray = &condTrue
})
} | go | {
"resource": ""
} |
q5788 | IfEqualTo | train | func (c WriteCondition) IfEqualTo(key []string, oldValue interface{}) WriteCondition {
return c.add(key, func(wc *writeCondition) {
wc.Old = oldValue
})
} | go | {
"resource": ""
} |
q5789 | newVertexCollection | train | func newVertexCollection(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 &vertexCollection{
name: name,
g: g,
conn: g.db.conn,
}, nil
} | go | {
"resource": ""
} |
q5790 | Revision | train | func (c *vertexCollection) Revision(ctx context.Context) (string, error) {
result, err := c.rawCollection().Revision(ctx)
if err != nil {
return "", WithStack(err)
}
return result, nil
} | go | {
"resource": ""
} |
q5791 | BasicAuthentication | train | func BasicAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeBasic,
userName: userName,
password: password,
}
} | go | {
"resource": ""
} |
q5792 | JWTAuthentication | train | func JWTAuthentication(userName, password string) Authentication {
return &userNameAuthentication{
authType: AuthenticationTypeJWT,
userName: userName,
password: password,
}
} | go | {
"resource": ""
} |
q5793 | Get | train | func (a *userNameAuthentication) Get(property string) string {
switch property {
case "username":
return a.userName
case "password":
return a.password
default:
return ""
}
} | go | {
"resource": ""
} |
q5794 | Major | train | func (v Version) Major() int {
parts := strings.Split(string(v), ".")
result, _ := strconv.Atoi(parts[0])
return result
} | go | {
"resource": ""
} |
q5795 | Minor | train | func (v Version) Minor() int {
parts := strings.Split(string(v), ".")
if len(parts) >= 2 {
result, _ := strconv.Atoi(parts[1])
return result
}
return 0
} | go | {
"resource": ""
} |
q5796 | Sub | train | func (v Version) Sub() string {
parts := strings.SplitN(string(v), ".", 3)
if len(parts) == 3 {
return parts[2]
}
return ""
} | go | {
"resource": ""
} |
q5797 | SubInt | train | func (v Version) SubInt() (int, bool) {
result, err := strconv.Atoi(v.Sub())
return result, err == nil
} | go | {
"resource": ""
} |
q5798 | Keys | train | func (l DocumentMetaSlice) Keys() []string {
keys := make([]string, len(l))
for i, m := range l {
keys[i] = m.Key
}
return keys
} | go | {
"resource": ""
} |
q5799 | Revs | train | func (l DocumentMetaSlice) Revs() []string {
revs := make([]string, len(l))
for i, m := range l {
revs[i] = m.Rev
}
return revs
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.