repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
couchbase/go-couchbase | observe.go | Get | func (p *OPpool) Get() *ObservePersistJob {
var o *ObservePersistJob
select {
case o = <-p.pool:
default:
o = &ObservePersistJob{}
}
return o
} | go | func (p *OPpool) Get() *ObservePersistJob {
var o *ObservePersistJob
select {
case o = <-p.pool:
default:
o = &ObservePersistJob{}
}
return o
} | [
"func",
"(",
"p",
"*",
"OPpool",
")",
"Get",
"(",
")",
"*",
"ObservePersistJob",
"{",
"var",
"o",
"*",
"ObservePersistJob",
"\n",
"select",
"{",
"case",
"o",
"=",
"<-",
"p",
".",
"pool",
":",
"default",
":",
"o",
"=",
"&",
"ObservePersistJob",
"{",
"}",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | // Borrow a Client from the pool. | [
"Borrow",
"a",
"Client",
"from",
"the",
"pool",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/observe.go#L283-L291 | train |
couchbase/go-couchbase | cbdatasource/cbdatasource.go | workerStart | func (d *bucketDataSource) workerStart(server string, workerCh chan []uint16, tlsConfig *tls.Config) {
backoffFactor := d.options.DataManagerBackoffFactor
if backoffFactor <= 0.0 {
backoffFactor = DefaultBucketDataSourceOptions.DataManagerBackoffFactor
}
sleepInitMS := d.options.DataManagerSleepInitMS
if sleepInitMS <= 0 {
sleepInitMS = DefaultBucketDataSourceOptions.DataManagerSleepInitMS
}
sleepMaxMS := d.options.DataManagerSleepMaxMS
if sleepMaxMS <= 0 {
sleepMaxMS = DefaultBucketDataSourceOptions.DataManagerSleepMaxMS
}
// Use exponential backoff loop to handle connect retries to the server.
go func() {
atomic.AddUint64(&d.stats.TotWorkerStart, 1)
ExponentialBackoffLoop("cbdatasource.worker-"+server,
func() int { return d.worker(server, workerCh, tlsConfig) },
sleepInitMS, backoffFactor, sleepMaxMS)
atomic.AddUint64(&d.stats.TotWorkerDone, 1)
}()
} | go | func (d *bucketDataSource) workerStart(server string, workerCh chan []uint16, tlsConfig *tls.Config) {
backoffFactor := d.options.DataManagerBackoffFactor
if backoffFactor <= 0.0 {
backoffFactor = DefaultBucketDataSourceOptions.DataManagerBackoffFactor
}
sleepInitMS := d.options.DataManagerSleepInitMS
if sleepInitMS <= 0 {
sleepInitMS = DefaultBucketDataSourceOptions.DataManagerSleepInitMS
}
sleepMaxMS := d.options.DataManagerSleepMaxMS
if sleepMaxMS <= 0 {
sleepMaxMS = DefaultBucketDataSourceOptions.DataManagerSleepMaxMS
}
// Use exponential backoff loop to handle connect retries to the server.
go func() {
atomic.AddUint64(&d.stats.TotWorkerStart, 1)
ExponentialBackoffLoop("cbdatasource.worker-"+server,
func() int { return d.worker(server, workerCh, tlsConfig) },
sleepInitMS, backoffFactor, sleepMaxMS)
atomic.AddUint64(&d.stats.TotWorkerDone, 1)
}()
} | [
"func",
"(",
"d",
"*",
"bucketDataSource",
")",
"workerStart",
"(",
"server",
"string",
",",
"workerCh",
"chan",
"[",
"]",
"uint16",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
")",
"{",
"backoffFactor",
":=",
"d",
".",
"options",
".",
"DataManagerBackoffFactor",
"\n",
"if",
"backoffFactor",
"<=",
"0.0",
"{",
"backoffFactor",
"=",
"DefaultBucketDataSourceOptions",
".",
"DataManagerBackoffFactor",
"\n",
"}",
"\n",
"sleepInitMS",
":=",
"d",
".",
"options",
".",
"DataManagerSleepInitMS",
"\n",
"if",
"sleepInitMS",
"<=",
"0",
"{",
"sleepInitMS",
"=",
"DefaultBucketDataSourceOptions",
".",
"DataManagerSleepInitMS",
"\n",
"}",
"\n",
"sleepMaxMS",
":=",
"d",
".",
"options",
".",
"DataManagerSleepMaxMS",
"\n",
"if",
"sleepMaxMS",
"<=",
"0",
"{",
"sleepMaxMS",
"=",
"DefaultBucketDataSourceOptions",
".",
"DataManagerSleepMaxMS",
"\n",
"}",
"\n\n",
"// Use exponential backoff loop to handle connect retries to the server.",
"go",
"func",
"(",
")",
"{",
"atomic",
".",
"AddUint64",
"(",
"&",
"d",
".",
"stats",
".",
"TotWorkerStart",
",",
"1",
")",
"\n\n",
"ExponentialBackoffLoop",
"(",
"\"",
"\"",
"+",
"server",
",",
"func",
"(",
")",
"int",
"{",
"return",
"d",
".",
"worker",
"(",
"server",
",",
"workerCh",
",",
"tlsConfig",
")",
"}",
",",
"sleepInitMS",
",",
"backoffFactor",
",",
"sleepMaxMS",
")",
"\n\n",
"atomic",
".",
"AddUint64",
"(",
"&",
"d",
".",
"stats",
".",
"TotWorkerDone",
",",
"1",
")",
"\n",
"}",
"(",
")",
"\n",
"}"
] | // A worker connects to one data manager server. | [
"A",
"worker",
"connects",
"to",
"one",
"data",
"manager",
"server",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/cbdatasource/cbdatasource.go#L927-L951 | train |
couchbase/go-couchbase | cbdatasource/cbdatasource.go | ConnectBucket | func ConnectBucket(serverURL, poolName, bucketName string,
auth couchbase.AuthHandler) (Bucket, error) {
var bucket *couchbase.Bucket
var err error
if auth != nil {
bucket, err = couchbase.ConnectWithAuthAndGetBucket(serverURL, poolName, bucketName, auth)
} else {
bucket, err = couchbase.GetBucket(serverURL, poolName, bucketName)
}
if err != nil {
return nil, err
}
if bucket == nil {
return nil, fmt.Errorf("unknown bucket,"+
" serverURL: %s, bucketName: %s", serverURL, bucketName)
}
return &bucketWrapper{b: bucket}, nil
} | go | func ConnectBucket(serverURL, poolName, bucketName string,
auth couchbase.AuthHandler) (Bucket, error) {
var bucket *couchbase.Bucket
var err error
if auth != nil {
bucket, err = couchbase.ConnectWithAuthAndGetBucket(serverURL, poolName, bucketName, auth)
} else {
bucket, err = couchbase.GetBucket(serverURL, poolName, bucketName)
}
if err != nil {
return nil, err
}
if bucket == nil {
return nil, fmt.Errorf("unknown bucket,"+
" serverURL: %s, bucketName: %s", serverURL, bucketName)
}
return &bucketWrapper{b: bucket}, nil
} | [
"func",
"ConnectBucket",
"(",
"serverURL",
",",
"poolName",
",",
"bucketName",
"string",
",",
"auth",
"couchbase",
".",
"AuthHandler",
")",
"(",
"Bucket",
",",
"error",
")",
"{",
"var",
"bucket",
"*",
"couchbase",
".",
"Bucket",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"auth",
"!=",
"nil",
"{",
"bucket",
",",
"err",
"=",
"couchbase",
".",
"ConnectWithAuthAndGetBucket",
"(",
"serverURL",
",",
"poolName",
",",
"bucketName",
",",
"auth",
")",
"\n",
"}",
"else",
"{",
"bucket",
",",
"err",
"=",
"couchbase",
".",
"GetBucket",
"(",
"serverURL",
",",
"poolName",
",",
"bucketName",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"bucket",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"serverURL",
",",
"bucketName",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"bucketWrapper",
"{",
"b",
":",
"bucket",
"}",
",",
"nil",
"\n",
"}"
] | // ConnectBucket is the default function used by BucketDataSource
// to connect to a Couchbase cluster to retrieve Bucket information.
// It is exposed for testability and to allow applications to
// override or wrap via BucketDataSourceOptions. | [
"ConnectBucket",
"is",
"the",
"default",
"function",
"used",
"by",
"BucketDataSource",
"to",
"connect",
"to",
"a",
"Couchbase",
"cluster",
"to",
"retrieve",
"Bucket",
"information",
".",
"It",
"is",
"exposed",
"for",
"testability",
"and",
"to",
"allow",
"applications",
"to",
"override",
"or",
"wrap",
"via",
"BucketDataSourceOptions",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/cbdatasource/cbdatasource.go#L1959-L1978 | train |
couchbase/go-couchbase | cbdatasource/cbdatasource.go | UPROpen | func UPROpen(mc *memcached.Client, name string,
option *BucketDataSourceOptions, openFlags uint32) error {
rq := &gomemcached.MCRequest{
Opcode: gomemcached.UPR_OPEN,
Key: []byte(name),
Opaque: 0xf00d1234,
Extras: make([]byte, 8),
}
bufSize := option.FeedBufferSizeBytes
noopInterval := option.NoopTimeIntervalSecs
binary.BigEndian.PutUint32(rq.Extras[:4], 0) // First 4 bytes are reserved.
flags := FlagOpenProducer | openFlags // NOTE: 1 for producer, 0 for consumer.
binary.BigEndian.PutUint32(rq.Extras[4:], flags)
if err := mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit, err: %v", err)
}
res, err := mc.Receive()
if err != nil {
return fmt.Errorf("UPROpen receive, err: %v", err)
}
if res.Opcode != gomemcached.UPR_OPEN {
return fmt.Errorf("UPROpen unexpected #opcode %v", res.Opcode)
}
if res.Opaque != rq.Opaque {
return fmt.Errorf("UPROpen opaque mismatch, %v over %v", res.Opaque, res.Opaque)
}
if res.Status != gomemcached.SUCCESS {
return fmt.Errorf("UPROpen failed, status: %v, %#v", res.Status, res)
}
if bufSize > 0 {
rq := &gomemcached.MCRequest{
Opcode: gomemcached.UPR_CONTROL,
Key: []byte("connection_buffer_size"),
Body: []byte(strconv.Itoa(int(bufSize))),
}
if err = mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit UPR_CONTROL"+
" (connection_buffer_size), err: %v", err)
}
}
if noopInterval > 0 {
rq := &gomemcached.MCRequest{
Opcode: gomemcached.UPR_CONTROL,
Key: []byte("enable_noop"),
Body: []byte("true"),
}
if err = mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit UPR_CONTROL"+
" (enable_noop), err: %v", err)
}
rq = &gomemcached.MCRequest{
Opcode: gomemcached.UPR_CONTROL,
Key: []byte("set_noop_interval"),
Body: []byte(strconv.Itoa(int(noopInterval))),
}
if err = mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit UPR_CONTROL"+
" (set_noop_interval), err: %v", err)
}
}
return nil
} | go | func UPROpen(mc *memcached.Client, name string,
option *BucketDataSourceOptions, openFlags uint32) error {
rq := &gomemcached.MCRequest{
Opcode: gomemcached.UPR_OPEN,
Key: []byte(name),
Opaque: 0xf00d1234,
Extras: make([]byte, 8),
}
bufSize := option.FeedBufferSizeBytes
noopInterval := option.NoopTimeIntervalSecs
binary.BigEndian.PutUint32(rq.Extras[:4], 0) // First 4 bytes are reserved.
flags := FlagOpenProducer | openFlags // NOTE: 1 for producer, 0 for consumer.
binary.BigEndian.PutUint32(rq.Extras[4:], flags)
if err := mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit, err: %v", err)
}
res, err := mc.Receive()
if err != nil {
return fmt.Errorf("UPROpen receive, err: %v", err)
}
if res.Opcode != gomemcached.UPR_OPEN {
return fmt.Errorf("UPROpen unexpected #opcode %v", res.Opcode)
}
if res.Opaque != rq.Opaque {
return fmt.Errorf("UPROpen opaque mismatch, %v over %v", res.Opaque, res.Opaque)
}
if res.Status != gomemcached.SUCCESS {
return fmt.Errorf("UPROpen failed, status: %v, %#v", res.Status, res)
}
if bufSize > 0 {
rq := &gomemcached.MCRequest{
Opcode: gomemcached.UPR_CONTROL,
Key: []byte("connection_buffer_size"),
Body: []byte(strconv.Itoa(int(bufSize))),
}
if err = mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit UPR_CONTROL"+
" (connection_buffer_size), err: %v", err)
}
}
if noopInterval > 0 {
rq := &gomemcached.MCRequest{
Opcode: gomemcached.UPR_CONTROL,
Key: []byte("enable_noop"),
Body: []byte("true"),
}
if err = mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit UPR_CONTROL"+
" (enable_noop), err: %v", err)
}
rq = &gomemcached.MCRequest{
Opcode: gomemcached.UPR_CONTROL,
Key: []byte("set_noop_interval"),
Body: []byte(strconv.Itoa(int(noopInterval))),
}
if err = mc.Transmit(rq); err != nil {
return fmt.Errorf("UPROpen transmit UPR_CONTROL"+
" (set_noop_interval), err: %v", err)
}
}
return nil
} | [
"func",
"UPROpen",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"name",
"string",
",",
"option",
"*",
"BucketDataSourceOptions",
",",
"openFlags",
"uint32",
")",
"error",
"{",
"rq",
":=",
"&",
"gomemcached",
".",
"MCRequest",
"{",
"Opcode",
":",
"gomemcached",
".",
"UPR_OPEN",
",",
"Key",
":",
"[",
"]",
"byte",
"(",
"name",
")",
",",
"Opaque",
":",
"0xf00d1234",
",",
"Extras",
":",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
",",
"}",
"\n",
"bufSize",
":=",
"option",
".",
"FeedBufferSizeBytes",
"\n",
"noopInterval",
":=",
"option",
".",
"NoopTimeIntervalSecs",
"\n\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"rq",
".",
"Extras",
"[",
":",
"4",
"]",
",",
"0",
")",
"// First 4 bytes are reserved.",
"\n",
"flags",
":=",
"FlagOpenProducer",
"|",
"openFlags",
"// NOTE: 1 for producer, 0 for consumer.",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"rq",
".",
"Extras",
"[",
"4",
":",
"]",
",",
"flags",
")",
"\n\n",
"if",
"err",
":=",
"mc",
".",
"Transmit",
"(",
"rq",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"res",
",",
"err",
":=",
"mc",
".",
"Receive",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"res",
".",
"Opcode",
"!=",
"gomemcached",
".",
"UPR_OPEN",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Opcode",
")",
"\n",
"}",
"\n",
"if",
"res",
".",
"Opaque",
"!=",
"rq",
".",
"Opaque",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Opaque",
",",
"res",
".",
"Opaque",
")",
"\n",
"}",
"\n",
"if",
"res",
".",
"Status",
"!=",
"gomemcached",
".",
"SUCCESS",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Status",
",",
"res",
")",
"\n",
"}",
"\n\n",
"if",
"bufSize",
">",
"0",
"{",
"rq",
":=",
"&",
"gomemcached",
".",
"MCRequest",
"{",
"Opcode",
":",
"gomemcached",
".",
"UPR_CONTROL",
",",
"Key",
":",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"Body",
":",
"[",
"]",
"byte",
"(",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"bufSize",
")",
")",
")",
",",
"}",
"\n",
"if",
"err",
"=",
"mc",
".",
"Transmit",
"(",
"rq",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"noopInterval",
">",
"0",
"{",
"rq",
":=",
"&",
"gomemcached",
".",
"MCRequest",
"{",
"Opcode",
":",
"gomemcached",
".",
"UPR_CONTROL",
",",
"Key",
":",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"Body",
":",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"}",
"\n",
"if",
"err",
"=",
"mc",
".",
"Transmit",
"(",
"rq",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"rq",
"=",
"&",
"gomemcached",
".",
"MCRequest",
"{",
"Opcode",
":",
"gomemcached",
".",
"UPR_CONTROL",
",",
"Key",
":",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"Body",
":",
"[",
"]",
"byte",
"(",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"noopInterval",
")",
")",
")",
",",
"}",
"\n",
"if",
"err",
"=",
"mc",
".",
"Transmit",
"(",
"rq",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UPROpen starts a UPR_OPEN stream on a memcached client connection.
// It is exposed for testability. | [
"UPROpen",
"starts",
"a",
"UPR_OPEN",
"stream",
"on",
"a",
"memcached",
"client",
"connection",
".",
"It",
"is",
"exposed",
"for",
"testability",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/cbdatasource/cbdatasource.go#L2037-L2105 | train |
couchbase/go-couchbase | upr.go | GetFailoverLogs | func (b *Bucket) GetFailoverLogs(vBuckets []uint16) (FailoverLog, error) {
// map vbids to their corresponding hosts
vbHostList := make(map[string][]uint16)
vbm := b.VBServerMap()
if len(vbm.VBucketMap) < len(vBuckets) {
return nil, fmt.Errorf("vbmap smaller than vbucket list: %v vs. %v",
vbm.VBucketMap, vBuckets)
}
for _, vb := range vBuckets {
masterID := vbm.VBucketMap[vb][0]
master := b.getMasterNode(masterID)
if master == "" {
return nil, fmt.Errorf("No master found for vb %d", vb)
}
vbList := vbHostList[master]
if vbList == nil {
vbList = make([]uint16, 0)
}
vbList = append(vbList, vb)
vbHostList[master] = vbList
}
failoverLogMap := make(FailoverLog)
for _, serverConn := range b.getConnPools(false /* not already locked */) {
vbList := vbHostList[serverConn.host]
if vbList == nil {
continue
}
mc, err := serverConn.Get()
if err != nil {
logging.Infof("No Free connections for vblist %v", vbList)
return nil, fmt.Errorf("No Free connections for host %s",
serverConn.host)
}
// close the connection so that it doesn't get reused for upr data
// connection
defer mc.Close()
failoverlogs, err := mc.UprGetFailoverLog(vbList)
if err != nil {
return nil, fmt.Errorf("Error getting failover log %s host %s",
err.Error(), serverConn.host)
}
for vb, log := range failoverlogs {
failoverLogMap[vb] = *log
}
}
return failoverLogMap, nil
} | go | func (b *Bucket) GetFailoverLogs(vBuckets []uint16) (FailoverLog, error) {
// map vbids to their corresponding hosts
vbHostList := make(map[string][]uint16)
vbm := b.VBServerMap()
if len(vbm.VBucketMap) < len(vBuckets) {
return nil, fmt.Errorf("vbmap smaller than vbucket list: %v vs. %v",
vbm.VBucketMap, vBuckets)
}
for _, vb := range vBuckets {
masterID := vbm.VBucketMap[vb][0]
master := b.getMasterNode(masterID)
if master == "" {
return nil, fmt.Errorf("No master found for vb %d", vb)
}
vbList := vbHostList[master]
if vbList == nil {
vbList = make([]uint16, 0)
}
vbList = append(vbList, vb)
vbHostList[master] = vbList
}
failoverLogMap := make(FailoverLog)
for _, serverConn := range b.getConnPools(false /* not already locked */) {
vbList := vbHostList[serverConn.host]
if vbList == nil {
continue
}
mc, err := serverConn.Get()
if err != nil {
logging.Infof("No Free connections for vblist %v", vbList)
return nil, fmt.Errorf("No Free connections for host %s",
serverConn.host)
}
// close the connection so that it doesn't get reused for upr data
// connection
defer mc.Close()
failoverlogs, err := mc.UprGetFailoverLog(vbList)
if err != nil {
return nil, fmt.Errorf("Error getting failover log %s host %s",
err.Error(), serverConn.host)
}
for vb, log := range failoverlogs {
failoverLogMap[vb] = *log
}
}
return failoverLogMap, nil
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetFailoverLogs",
"(",
"vBuckets",
"[",
"]",
"uint16",
")",
"(",
"FailoverLog",
",",
"error",
")",
"{",
"// map vbids to their corresponding hosts",
"vbHostList",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"uint16",
")",
"\n",
"vbm",
":=",
"b",
".",
"VBServerMap",
"(",
")",
"\n",
"if",
"len",
"(",
"vbm",
".",
"VBucketMap",
")",
"<",
"len",
"(",
"vBuckets",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vbm",
".",
"VBucketMap",
",",
"vBuckets",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"vb",
":=",
"range",
"vBuckets",
"{",
"masterID",
":=",
"vbm",
".",
"VBucketMap",
"[",
"vb",
"]",
"[",
"0",
"]",
"\n",
"master",
":=",
"b",
".",
"getMasterNode",
"(",
"masterID",
")",
"\n",
"if",
"master",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vb",
")",
"\n",
"}",
"\n\n",
"vbList",
":=",
"vbHostList",
"[",
"master",
"]",
"\n",
"if",
"vbList",
"==",
"nil",
"{",
"vbList",
"=",
"make",
"(",
"[",
"]",
"uint16",
",",
"0",
")",
"\n",
"}",
"\n",
"vbList",
"=",
"append",
"(",
"vbList",
",",
"vb",
")",
"\n",
"vbHostList",
"[",
"master",
"]",
"=",
"vbList",
"\n",
"}",
"\n\n",
"failoverLogMap",
":=",
"make",
"(",
"FailoverLog",
")",
"\n",
"for",
"_",
",",
"serverConn",
":=",
"range",
"b",
".",
"getConnPools",
"(",
"false",
"/* not already locked */",
")",
"{",
"vbList",
":=",
"vbHostList",
"[",
"serverConn",
".",
"host",
"]",
"\n",
"if",
"vbList",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"mc",
",",
"err",
":=",
"serverConn",
".",
"Get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Infof",
"(",
"\"",
"\"",
",",
"vbList",
")",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"serverConn",
".",
"host",
")",
"\n\n",
"}",
"\n",
"// close the connection so that it doesn't get reused for upr data",
"// connection",
"defer",
"mc",
".",
"Close",
"(",
")",
"\n",
"failoverlogs",
",",
"err",
":=",
"mc",
".",
"UprGetFailoverLog",
"(",
"vbList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
",",
"serverConn",
".",
"host",
")",
"\n\n",
"}",
"\n\n",
"for",
"vb",
",",
"log",
":=",
"range",
"failoverlogs",
"{",
"failoverLogMap",
"[",
"vb",
"]",
"=",
"*",
"log",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"failoverLogMap",
",",
"nil",
"\n",
"}"
] | // GetFailoverLogs, get the failover logs for a set of vbucket ids | [
"GetFailoverLogs",
"get",
"the",
"failover",
"logs",
"for",
"a",
"set",
"of",
"vbucket",
"ids"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/upr.go#L48-L104 | train |
couchbase/go-couchbase | upr.go | StartUprFeedWithConfig | func (b *Bucket) StartUprFeedWithConfig(name string, sequence uint32, data_chan_size int, dcp_buffer_size uint32) (*UprFeed, error) {
feed := &UprFeed{
bucket: b,
output: make(chan *memcached.UprEvent, data_chan_size),
quit: make(chan bool),
nodeFeeds: make(map[string]*FeedInfo, 0),
name: name,
sequence: sequence,
killSwitch: make(chan bool),
dcp_buffer_size: dcp_buffer_size,
data_chan_size: data_chan_size,
}
err := feed.connectToNodes()
if err != nil {
return nil, fmt.Errorf("Cannot connect to bucket %s", err.Error())
}
feed.connected = true
go feed.run()
feed.C = feed.output
return feed, nil
} | go | func (b *Bucket) StartUprFeedWithConfig(name string, sequence uint32, data_chan_size int, dcp_buffer_size uint32) (*UprFeed, error) {
feed := &UprFeed{
bucket: b,
output: make(chan *memcached.UprEvent, data_chan_size),
quit: make(chan bool),
nodeFeeds: make(map[string]*FeedInfo, 0),
name: name,
sequence: sequence,
killSwitch: make(chan bool),
dcp_buffer_size: dcp_buffer_size,
data_chan_size: data_chan_size,
}
err := feed.connectToNodes()
if err != nil {
return nil, fmt.Errorf("Cannot connect to bucket %s", err.Error())
}
feed.connected = true
go feed.run()
feed.C = feed.output
return feed, nil
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"StartUprFeedWithConfig",
"(",
"name",
"string",
",",
"sequence",
"uint32",
",",
"data_chan_size",
"int",
",",
"dcp_buffer_size",
"uint32",
")",
"(",
"*",
"UprFeed",
",",
"error",
")",
"{",
"feed",
":=",
"&",
"UprFeed",
"{",
"bucket",
":",
"b",
",",
"output",
":",
"make",
"(",
"chan",
"*",
"memcached",
".",
"UprEvent",
",",
"data_chan_size",
")",
",",
"quit",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"nodeFeeds",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"FeedInfo",
",",
"0",
")",
",",
"name",
":",
"name",
",",
"sequence",
":",
"sequence",
",",
"killSwitch",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"dcp_buffer_size",
":",
"dcp_buffer_size",
",",
"data_chan_size",
":",
"data_chan_size",
",",
"}",
"\n\n",
"err",
":=",
"feed",
".",
"connectToNodes",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"feed",
".",
"connected",
"=",
"true",
"\n",
"go",
"feed",
".",
"run",
"(",
")",
"\n\n",
"feed",
".",
"C",
"=",
"feed",
".",
"output",
"\n",
"return",
"feed",
",",
"nil",
"\n",
"}"
] | // StartUprFeed creates and starts a new Upr feed
// No data will be sent on the channel unless vbuckets streams are requested | [
"StartUprFeed",
"creates",
"and",
"starts",
"a",
"new",
"Upr",
"feed",
"No",
"data",
"will",
"be",
"sent",
"on",
"the",
"channel",
"unless",
"vbuckets",
"streams",
"are",
"requested"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/upr.go#L112-L135 | train |
couchbase/go-couchbase | upr.go | UprRequestStream | func (feed *UprFeed) UprRequestStream(vb uint16, opaque uint16, flags uint32,
vuuid, startSequence, endSequence, snapStart, snapEnd uint64) error {
defer func() {
if r := recover(); r != nil {
log.Panicf("Panic in UprRequestStream. Feed %v Bucket %v", feed, feed.bucket)
}
}()
vbm := feed.bucket.VBServerMap()
if len(vbm.VBucketMap) < int(vb) {
return fmt.Errorf("vbmap smaller than vbucket list: %v vs. %v",
vb, vbm.VBucketMap)
}
if int(vb) >= len(vbm.VBucketMap) {
return fmt.Errorf("Invalid vbucket id %d", vb)
}
masterID := vbm.VBucketMap[vb][0]
master := feed.bucket.getMasterNode(masterID)
if master == "" {
return fmt.Errorf("Master node not found for vbucket %d", vb)
}
singleFeed := feed.nodeFeeds[master]
if singleFeed == nil {
return fmt.Errorf("UprFeed for this host not found")
}
if err := singleFeed.uprFeed.UprRequestStream(vb, opaque, flags,
vuuid, startSequence, endSequence, snapStart, snapEnd); err != nil {
return err
}
return nil
} | go | func (feed *UprFeed) UprRequestStream(vb uint16, opaque uint16, flags uint32,
vuuid, startSequence, endSequence, snapStart, snapEnd uint64) error {
defer func() {
if r := recover(); r != nil {
log.Panicf("Panic in UprRequestStream. Feed %v Bucket %v", feed, feed.bucket)
}
}()
vbm := feed.bucket.VBServerMap()
if len(vbm.VBucketMap) < int(vb) {
return fmt.Errorf("vbmap smaller than vbucket list: %v vs. %v",
vb, vbm.VBucketMap)
}
if int(vb) >= len(vbm.VBucketMap) {
return fmt.Errorf("Invalid vbucket id %d", vb)
}
masterID := vbm.VBucketMap[vb][0]
master := feed.bucket.getMasterNode(masterID)
if master == "" {
return fmt.Errorf("Master node not found for vbucket %d", vb)
}
singleFeed := feed.nodeFeeds[master]
if singleFeed == nil {
return fmt.Errorf("UprFeed for this host not found")
}
if err := singleFeed.uprFeed.UprRequestStream(vb, opaque, flags,
vuuid, startSequence, endSequence, snapStart, snapEnd); err != nil {
return err
}
return nil
} | [
"func",
"(",
"feed",
"*",
"UprFeed",
")",
"UprRequestStream",
"(",
"vb",
"uint16",
",",
"opaque",
"uint16",
",",
"flags",
"uint32",
",",
"vuuid",
",",
"startSequence",
",",
"endSequence",
",",
"snapStart",
",",
"snapEnd",
"uint64",
")",
"error",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"log",
".",
"Panicf",
"(",
"\"",
"\"",
",",
"feed",
",",
"feed",
".",
"bucket",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"vbm",
":=",
"feed",
".",
"bucket",
".",
"VBServerMap",
"(",
")",
"\n",
"if",
"len",
"(",
"vbm",
".",
"VBucketMap",
")",
"<",
"int",
"(",
"vb",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vb",
",",
"vbm",
".",
"VBucketMap",
")",
"\n",
"}",
"\n\n",
"if",
"int",
"(",
"vb",
")",
">=",
"len",
"(",
"vbm",
".",
"VBucketMap",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vb",
")",
"\n",
"}",
"\n\n",
"masterID",
":=",
"vbm",
".",
"VBucketMap",
"[",
"vb",
"]",
"[",
"0",
"]",
"\n",
"master",
":=",
"feed",
".",
"bucket",
".",
"getMasterNode",
"(",
"masterID",
")",
"\n",
"if",
"master",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vb",
")",
"\n",
"}",
"\n",
"singleFeed",
":=",
"feed",
".",
"nodeFeeds",
"[",
"master",
"]",
"\n",
"if",
"singleFeed",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"singleFeed",
".",
"uprFeed",
".",
"UprRequestStream",
"(",
"vb",
",",
"opaque",
",",
"flags",
",",
"vuuid",
",",
"startSequence",
",",
"endSequence",
",",
"snapStart",
",",
"snapEnd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UprRequestStream starts a stream for a vb on a feed | [
"UprRequestStream",
"starts",
"a",
"stream",
"for",
"a",
"vb",
"on",
"a",
"feed"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/upr.go#L138-L173 | train |
couchbase/go-couchbase | upr.go | UprCloseStream | func (feed *UprFeed) UprCloseStream(vb, opaqueMSB uint16) error {
defer func() {
if r := recover(); r != nil {
log.Panicf("Panic in UprCloseStream. Feed %v Bucket %v ", feed, feed.bucket)
}
}()
vbm := feed.bucket.VBServerMap()
if len(vbm.VBucketMap) < int(vb) {
return fmt.Errorf("vbmap smaller than vbucket list: %v vs. %v",
vb, vbm.VBucketMap)
}
if int(vb) >= len(vbm.VBucketMap) {
return fmt.Errorf("Invalid vbucket id %d", vb)
}
masterID := vbm.VBucketMap[vb][0]
master := feed.bucket.getMasterNode(masterID)
if master == "" {
return fmt.Errorf("Master node not found for vbucket %d", vb)
}
singleFeed := feed.nodeFeeds[master]
if singleFeed == nil {
return fmt.Errorf("UprFeed for this host not found")
}
if err := singleFeed.uprFeed.CloseStream(vb, opaqueMSB); err != nil {
return err
}
return nil
} | go | func (feed *UprFeed) UprCloseStream(vb, opaqueMSB uint16) error {
defer func() {
if r := recover(); r != nil {
log.Panicf("Panic in UprCloseStream. Feed %v Bucket %v ", feed, feed.bucket)
}
}()
vbm := feed.bucket.VBServerMap()
if len(vbm.VBucketMap) < int(vb) {
return fmt.Errorf("vbmap smaller than vbucket list: %v vs. %v",
vb, vbm.VBucketMap)
}
if int(vb) >= len(vbm.VBucketMap) {
return fmt.Errorf("Invalid vbucket id %d", vb)
}
masterID := vbm.VBucketMap[vb][0]
master := feed.bucket.getMasterNode(masterID)
if master == "" {
return fmt.Errorf("Master node not found for vbucket %d", vb)
}
singleFeed := feed.nodeFeeds[master]
if singleFeed == nil {
return fmt.Errorf("UprFeed for this host not found")
}
if err := singleFeed.uprFeed.CloseStream(vb, opaqueMSB); err != nil {
return err
}
return nil
} | [
"func",
"(",
"feed",
"*",
"UprFeed",
")",
"UprCloseStream",
"(",
"vb",
",",
"opaqueMSB",
"uint16",
")",
"error",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"log",
".",
"Panicf",
"(",
"\"",
"\"",
",",
"feed",
",",
"feed",
".",
"bucket",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"vbm",
":=",
"feed",
".",
"bucket",
".",
"VBServerMap",
"(",
")",
"\n",
"if",
"len",
"(",
"vbm",
".",
"VBucketMap",
")",
"<",
"int",
"(",
"vb",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vb",
",",
"vbm",
".",
"VBucketMap",
")",
"\n",
"}",
"\n\n",
"if",
"int",
"(",
"vb",
")",
">=",
"len",
"(",
"vbm",
".",
"VBucketMap",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vb",
")",
"\n",
"}",
"\n\n",
"masterID",
":=",
"vbm",
".",
"VBucketMap",
"[",
"vb",
"]",
"[",
"0",
"]",
"\n",
"master",
":=",
"feed",
".",
"bucket",
".",
"getMasterNode",
"(",
"masterID",
")",
"\n",
"if",
"master",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vb",
")",
"\n",
"}",
"\n",
"singleFeed",
":=",
"feed",
".",
"nodeFeeds",
"[",
"master",
"]",
"\n",
"if",
"singleFeed",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"singleFeed",
".",
"uprFeed",
".",
"CloseStream",
"(",
"vb",
",",
"opaqueMSB",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UprCloseStream ends a vbucket stream. | [
"UprCloseStream",
"ends",
"a",
"vbucket",
"stream",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/upr.go#L176-L208 | train |
couchbase/go-couchbase | upr.go | forwardUprEvents | func (feed *UprFeed) forwardUprEvents(nodeFeed *FeedInfo, killSwitch chan bool, host string) {
singleFeed := nodeFeed.uprFeed
defer func() {
feed.wg.Done()
if r := recover(); r != nil {
//if feed is not closing, re-throw the panic
if feed.outputClosed != true && feed.closing != true {
panic(r)
} else {
logging.Errorf("Panic is recovered. Since feed is closed, exit gracefully")
}
}
}()
for {
select {
case <-nodeFeed.quit:
nodeFeed.connected = false
return
case event, ok := <-singleFeed.C:
if !ok {
if singleFeed.Error != nil {
logging.Errorf("go-couchbase: Upr feed from %s failed: %v", host, singleFeed.Error)
}
killSwitch <- true
return
}
if feed.outputClosed == true {
// someone closed the node feed
logging.Infof("Node need closed, returning from forwardUprEvent")
return
}
feed.output <- event
if event.Status == gomemcached.NOT_MY_VBUCKET {
logging.Infof(" Got a not my vbucket error !! ")
if err := feed.bucket.Refresh(); err != nil {
logging.Errorf("Unable to refresh bucket %s ", err.Error())
feed.closeNodeFeeds()
return
}
// this will only connect to nodes that are not connected or changed
// user will have to reconnect the stream
if err := feed.connectToNodes(); err != nil {
logging.Errorf("Unable to connect to nodes %s", err.Error())
return
}
}
}
}
} | go | func (feed *UprFeed) forwardUprEvents(nodeFeed *FeedInfo, killSwitch chan bool, host string) {
singleFeed := nodeFeed.uprFeed
defer func() {
feed.wg.Done()
if r := recover(); r != nil {
//if feed is not closing, re-throw the panic
if feed.outputClosed != true && feed.closing != true {
panic(r)
} else {
logging.Errorf("Panic is recovered. Since feed is closed, exit gracefully")
}
}
}()
for {
select {
case <-nodeFeed.quit:
nodeFeed.connected = false
return
case event, ok := <-singleFeed.C:
if !ok {
if singleFeed.Error != nil {
logging.Errorf("go-couchbase: Upr feed from %s failed: %v", host, singleFeed.Error)
}
killSwitch <- true
return
}
if feed.outputClosed == true {
// someone closed the node feed
logging.Infof("Node need closed, returning from forwardUprEvent")
return
}
feed.output <- event
if event.Status == gomemcached.NOT_MY_VBUCKET {
logging.Infof(" Got a not my vbucket error !! ")
if err := feed.bucket.Refresh(); err != nil {
logging.Errorf("Unable to refresh bucket %s ", err.Error())
feed.closeNodeFeeds()
return
}
// this will only connect to nodes that are not connected or changed
// user will have to reconnect the stream
if err := feed.connectToNodes(); err != nil {
logging.Errorf("Unable to connect to nodes %s", err.Error())
return
}
}
}
}
} | [
"func",
"(",
"feed",
"*",
"UprFeed",
")",
"forwardUprEvents",
"(",
"nodeFeed",
"*",
"FeedInfo",
",",
"killSwitch",
"chan",
"bool",
",",
"host",
"string",
")",
"{",
"singleFeed",
":=",
"nodeFeed",
".",
"uprFeed",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"feed",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"//if feed is not closing, re-throw the panic",
"if",
"feed",
".",
"outputClosed",
"!=",
"true",
"&&",
"feed",
".",
"closing",
"!=",
"true",
"{",
"panic",
"(",
"r",
")",
"\n",
"}",
"else",
"{",
"logging",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"nodeFeed",
".",
"quit",
":",
"nodeFeed",
".",
"connected",
"=",
"false",
"\n",
"return",
"\n\n",
"case",
"event",
",",
"ok",
":=",
"<-",
"singleFeed",
".",
"C",
":",
"if",
"!",
"ok",
"{",
"if",
"singleFeed",
".",
"Error",
"!=",
"nil",
"{",
"logging",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"host",
",",
"singleFeed",
".",
"Error",
")",
"\n",
"}",
"\n",
"killSwitch",
"<-",
"true",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"feed",
".",
"outputClosed",
"==",
"true",
"{",
"// someone closed the node feed",
"logging",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"feed",
".",
"output",
"<-",
"event",
"\n",
"if",
"event",
".",
"Status",
"==",
"gomemcached",
".",
"NOT_MY_VBUCKET",
"{",
"logging",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"feed",
".",
"bucket",
".",
"Refresh",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"feed",
".",
"closeNodeFeeds",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"// this will only connect to nodes that are not connected or changed",
"// user will have to reconnect the stream",
"if",
"err",
":=",
"feed",
".",
"connectToNodes",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Goroutine that forwards Upr events from a single node's feed to the aggregate feed. | [
"Goroutine",
"that",
"forwards",
"Upr",
"events",
"from",
"a",
"single",
"node",
"s",
"feed",
"to",
"the",
"aggregate",
"feed",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/upr.go#L315-L368 | train |
couchbase/go-couchbase | upr.go | Close | func (feed *UprFeed) Close() error {
select {
case <-feed.quit:
return nil
default:
}
feed.closing = true
feed.closeNodeFeeds()
close(feed.quit)
feed.wg.Wait()
if feed.outputClosed == false {
feed.outputClosed = true
close(feed.output)
}
return nil
} | go | func (feed *UprFeed) Close() error {
select {
case <-feed.quit:
return nil
default:
}
feed.closing = true
feed.closeNodeFeeds()
close(feed.quit)
feed.wg.Wait()
if feed.outputClosed == false {
feed.outputClosed = true
close(feed.output)
}
return nil
} | [
"func",
"(",
"feed",
"*",
"UprFeed",
")",
"Close",
"(",
")",
"error",
"{",
"select",
"{",
"case",
"<-",
"feed",
".",
"quit",
":",
"return",
"nil",
"\n",
"default",
":",
"}",
"\n\n",
"feed",
".",
"closing",
"=",
"true",
"\n",
"feed",
".",
"closeNodeFeeds",
"(",
")",
"\n",
"close",
"(",
"feed",
".",
"quit",
")",
"\n\n",
"feed",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"if",
"feed",
".",
"outputClosed",
"==",
"false",
"{",
"feed",
".",
"outputClosed",
"=",
"true",
"\n",
"close",
"(",
"feed",
".",
"output",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close a Upr feed. | [
"Close",
"a",
"Upr",
"feed",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/upr.go#L380-L398 | train |
couchbase/go-couchbase | client.go | IsRefreshRequired | func IsRefreshRequired(err error) bool {
res, ok := err.(*gomemcached.MCResponse)
if ok && (res.Status == gomemcached.NO_BUCKET || res.Status == gomemcached.NOT_MY_VBUCKET) {
return true
}
return false
} | go | func IsRefreshRequired(err error) bool {
res, ok := err.(*gomemcached.MCResponse)
if ok && (res.Status == gomemcached.NO_BUCKET || res.Status == gomemcached.NOT_MY_VBUCKET) {
return true
}
return false
} | [
"func",
"IsRefreshRequired",
"(",
"err",
"error",
")",
"bool",
"{",
"res",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"gomemcached",
".",
"MCResponse",
")",
"\n",
"if",
"ok",
"&&",
"(",
"res",
".",
"Status",
"==",
"gomemcached",
".",
"NO_BUCKET",
"||",
"res",
".",
"Status",
"==",
"gomemcached",
".",
"NOT_MY_VBUCKET",
")",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Return true if error suggests a bucket refresh is required. Required by cbq-engine | [
"Return",
"true",
"if",
"error",
"suggests",
"a",
"bucket",
"refresh",
"is",
"required",
".",
"Required",
"by",
"cbq",
"-",
"engine"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L91-L99 | train |
couchbase/go-couchbase | client.go | Do | func (b *Bucket) Do(k string, f func(mc *memcached.Client, vb uint16) error) (err error) {
return b.Do2(k, f, true)
} | go | func (b *Bucket) Do(k string, f func(mc *memcached.Client, vb uint16) error) (err error) {
return b.Do2(k, f, true)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Do",
"(",
"k",
"string",
",",
"f",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
")",
"(",
"err",
"error",
")",
"{",
"return",
"b",
".",
"Do2",
"(",
"k",
",",
"f",
",",
"true",
")",
"\n",
"}"
] | // Do executes a function on a memcached connection to the node owning key "k"
//
// Note that this automatically handles transient errors by replaying
// your function on a "not-my-vbucket" error, so don't assume
// your command will only be executed only once. | [
"Do",
"executes",
"a",
"function",
"on",
"a",
"memcached",
"connection",
"to",
"the",
"node",
"owning",
"key",
"k",
"Note",
"that",
"this",
"automatically",
"handles",
"transient",
"errors",
"by",
"replaying",
"your",
"function",
"on",
"a",
"not",
"-",
"my",
"-",
"vbucket",
"error",
"so",
"don",
"t",
"assume",
"your",
"command",
"will",
"only",
"be",
"executed",
"only",
"once",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L109-L111 | train |
couchbase/go-couchbase | client.go | GetStats | func (b *Bucket) GetStats(which string) map[string]map[string]string {
rv := map[string]map[string]string{}
for server, gs := range b.GatherStats(which) {
if len(gs.Stats) > 0 {
rv[server] = gs.Stats
}
}
return rv
} | go | func (b *Bucket) GetStats(which string) map[string]map[string]string {
rv := map[string]map[string]string{}
for server, gs := range b.GatherStats(which) {
if len(gs.Stats) > 0 {
rv[server] = gs.Stats
}
}
return rv
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetStats",
"(",
"which",
"string",
")",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"string",
"{",
"rv",
":=",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"for",
"server",
",",
"gs",
":=",
"range",
"b",
".",
"GatherStats",
"(",
"which",
")",
"{",
"if",
"len",
"(",
"gs",
".",
"Stats",
")",
">",
"0",
"{",
"rv",
"[",
"server",
"]",
"=",
"gs",
".",
"Stats",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"rv",
"\n",
"}"
] | // GetStats gets a set of stats from all servers.
//
// Returns a map of server ID -> map of stat key to map value. | [
"GetStats",
"gets",
"a",
"set",
"of",
"stats",
"from",
"all",
"servers",
".",
"Returns",
"a",
"map",
"of",
"server",
"ID",
"-",
">",
"map",
"of",
"stat",
"key",
"to",
"map",
"value",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L206-L214 | train |
couchbase/go-couchbase | client.go | GatherStats | func (b *Bucket) GatherStats(which string) map[string]GatheredStats {
vsm := b.VBServerMap()
if vsm.ServerList == nil {
return nil
}
// Go grab all the things at once.
ch := make(chan GatheredStats, len(vsm.ServerList))
for i, sn := range vsm.ServerList {
go getStatsParallel(sn, b, i, which, ch)
}
// Gather the results
rv := map[string]GatheredStats{}
for range vsm.ServerList {
gs := <-ch
rv[gs.Server] = gs
}
return rv
} | go | func (b *Bucket) GatherStats(which string) map[string]GatheredStats {
vsm := b.VBServerMap()
if vsm.ServerList == nil {
return nil
}
// Go grab all the things at once.
ch := make(chan GatheredStats, len(vsm.ServerList))
for i, sn := range vsm.ServerList {
go getStatsParallel(sn, b, i, which, ch)
}
// Gather the results
rv := map[string]GatheredStats{}
for range vsm.ServerList {
gs := <-ch
rv[gs.Server] = gs
}
return rv
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GatherStats",
"(",
"which",
"string",
")",
"map",
"[",
"string",
"]",
"GatheredStats",
"{",
"vsm",
":=",
"b",
".",
"VBServerMap",
"(",
")",
"\n",
"if",
"vsm",
".",
"ServerList",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Go grab all the things at once.",
"ch",
":=",
"make",
"(",
"chan",
"GatheredStats",
",",
"len",
"(",
"vsm",
".",
"ServerList",
")",
")",
"\n",
"for",
"i",
",",
"sn",
":=",
"range",
"vsm",
".",
"ServerList",
"{",
"go",
"getStatsParallel",
"(",
"sn",
",",
"b",
",",
"i",
",",
"which",
",",
"ch",
")",
"\n",
"}",
"\n\n",
"// Gather the results",
"rv",
":=",
"map",
"[",
"string",
"]",
"GatheredStats",
"{",
"}",
"\n",
"for",
"range",
"vsm",
".",
"ServerList",
"{",
"gs",
":=",
"<-",
"ch",
"\n",
"rv",
"[",
"gs",
".",
"Server",
"]",
"=",
"gs",
"\n",
"}",
"\n",
"return",
"rv",
"\n",
"}"
] | // GatherStats returns a map of server ID -> GatheredStats from all servers. | [
"GatherStats",
"returns",
"a",
"map",
"of",
"server",
"ID",
"-",
">",
"GatheredStats",
"from",
"all",
"servers",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L217-L236 | train |
couchbase/go-couchbase | client.go | GetCount | func (b *Bucket) GetCount(refresh bool) (count int64, err error) {
if refresh {
b.Refresh()
}
var cnt int64
for _, gs := range b.GatherStats("") {
if len(gs.Stats) > 0 {
cnt, err = strconv.ParseInt(gs.Stats["curr_items"], 10, 64)
if err != nil {
return 0, err
}
count += cnt
}
}
return count, nil
} | go | func (b *Bucket) GetCount(refresh bool) (count int64, err error) {
if refresh {
b.Refresh()
}
var cnt int64
for _, gs := range b.GatherStats("") {
if len(gs.Stats) > 0 {
cnt, err = strconv.ParseInt(gs.Stats["curr_items"], 10, 64)
if err != nil {
return 0, err
}
count += cnt
}
}
return count, nil
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetCount",
"(",
"refresh",
"bool",
")",
"(",
"count",
"int64",
",",
"err",
"error",
")",
"{",
"if",
"refresh",
"{",
"b",
".",
"Refresh",
"(",
")",
"\n",
"}",
"\n\n",
"var",
"cnt",
"int64",
"\n",
"for",
"_",
",",
"gs",
":=",
"range",
"b",
".",
"GatherStats",
"(",
"\"",
"\"",
")",
"{",
"if",
"len",
"(",
"gs",
".",
"Stats",
")",
">",
"0",
"{",
"cnt",
",",
"err",
"=",
"strconv",
".",
"ParseInt",
"(",
"gs",
".",
"Stats",
"[",
"\"",
"\"",
"]",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"count",
"+=",
"cnt",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"count",
",",
"nil",
"\n",
"}"
] | // Get bucket count through the bucket stats | [
"Get",
"bucket",
"count",
"through",
"the",
"bucket",
"stats"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L239-L256 | train |
couchbase/go-couchbase | client.go | GetSize | func (b *Bucket) GetSize(refresh bool) (size int64, err error) {
if refresh {
b.Refresh()
}
var sz int64
for _, gs := range b.GatherStats("") {
if len(gs.Stats) > 0 {
sz, err = strconv.ParseInt(gs.Stats["ep_value_size"], 10, 64)
if err != nil {
return 0, err
}
size += sz
}
}
return size, nil
} | go | func (b *Bucket) GetSize(refresh bool) (size int64, err error) {
if refresh {
b.Refresh()
}
var sz int64
for _, gs := range b.GatherStats("") {
if len(gs.Stats) > 0 {
sz, err = strconv.ParseInt(gs.Stats["ep_value_size"], 10, 64)
if err != nil {
return 0, err
}
size += sz
}
}
return size, nil
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetSize",
"(",
"refresh",
"bool",
")",
"(",
"size",
"int64",
",",
"err",
"error",
")",
"{",
"if",
"refresh",
"{",
"b",
".",
"Refresh",
"(",
")",
"\n",
"}",
"\n\n",
"var",
"sz",
"int64",
"\n",
"for",
"_",
",",
"gs",
":=",
"range",
"b",
".",
"GatherStats",
"(",
"\"",
"\"",
")",
"{",
"if",
"len",
"(",
"gs",
".",
"Stats",
")",
">",
"0",
"{",
"sz",
",",
"err",
"=",
"strconv",
".",
"ParseInt",
"(",
"gs",
".",
"Stats",
"[",
"\"",
"\"",
"]",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"size",
"+=",
"sz",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"size",
",",
"nil",
"\n",
"}"
] | // Get bucket document size through the bucket stats | [
"Get",
"bucket",
"document",
"size",
"through",
"the",
"bucket",
"stats"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L259-L276 | train |
couchbase/go-couchbase | client.go | isConnError | func isConnError(err error) bool {
if err == io.EOF {
return true
}
estr := err.Error()
return strings.Contains(estr, "broken pipe") ||
strings.Contains(estr, "connection reset") ||
strings.Contains(estr, "connection refused") ||
strings.Contains(estr, "connection pool is closed")
} | go | func isConnError(err error) bool {
if err == io.EOF {
return true
}
estr := err.Error()
return strings.Contains(estr, "broken pipe") ||
strings.Contains(estr, "connection reset") ||
strings.Contains(estr, "connection refused") ||
strings.Contains(estr, "connection pool is closed")
} | [
"func",
"isConnError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"true",
"\n",
"}",
"\n",
"estr",
":=",
"err",
".",
"Error",
"(",
")",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"estr",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"estr",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"estr",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"estr",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // Errors that are not considered fatal for our fetch loop | [
"Errors",
"that",
"are",
"not",
"considered",
"fatal",
"for",
"our",
"fetch",
"loop"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L297-L306 | train |
couchbase/go-couchbase | client.go | GetBulk | func (b *Bucket) GetBulk(keys []string, reqDeadline time.Time, subPaths []string) (map[string]*gomemcached.MCResponse, error) {
return b.getBulk(keys, reqDeadline, subPaths)
} | go | func (b *Bucket) GetBulk(keys []string, reqDeadline time.Time, subPaths []string) (map[string]*gomemcached.MCResponse, error) {
return b.getBulk(keys, reqDeadline, subPaths)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetBulk",
"(",
"keys",
"[",
"]",
"string",
",",
"reqDeadline",
"time",
".",
"Time",
",",
"subPaths",
"[",
"]",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"gomemcached",
".",
"MCResponse",
",",
"error",
")",
"{",
"return",
"b",
".",
"getBulk",
"(",
"keys",
",",
"reqDeadline",
",",
"subPaths",
")",
"\n",
"}"
] | // GetBulk fetches multiple keys concurrently.
//
// Unlike more convenient GETs, the entire response is returned in the
// map array for each key. Keys that were not found will not be included in
// the map. | [
"GetBulk",
"fetches",
"multiple",
"keys",
"concurrently",
".",
"Unlike",
"more",
"convenient",
"GETs",
"the",
"entire",
"response",
"is",
"returned",
"in",
"the",
"map",
"array",
"for",
"each",
"key",
".",
"Keys",
"that",
"were",
"not",
"found",
"will",
"not",
"be",
"included",
"in",
"the",
"map",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L635-L637 | train |
couchbase/go-couchbase | client.go | String | func (w WriteOptions) String() string {
f := []string{}
for _, on := range optNames {
if w&on.opt != 0 {
f = append(f, on.name)
w &= ^on.opt
}
}
if len(f) == 0 || w != 0 {
f = append(f, fmt.Sprintf("0x%x", int(w)))
}
return strings.Join(f, "|")
} | go | func (w WriteOptions) String() string {
f := []string{}
for _, on := range optNames {
if w&on.opt != 0 {
f = append(f, on.name)
w &= ^on.opt
}
}
if len(f) == 0 || w != 0 {
f = append(f, fmt.Sprintf("0x%x", int(w)))
}
return strings.Join(f, "|")
} | [
"func",
"(",
"w",
"WriteOptions",
")",
"String",
"(",
")",
"string",
"{",
"f",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"on",
":=",
"range",
"optNames",
"{",
"if",
"w",
"&",
"on",
".",
"opt",
"!=",
"0",
"{",
"f",
"=",
"append",
"(",
"f",
",",
"on",
".",
"name",
")",
"\n",
"w",
"&=",
"^",
"on",
".",
"opt",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"f",
")",
"==",
"0",
"||",
"w",
"!=",
"0",
"{",
"f",
"=",
"append",
"(",
"f",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"int",
"(",
"w",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // String representation of WriteOptions | [
"String",
"representation",
"of",
"WriteOptions"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L716-L728 | train |
couchbase/go-couchbase | client.go | Cas | func (b *Bucket) Cas(k string, exp int, cas uint64, v interface{}) (uint64, error) {
return b.WriteCas(k, 0, exp, cas, v, 0)
} | go | func (b *Bucket) Cas(k string, exp int, cas uint64, v interface{}) (uint64, error) {
return b.WriteCas(k, 0, exp, cas, v, 0)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Cas",
"(",
"k",
"string",
",",
"exp",
"int",
",",
"cas",
"uint64",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"return",
"b",
".",
"WriteCas",
"(",
"k",
",",
"0",
",",
"exp",
",",
"cas",
",",
"v",
",",
"0",
")",
"\n",
"}"
] | // Set a value in this bucket with Cas and return the new Cas value | [
"Set",
"a",
"value",
"in",
"this",
"bucket",
"with",
"Cas",
"and",
"return",
"the",
"new",
"Cas",
"value"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L846-L848 | train |
couchbase/go-couchbase | client.go | CasRaw | func (b *Bucket) CasRaw(k string, exp int, cas uint64, v interface{}) (uint64, error) {
return b.WriteCas(k, 0, exp, cas, v, Raw)
} | go | func (b *Bucket) CasRaw(k string, exp int, cas uint64, v interface{}) (uint64, error) {
return b.WriteCas(k, 0, exp, cas, v, Raw)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"CasRaw",
"(",
"k",
"string",
",",
"exp",
"int",
",",
"cas",
"uint64",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"return",
"b",
".",
"WriteCas",
"(",
"k",
",",
"0",
",",
"exp",
",",
"cas",
",",
"v",
",",
"Raw",
")",
"\n",
"}"
] | // Set a value in this bucket with Cas without json encoding it | [
"Set",
"a",
"value",
"in",
"this",
"bucket",
"with",
"Cas",
"without",
"json",
"encoding",
"it"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L851-L853 | train |
couchbase/go-couchbase | client.go | CasWithMeta | func (b *Bucket) CasWithMeta(k string, flags int, exp int, cas uint64, v interface{}) (uint64, *MutationToken, error) {
return b.WriteCasWithMT(k, flags, exp, cas, v, 0)
} | go | func (b *Bucket) CasWithMeta(k string, flags int, exp int, cas uint64, v interface{}) (uint64, *MutationToken, error) {
return b.WriteCasWithMT(k, flags, exp, cas, v, 0)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"CasWithMeta",
"(",
"k",
"string",
",",
"flags",
"int",
",",
"exp",
"int",
",",
"cas",
"uint64",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"uint64",
",",
"*",
"MutationToken",
",",
"error",
")",
"{",
"return",
"b",
".",
"WriteCasWithMT",
"(",
"k",
",",
"flags",
",",
"exp",
",",
"cas",
",",
"v",
",",
"0",
")",
"\n",
"}"
] | // Extended CAS operation. These functions will return the mutation token, i.e vbuuid & guard | [
"Extended",
"CAS",
"operation",
".",
"These",
"functions",
"will",
"return",
"the",
"mutation",
"token",
"i",
".",
"e",
"vbuuid",
"&",
"guard"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L888-L890 | train |
couchbase/go-couchbase | client.go | Set | func (b *Bucket) Set(k string, exp int, v interface{}) error {
return b.Write(k, 0, exp, v, 0)
} | go | func (b *Bucket) Set(k string, exp int, v interface{}) error {
return b.Write(k, 0, exp, v, 0)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Set",
"(",
"k",
"string",
",",
"exp",
"int",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"b",
".",
"Write",
"(",
"k",
",",
"0",
",",
"exp",
",",
"v",
",",
"0",
")",
"\n",
"}"
] | // Set a value in this bucket.
// The value will be serialized into a JSON document. | [
"Set",
"a",
"value",
"in",
"this",
"bucket",
".",
"The",
"value",
"will",
"be",
"serialized",
"into",
"a",
"JSON",
"document",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L942-L944 | train |
couchbase/go-couchbase | client.go | SetWithMeta | func (b *Bucket) SetWithMeta(k string, flags int, exp int, v interface{}) (*MutationToken, error) {
return b.WriteWithMT(k, flags, exp, v, 0)
} | go | func (b *Bucket) SetWithMeta(k string, flags int, exp int, v interface{}) (*MutationToken, error) {
return b.WriteWithMT(k, flags, exp, v, 0)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"SetWithMeta",
"(",
"k",
"string",
",",
"flags",
"int",
",",
"exp",
"int",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"*",
"MutationToken",
",",
"error",
")",
"{",
"return",
"b",
".",
"WriteWithMT",
"(",
"k",
",",
"flags",
",",
"exp",
",",
"v",
",",
"0",
")",
"\n",
"}"
] | // Set a value in this bucket with with flags | [
"Set",
"a",
"value",
"in",
"this",
"bucket",
"with",
"with",
"flags"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L947-L949 | train |
couchbase/go-couchbase | client.go | SetRaw | func (b *Bucket) SetRaw(k string, exp int, v []byte) error {
return b.Write(k, 0, exp, v, Raw)
} | go | func (b *Bucket) SetRaw(k string, exp int, v []byte) error {
return b.Write(k, 0, exp, v, Raw)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"SetRaw",
"(",
"k",
"string",
",",
"exp",
"int",
",",
"v",
"[",
"]",
"byte",
")",
"error",
"{",
"return",
"b",
".",
"Write",
"(",
"k",
",",
"0",
",",
"exp",
",",
"v",
",",
"Raw",
")",
"\n",
"}"
] | // SetRaw sets a value in this bucket without JSON encoding it. | [
"SetRaw",
"sets",
"a",
"value",
"in",
"this",
"bucket",
"without",
"JSON",
"encoding",
"it",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L952-L954 | train |
couchbase/go-couchbase | client.go | Append | func (b *Bucket) Append(k string, data []byte) error {
return b.Write(k, 0, 0, data, Append|Raw)
} | go | func (b *Bucket) Append(k string, data []byte) error {
return b.Write(k, 0, 0, data, Append|Raw)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Append",
"(",
"k",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"return",
"b",
".",
"Write",
"(",
"k",
",",
"0",
",",
"0",
",",
"data",
",",
"Append",
"|",
"Raw",
")",
"\n",
"}"
] | // Append appends raw data to an existing item. | [
"Append",
"appends",
"raw",
"data",
"to",
"an",
"existing",
"item",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L999-L1001 | train |
couchbase/go-couchbase | client.go | GetCollectionCID | func (b *Bucket) GetCollectionCID(scope string, collection string, reqDeadline time.Time) (uint32, uint32, error) {
var err error
var response *gomemcached.MCResponse
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetCollectionCID", scope+"."+collection, t, err) }(time.Now())
}
var key = "DUMMY" // Contact any server.
var manifestUid uint32
var collUid uint32
err = b.Do2(key, func(mc *memcached.Client, vb uint16) error {
var err1 error
mc.SetDeadline(getDeadline(reqDeadline, DefaultTimeout))
_, err1 = mc.SelectBucket(b.Name)
if err1 != nil {
mc.SetDeadline(noDeadline)
return err1
}
response, err1 = mc.CollectionsGetCID(scope, collection)
if err1 != nil {
mc.SetDeadline(noDeadline)
return err1
}
manifestUid = binary.BigEndian.Uint32(response.Extras[4:8])
collUid = binary.BigEndian.Uint32(response.Extras[8:12])
return nil
}, false)
return collUid, manifestUid, err
} | go | func (b *Bucket) GetCollectionCID(scope string, collection string, reqDeadline time.Time) (uint32, uint32, error) {
var err error
var response *gomemcached.MCResponse
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetCollectionCID", scope+"."+collection, t, err) }(time.Now())
}
var key = "DUMMY" // Contact any server.
var manifestUid uint32
var collUid uint32
err = b.Do2(key, func(mc *memcached.Client, vb uint16) error {
var err1 error
mc.SetDeadline(getDeadline(reqDeadline, DefaultTimeout))
_, err1 = mc.SelectBucket(b.Name)
if err1 != nil {
mc.SetDeadline(noDeadline)
return err1
}
response, err1 = mc.CollectionsGetCID(scope, collection)
if err1 != nil {
mc.SetDeadline(noDeadline)
return err1
}
manifestUid = binary.BigEndian.Uint32(response.Extras[4:8])
collUid = binary.BigEndian.Uint32(response.Extras[8:12])
return nil
}, false)
return collUid, manifestUid, err
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetCollectionCID",
"(",
"scope",
"string",
",",
"collection",
"string",
",",
"reqDeadline",
"time",
".",
"Time",
")",
"(",
"uint32",
",",
"uint32",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"response",
"*",
"gomemcached",
".",
"MCResponse",
"\n\n",
"if",
"ClientOpCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ClientOpCallback",
"(",
"\"",
"\"",
",",
"scope",
"+",
"\"",
"\"",
"+",
"collection",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"var",
"key",
"=",
"\"",
"\"",
"// Contact any server.",
"\n",
"var",
"manifestUid",
"uint32",
"\n",
"var",
"collUid",
"uint32",
"\n",
"err",
"=",
"b",
".",
"Do2",
"(",
"key",
",",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
"{",
"var",
"err1",
"error",
"\n\n",
"mc",
".",
"SetDeadline",
"(",
"getDeadline",
"(",
"reqDeadline",
",",
"DefaultTimeout",
")",
")",
"\n",
"_",
",",
"err1",
"=",
"mc",
".",
"SelectBucket",
"(",
"b",
".",
"Name",
")",
"\n",
"if",
"err1",
"!=",
"nil",
"{",
"mc",
".",
"SetDeadline",
"(",
"noDeadline",
")",
"\n",
"return",
"err1",
"\n",
"}",
"\n\n",
"response",
",",
"err1",
"=",
"mc",
".",
"CollectionsGetCID",
"(",
"scope",
",",
"collection",
")",
"\n",
"if",
"err1",
"!=",
"nil",
"{",
"mc",
".",
"SetDeadline",
"(",
"noDeadline",
")",
"\n",
"return",
"err1",
"\n",
"}",
"\n\n",
"manifestUid",
"=",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"response",
".",
"Extras",
"[",
"4",
":",
"8",
"]",
")",
"\n",
"collUid",
"=",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"response",
".",
"Extras",
"[",
"8",
":",
"12",
"]",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
",",
"false",
")",
"\n\n",
"return",
"collUid",
",",
"manifestUid",
",",
"err",
"\n",
"}"
] | // Returns collectionUid, manifestUid, error. | [
"Returns",
"collectionUid",
"manifestUid",
"error",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1039-L1073 | train |
couchbase/go-couchbase | client.go | GetsMC | func (b *Bucket) GetsMC(key string, reqDeadline time.Time) (*gomemcached.MCResponse, error) {
var err error
var response *gomemcached.MCResponse
if key == "" {
return nil, nil
}
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsMC", key, t, err) }(time.Now())
}
err = b.Do2(key, func(mc *memcached.Client, vb uint16) error {
var err1 error
mc.SetDeadline(getDeadline(reqDeadline, DefaultTimeout))
response, err1 = mc.Get(vb, key)
mc.SetDeadline(noDeadline)
if err1 != nil {
return err1
}
return nil
}, false)
return response, err
} | go | func (b *Bucket) GetsMC(key string, reqDeadline time.Time) (*gomemcached.MCResponse, error) {
var err error
var response *gomemcached.MCResponse
if key == "" {
return nil, nil
}
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsMC", key, t, err) }(time.Now())
}
err = b.Do2(key, func(mc *memcached.Client, vb uint16) error {
var err1 error
mc.SetDeadline(getDeadline(reqDeadline, DefaultTimeout))
response, err1 = mc.Get(vb, key)
mc.SetDeadline(noDeadline)
if err1 != nil {
return err1
}
return nil
}, false)
return response, err
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetsMC",
"(",
"key",
"string",
",",
"reqDeadline",
"time",
".",
"Time",
")",
"(",
"*",
"gomemcached",
".",
"MCResponse",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"response",
"*",
"gomemcached",
".",
"MCResponse",
"\n\n",
"if",
"key",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"ClientOpCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ClientOpCallback",
"(",
"\"",
"\"",
",",
"key",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"b",
".",
"Do2",
"(",
"key",
",",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
"{",
"var",
"err1",
"error",
"\n\n",
"mc",
".",
"SetDeadline",
"(",
"getDeadline",
"(",
"reqDeadline",
",",
"DefaultTimeout",
")",
")",
"\n",
"response",
",",
"err1",
"=",
"mc",
".",
"Get",
"(",
"vb",
",",
"key",
")",
"\n",
"mc",
".",
"SetDeadline",
"(",
"noDeadline",
")",
"\n",
"if",
"err1",
"!=",
"nil",
"{",
"return",
"err1",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
",",
"false",
")",
"\n",
"return",
"response",
",",
"err",
"\n",
"}"
] | // Get a value straight from Memcached | [
"Get",
"a",
"value",
"straight",
"from",
"Memcached"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1076-L1100 | train |
couchbase/go-couchbase | client.go | GetsRaw | func (b *Bucket) GetsRaw(k string) (data []byte, flags int,
cas uint64, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsRaw", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.Get(vb, k)
if err != nil {
return err
}
cas = res.Cas
if len(res.Extras) >= 4 {
flags = int(binary.BigEndian.Uint32(res.Extras))
}
data = res.Body
return nil
})
return
} | go | func (b *Bucket) GetsRaw(k string) (data []byte, flags int,
cas uint64, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsRaw", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.Get(vb, k)
if err != nil {
return err
}
cas = res.Cas
if len(res.Extras) >= 4 {
flags = int(binary.BigEndian.Uint32(res.Extras))
}
data = res.Body
return nil
})
return
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetsRaw",
"(",
"k",
"string",
")",
"(",
"data",
"[",
"]",
"byte",
",",
"flags",
"int",
",",
"cas",
"uint64",
",",
"err",
"error",
")",
"{",
"if",
"ClientOpCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ClientOpCallback",
"(",
"\"",
"\"",
",",
"k",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"b",
".",
"Do",
"(",
"k",
",",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
"{",
"res",
",",
"err",
":=",
"mc",
".",
"Get",
"(",
"vb",
",",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"cas",
"=",
"res",
".",
"Cas",
"\n",
"if",
"len",
"(",
"res",
".",
"Extras",
")",
">=",
"4",
"{",
"flags",
"=",
"int",
"(",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"res",
".",
"Extras",
")",
")",
"\n",
"}",
"\n",
"data",
"=",
"res",
".",
"Body",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] | // GetsRaw gets a raw value from this bucket including its CAS
// counter and flags. | [
"GetsRaw",
"gets",
"a",
"raw",
"value",
"from",
"this",
"bucket",
"including",
"its",
"CAS",
"counter",
"and",
"flags",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1131-L1151 | train |
couchbase/go-couchbase | client.go | Gets | func (b *Bucket) Gets(k string, rv interface{}, caso *uint64) error {
data, _, cas, err := b.GetsRaw(k)
if err != nil {
return err
}
if caso != nil {
*caso = cas
}
return json.Unmarshal(data, rv)
} | go | func (b *Bucket) Gets(k string, rv interface{}, caso *uint64) error {
data, _, cas, err := b.GetsRaw(k)
if err != nil {
return err
}
if caso != nil {
*caso = cas
}
return json.Unmarshal(data, rv)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Gets",
"(",
"k",
"string",
",",
"rv",
"interface",
"{",
"}",
",",
"caso",
"*",
"uint64",
")",
"error",
"{",
"data",
",",
"_",
",",
"cas",
",",
"err",
":=",
"b",
".",
"GetsRaw",
"(",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"caso",
"!=",
"nil",
"{",
"*",
"caso",
"=",
"cas",
"\n",
"}",
"\n",
"return",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"rv",
")",
"\n",
"}"
] | // Gets gets a value from this bucket, including its CAS counter. The
// value is expected to be a JSON stream and will be deserialized into
// rv. | [
"Gets",
"gets",
"a",
"value",
"from",
"this",
"bucket",
"including",
"its",
"CAS",
"counter",
".",
"The",
"value",
"is",
"expected",
"to",
"be",
"a",
"JSON",
"stream",
"and",
"will",
"be",
"deserialized",
"into",
"rv",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1156-L1165 | train |
couchbase/go-couchbase | client.go | Get | func (b *Bucket) Get(k string, rv interface{}) error {
return b.Gets(k, rv, nil)
} | go | func (b *Bucket) Get(k string, rv interface{}) error {
return b.Gets(k, rv, nil)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Get",
"(",
"k",
"string",
",",
"rv",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"b",
".",
"Gets",
"(",
"k",
",",
"rv",
",",
"nil",
")",
"\n",
"}"
] | // Get a value from this bucket.
// The value is expected to be a JSON stream and will be deserialized
// into rv. | [
"Get",
"a",
"value",
"from",
"this",
"bucket",
".",
"The",
"value",
"is",
"expected",
"to",
"be",
"a",
"JSON",
"stream",
"and",
"will",
"be",
"deserialized",
"into",
"rv",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1170-L1172 | train |
couchbase/go-couchbase | client.go | GetRaw | func (b *Bucket) GetRaw(k string) ([]byte, error) {
d, _, _, err := b.GetsRaw(k)
return d, err
} | go | func (b *Bucket) GetRaw(k string) ([]byte, error) {
d, _, _, err := b.GetsRaw(k)
return d, err
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetRaw",
"(",
"k",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"d",
",",
"_",
",",
"_",
",",
"err",
":=",
"b",
".",
"GetsRaw",
"(",
"k",
")",
"\n",
"return",
"d",
",",
"err",
"\n",
"}"
] | // GetRaw gets a raw value from this bucket. No marshaling is performed. | [
"GetRaw",
"gets",
"a",
"raw",
"value",
"from",
"this",
"bucket",
".",
"No",
"marshaling",
"is",
"performed",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1175-L1178 | train |
couchbase/go-couchbase | client.go | GetAndTouchRaw | func (b *Bucket) GetAndTouchRaw(k string, exp int) (data []byte,
cas uint64, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsRaw", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.GetAndTouch(vb, k, exp)
if err != nil {
return err
}
cas = res.Cas
data = res.Body
return nil
})
return data, cas, err
} | go | func (b *Bucket) GetAndTouchRaw(k string, exp int) (data []byte,
cas uint64, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsRaw", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.GetAndTouch(vb, k, exp)
if err != nil {
return err
}
cas = res.Cas
data = res.Body
return nil
})
return data, cas, err
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetAndTouchRaw",
"(",
"k",
"string",
",",
"exp",
"int",
")",
"(",
"data",
"[",
"]",
"byte",
",",
"cas",
"uint64",
",",
"err",
"error",
")",
"{",
"if",
"ClientOpCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ClientOpCallback",
"(",
"\"",
"\"",
",",
"k",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"b",
".",
"Do",
"(",
"k",
",",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
"{",
"res",
",",
"err",
":=",
"mc",
".",
"GetAndTouch",
"(",
"vb",
",",
"k",
",",
"exp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"cas",
"=",
"res",
".",
"Cas",
"\n",
"data",
"=",
"res",
".",
"Body",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"data",
",",
"cas",
",",
"err",
"\n",
"}"
] | // GetAndTouchRaw gets a raw value from this bucket including its CAS
// counter and flags, and updates the expiry on the doc. | [
"GetAndTouchRaw",
"gets",
"a",
"raw",
"value",
"from",
"this",
"bucket",
"including",
"its",
"CAS",
"counter",
"and",
"flags",
"and",
"updates",
"the",
"expiry",
"on",
"the",
"doc",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1182-L1199 | train |
couchbase/go-couchbase | client.go | GetMeta | func (b *Bucket) GetMeta(k string, flags *int, expiry *int, cas *uint64, seqNo *uint64) (err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsMeta", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.GetMeta(vb, k)
if err != nil {
return err
}
*cas = res.Cas
if len(res.Extras) >= 8 {
*flags = int(binary.BigEndian.Uint32(res.Extras[4:]))
}
if len(res.Extras) >= 12 {
*expiry = int(binary.BigEndian.Uint32(res.Extras[8:]))
}
if len(res.Extras) >= 20 {
*seqNo = uint64(binary.BigEndian.Uint64(res.Extras[12:]))
}
return nil
})
return err
} | go | func (b *Bucket) GetMeta(k string, flags *int, expiry *int, cas *uint64, seqNo *uint64) (err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("GetsMeta", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.GetMeta(vb, k)
if err != nil {
return err
}
*cas = res.Cas
if len(res.Extras) >= 8 {
*flags = int(binary.BigEndian.Uint32(res.Extras[4:]))
}
if len(res.Extras) >= 12 {
*expiry = int(binary.BigEndian.Uint32(res.Extras[8:]))
}
if len(res.Extras) >= 20 {
*seqNo = uint64(binary.BigEndian.Uint64(res.Extras[12:]))
}
return nil
})
return err
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"GetMeta",
"(",
"k",
"string",
",",
"flags",
"*",
"int",
",",
"expiry",
"*",
"int",
",",
"cas",
"*",
"uint64",
",",
"seqNo",
"*",
"uint64",
")",
"(",
"err",
"error",
")",
"{",
"if",
"ClientOpCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ClientOpCallback",
"(",
"\"",
"\"",
",",
"k",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"b",
".",
"Do",
"(",
"k",
",",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
"{",
"res",
",",
"err",
":=",
"mc",
".",
"GetMeta",
"(",
"vb",
",",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"*",
"cas",
"=",
"res",
".",
"Cas",
"\n",
"if",
"len",
"(",
"res",
".",
"Extras",
")",
">=",
"8",
"{",
"*",
"flags",
"=",
"int",
"(",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"res",
".",
"Extras",
"[",
"4",
":",
"]",
")",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
".",
"Extras",
")",
">=",
"12",
"{",
"*",
"expiry",
"=",
"int",
"(",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"res",
".",
"Extras",
"[",
"8",
":",
"]",
")",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
".",
"Extras",
")",
">=",
"20",
"{",
"*",
"seqNo",
"=",
"uint64",
"(",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"res",
".",
"Extras",
"[",
"12",
":",
"]",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | // GetMeta returns the meta values for a key | [
"GetMeta",
"returns",
"the",
"meta",
"values",
"for",
"a",
"key"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1202-L1231 | train |
couchbase/go-couchbase | client.go | Delete | func (b *Bucket) Delete(k string) error {
return b.Write(k, 0, 0, nil, Raw)
} | go | func (b *Bucket) Delete(k string) error {
return b.Write(k, 0, 0, nil, Raw)
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Delete",
"(",
"k",
"string",
")",
"error",
"{",
"return",
"b",
".",
"Write",
"(",
"k",
",",
"0",
",",
"0",
",",
"nil",
",",
"Raw",
")",
"\n",
"}"
] | // Delete a key from this bucket. | [
"Delete",
"a",
"key",
"from",
"this",
"bucket",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1234-L1236 | train |
couchbase/go-couchbase | client.go | Incr | func (b *Bucket) Incr(k string, amt, def uint64, exp int) (val uint64, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("Incr", k, t, err) }(time.Now())
}
var rv uint64
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.Incr(vb, k, amt, def, exp)
if err != nil {
return err
}
rv = res
return nil
})
return rv, err
} | go | func (b *Bucket) Incr(k string, amt, def uint64, exp int) (val uint64, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("Incr", k, t, err) }(time.Now())
}
var rv uint64
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
res, err := mc.Incr(vb, k, amt, def, exp)
if err != nil {
return err
}
rv = res
return nil
})
return rv, err
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Incr",
"(",
"k",
"string",
",",
"amt",
",",
"def",
"uint64",
",",
"exp",
"int",
")",
"(",
"val",
"uint64",
",",
"err",
"error",
")",
"{",
"if",
"ClientOpCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ClientOpCallback",
"(",
"\"",
"\"",
",",
"k",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"var",
"rv",
"uint64",
"\n",
"err",
"=",
"b",
".",
"Do",
"(",
"k",
",",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
"{",
"res",
",",
"err",
":=",
"mc",
".",
"Incr",
"(",
"vb",
",",
"k",
",",
"amt",
",",
"def",
",",
"exp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"rv",
"=",
"res",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"rv",
",",
"err",
"\n",
"}"
] | // Incr increments the value at a given key by amt and defaults to def if no value present. | [
"Incr",
"increments",
"the",
"value",
"at",
"a",
"given",
"key",
"by",
"amt",
"and",
"defaults",
"to",
"def",
"if",
"no",
"value",
"present",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1239-L1254 | train |
couchbase/go-couchbase | client.go | update | func (b *Bucket) update(k string, exp int, callback UpdateFunc) (newCas uint64, err error) {
var state memcached.CASState
for b.casNext(k, exp, &state) {
var err error
if state.Value, err = callback(state.Value); err != nil {
return 0, err
}
}
return state.Cas, state.Err
} | go | func (b *Bucket) update(k string, exp int, callback UpdateFunc) (newCas uint64, err error) {
var state memcached.CASState
for b.casNext(k, exp, &state) {
var err error
if state.Value, err = callback(state.Value); err != nil {
return 0, err
}
}
return state.Cas, state.Err
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"update",
"(",
"k",
"string",
",",
"exp",
"int",
",",
"callback",
"UpdateFunc",
")",
"(",
"newCas",
"uint64",
",",
"err",
"error",
")",
"{",
"var",
"state",
"memcached",
".",
"CASState",
"\n",
"for",
"b",
".",
"casNext",
"(",
"k",
",",
"exp",
",",
"&",
"state",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"state",
".",
"Value",
",",
"err",
"=",
"callback",
"(",
"state",
".",
"Value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"state",
".",
"Cas",
",",
"state",
".",
"Err",
"\n",
"}"
] | // internal version of Update that returns a CAS value | [
"internal",
"version",
"of",
"Update",
"that",
"returns",
"a",
"CAS",
"value"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1313-L1322 | train |
couchbase/go-couchbase | client.go | Observe | func (b *Bucket) Observe(k string) (result memcached.ObserveResult, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("Observe", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
result, err = mc.Observe(vb, k)
return err
})
return
} | go | func (b *Bucket) Observe(k string) (result memcached.ObserveResult, err error) {
if ClientOpCallback != nil {
defer func(t time.Time) { ClientOpCallback("Observe", k, t, err) }(time.Now())
}
err = b.Do(k, func(mc *memcached.Client, vb uint16) error {
result, err = mc.Observe(vb, k)
return err
})
return
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"Observe",
"(",
"k",
"string",
")",
"(",
"result",
"memcached",
".",
"ObserveResult",
",",
"err",
"error",
")",
"{",
"if",
"ClientOpCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ClientOpCallback",
"(",
"\"",
"\"",
",",
"k",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"b",
".",
"Do",
"(",
"k",
",",
"func",
"(",
"mc",
"*",
"memcached",
".",
"Client",
",",
"vb",
"uint16",
")",
"error",
"{",
"result",
",",
"err",
"=",
"mc",
".",
"Observe",
"(",
"vb",
",",
"k",
")",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] | // Observe observes the current state of a document. | [
"Observe",
"observes",
"the",
"current",
"state",
"of",
"a",
"document",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1355-L1365 | train |
couchbase/go-couchbase | client.go | WaitForPersistence | func (b *Bucket) WaitForPersistence(k string, cas uint64, deletion bool) error {
timeout := 10 * time.Second
sleepDelay := 5 * time.Millisecond
start := time.Now()
for {
time.Sleep(sleepDelay)
sleepDelay += sleepDelay / 2 // multiply delay by 1.5 every time
result, err := b.Observe(k)
if err != nil {
return err
}
if persisted, overwritten := result.CheckPersistence(cas, deletion); overwritten {
return ErrOverwritten
} else if persisted {
return nil
}
if result.PersistenceTime > 0 {
timeout = 2 * result.PersistenceTime
}
if time.Since(start) >= timeout-sleepDelay {
return ErrTimeout
}
}
} | go | func (b *Bucket) WaitForPersistence(k string, cas uint64, deletion bool) error {
timeout := 10 * time.Second
sleepDelay := 5 * time.Millisecond
start := time.Now()
for {
time.Sleep(sleepDelay)
sleepDelay += sleepDelay / 2 // multiply delay by 1.5 every time
result, err := b.Observe(k)
if err != nil {
return err
}
if persisted, overwritten := result.CheckPersistence(cas, deletion); overwritten {
return ErrOverwritten
} else if persisted {
return nil
}
if result.PersistenceTime > 0 {
timeout = 2 * result.PersistenceTime
}
if time.Since(start) >= timeout-sleepDelay {
return ErrTimeout
}
}
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"WaitForPersistence",
"(",
"k",
"string",
",",
"cas",
"uint64",
",",
"deletion",
"bool",
")",
"error",
"{",
"timeout",
":=",
"10",
"*",
"time",
".",
"Second",
"\n",
"sleepDelay",
":=",
"5",
"*",
"time",
".",
"Millisecond",
"\n",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"for",
"{",
"time",
".",
"Sleep",
"(",
"sleepDelay",
")",
"\n",
"sleepDelay",
"+=",
"sleepDelay",
"/",
"2",
"// multiply delay by 1.5 every time",
"\n\n",
"result",
",",
"err",
":=",
"b",
".",
"Observe",
"(",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"persisted",
",",
"overwritten",
":=",
"result",
".",
"CheckPersistence",
"(",
"cas",
",",
"deletion",
")",
";",
"overwritten",
"{",
"return",
"ErrOverwritten",
"\n",
"}",
"else",
"if",
"persisted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"result",
".",
"PersistenceTime",
">",
"0",
"{",
"timeout",
"=",
"2",
"*",
"result",
".",
"PersistenceTime",
"\n",
"}",
"\n",
"if",
"time",
".",
"Since",
"(",
"start",
")",
">=",
"timeout",
"-",
"sleepDelay",
"{",
"return",
"ErrTimeout",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WaitForPersistence waits for an item to be considered durable.
//
// Besides transport errors, ErrOverwritten may be returned if the
// item is overwritten before it reaches durability. ErrTimeout may
// occur if the item isn't found durable in a reasonable amount of
// time. | [
"WaitForPersistence",
"waits",
"for",
"an",
"item",
"to",
"be",
"considered",
"durable",
".",
"Besides",
"transport",
"errors",
"ErrOverwritten",
"may",
"be",
"returned",
"if",
"the",
"item",
"is",
"overwritten",
"before",
"it",
"reaches",
"durability",
".",
"ErrTimeout",
"may",
"occur",
"if",
"the",
"item",
"isn",
"t",
"found",
"durable",
"in",
"a",
"reasonable",
"amount",
"of",
"time",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/client.go#L1381-L1406 | train |
couchbase/go-couchbase | tap.go | StartTapFeed | func (b *Bucket) StartTapFeed(args *memcached.TapArguments) (*TapFeed, error) {
if args == nil {
defaultArgs := memcached.DefaultTapArguments()
args = &defaultArgs
}
feed := &TapFeed{
bucket: b,
args: args,
output: make(chan memcached.TapEvent, 10),
quit: make(chan bool),
}
go feed.run()
feed.C = feed.output
return feed, nil
} | go | func (b *Bucket) StartTapFeed(args *memcached.TapArguments) (*TapFeed, error) {
if args == nil {
defaultArgs := memcached.DefaultTapArguments()
args = &defaultArgs
}
feed := &TapFeed{
bucket: b,
args: args,
output: make(chan memcached.TapEvent, 10),
quit: make(chan bool),
}
go feed.run()
feed.C = feed.output
return feed, nil
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"StartTapFeed",
"(",
"args",
"*",
"memcached",
".",
"TapArguments",
")",
"(",
"*",
"TapFeed",
",",
"error",
")",
"{",
"if",
"args",
"==",
"nil",
"{",
"defaultArgs",
":=",
"memcached",
".",
"DefaultTapArguments",
"(",
")",
"\n",
"args",
"=",
"&",
"defaultArgs",
"\n",
"}",
"\n\n",
"feed",
":=",
"&",
"TapFeed",
"{",
"bucket",
":",
"b",
",",
"args",
":",
"args",
",",
"output",
":",
"make",
"(",
"chan",
"memcached",
".",
"TapEvent",
",",
"10",
")",
",",
"quit",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"}",
"\n\n",
"go",
"feed",
".",
"run",
"(",
")",
"\n\n",
"feed",
".",
"C",
"=",
"feed",
".",
"output",
"\n",
"return",
"feed",
",",
"nil",
"\n",
"}"
] | // StartTapFeed creates and starts a new Tap feed | [
"StartTapFeed",
"creates",
"and",
"starts",
"a",
"new",
"Tap",
"feed"
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/tap.go#L30-L47 | train |
couchbase/go-couchbase | tap.go | forwardTapEvents | func (feed *TapFeed) forwardTapEvents(singleFeed *memcached.TapFeed, killSwitch chan bool, host string) {
defer feed.wg.Done()
for {
select {
case event, ok := <-singleFeed.C:
if !ok {
if singleFeed.Error != nil {
logging.Errorf("go-couchbase: Tap feed from %s failed: %v", host, singleFeed.Error)
}
killSwitch <- true
return
}
feed.output <- event
case <-feed.quit:
return
}
}
} | go | func (feed *TapFeed) forwardTapEvents(singleFeed *memcached.TapFeed, killSwitch chan bool, host string) {
defer feed.wg.Done()
for {
select {
case event, ok := <-singleFeed.C:
if !ok {
if singleFeed.Error != nil {
logging.Errorf("go-couchbase: Tap feed from %s failed: %v", host, singleFeed.Error)
}
killSwitch <- true
return
}
feed.output <- event
case <-feed.quit:
return
}
}
} | [
"func",
"(",
"feed",
"*",
"TapFeed",
")",
"forwardTapEvents",
"(",
"singleFeed",
"*",
"memcached",
".",
"TapFeed",
",",
"killSwitch",
"chan",
"bool",
",",
"host",
"string",
")",
"{",
"defer",
"feed",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"event",
",",
"ok",
":=",
"<-",
"singleFeed",
".",
"C",
":",
"if",
"!",
"ok",
"{",
"if",
"singleFeed",
".",
"Error",
"!=",
"nil",
"{",
"logging",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"host",
",",
"singleFeed",
".",
"Error",
")",
"\n",
"}",
"\n",
"killSwitch",
"<-",
"true",
"\n",
"return",
"\n",
"}",
"\n",
"feed",
".",
"output",
"<-",
"event",
"\n",
"case",
"<-",
"feed",
".",
"quit",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Goroutine that forwards Tap events from a single node's feed to the aggregate feed. | [
"Goroutine",
"that",
"forwards",
"Tap",
"events",
"from",
"a",
"single",
"node",
"s",
"feed",
"to",
"the",
"aggregate",
"feed",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/tap.go#L104-L121 | train |
couchbase/go-couchbase | tap.go | Close | func (feed *TapFeed) Close() error {
select {
case <-feed.quit:
return nil
default:
}
feed.closeNodeFeeds()
close(feed.quit)
feed.wg.Wait()
close(feed.output)
return nil
} | go | func (feed *TapFeed) Close() error {
select {
case <-feed.quit:
return nil
default:
}
feed.closeNodeFeeds()
close(feed.quit)
feed.wg.Wait()
close(feed.output)
return nil
} | [
"func",
"(",
"feed",
"*",
"TapFeed",
")",
"Close",
"(",
")",
"error",
"{",
"select",
"{",
"case",
"<-",
"feed",
".",
"quit",
":",
"return",
"nil",
"\n",
"default",
":",
"}",
"\n\n",
"feed",
".",
"closeNodeFeeds",
"(",
")",
"\n",
"close",
"(",
"feed",
".",
"quit",
")",
"\n",
"feed",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"feed",
".",
"output",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close a Tap feed. | [
"Close",
"a",
"Tap",
"feed",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/tap.go#L131-L143 | train |
couchbase/go-couchbase | util/viewmgmt.go | UpdateView | func UpdateView(d *couchbase.Bucket,
ddocName, markerKey, ddocBody string, version int) error {
marker := ViewMarker{}
err := d.Get(markerKey, &marker)
if err != nil {
log.Printf("Error checking view version: %v", err)
}
if marker.Version < version {
log.Printf("Installing new version of views (old version=%v)",
marker.Version)
doc := json.RawMessage([]byte(ddocBody))
err = d.PutDDoc(ddocName, &doc)
if err != nil {
return err
}
marker.Version = version
marker.Timestamp = time.Now().UTC()
marker.Type = "viewmarker"
return d.Set(markerKey, 0, &marker)
}
return nil
} | go | func UpdateView(d *couchbase.Bucket,
ddocName, markerKey, ddocBody string, version int) error {
marker := ViewMarker{}
err := d.Get(markerKey, &marker)
if err != nil {
log.Printf("Error checking view version: %v", err)
}
if marker.Version < version {
log.Printf("Installing new version of views (old version=%v)",
marker.Version)
doc := json.RawMessage([]byte(ddocBody))
err = d.PutDDoc(ddocName, &doc)
if err != nil {
return err
}
marker.Version = version
marker.Timestamp = time.Now().UTC()
marker.Type = "viewmarker"
return d.Set(markerKey, 0, &marker)
}
return nil
} | [
"func",
"UpdateView",
"(",
"d",
"*",
"couchbase",
".",
"Bucket",
",",
"ddocName",
",",
"markerKey",
",",
"ddocBody",
"string",
",",
"version",
"int",
")",
"error",
"{",
"marker",
":=",
"ViewMarker",
"{",
"}",
"\n",
"err",
":=",
"d",
".",
"Get",
"(",
"markerKey",
",",
"&",
"marker",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"marker",
".",
"Version",
"<",
"version",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"marker",
".",
"Version",
")",
"\n",
"doc",
":=",
"json",
".",
"RawMessage",
"(",
"[",
"]",
"byte",
"(",
"ddocBody",
")",
")",
"\n",
"err",
"=",
"d",
".",
"PutDDoc",
"(",
"ddocName",
",",
"&",
"doc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"marker",
".",
"Version",
"=",
"version",
"\n",
"marker",
".",
"Timestamp",
"=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"marker",
".",
"Type",
"=",
"\"",
"\"",
"\n\n",
"return",
"d",
".",
"Set",
"(",
"markerKey",
",",
"0",
",",
"&",
"marker",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpdateView installs or updates a view.
//
// This creates a document that tracks the version of design document
// in couchbase and updates it if it's behind the version specified.
//
// A ViewMarker is stored with a type of "viewmarker" under the key
// specified by `markerKey` to keep up with the view info. | [
"UpdateView",
"installs",
"or",
"updates",
"a",
"view",
".",
"This",
"creates",
"a",
"document",
"that",
"tracks",
"the",
"version",
"of",
"design",
"document",
"in",
"couchbase",
"and",
"updates",
"it",
"if",
"it",
"s",
"behind",
"the",
"version",
"specified",
".",
"A",
"ViewMarker",
"is",
"stored",
"with",
"a",
"type",
"of",
"viewmarker",
"under",
"the",
"key",
"specified",
"by",
"markerKey",
"to",
"keep",
"up",
"with",
"the",
"view",
"info",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/util/viewmgmt.go#L28-L51 | train |
couchbase/go-couchbase | views.go | ViewURL | func (b *Bucket) ViewURL(ddoc, name string,
params map[string]interface{}) (string, error) {
u, err := b.randomBaseURL()
if err != nil {
return "", err
}
values := url.Values{}
for k, v := range params {
switch t := v.(type) {
case DocID:
values[k] = []string{string(t)}
case string:
values[k] = []string{qParam(k, t)}
case int:
values[k] = []string{fmt.Sprintf(`%d`, t)}
case bool:
values[k] = []string{fmt.Sprintf(`%v`, t)}
default:
b, err := json.Marshal(v)
if err != nil {
return "", fmt.Errorf("unsupported value-type %T in Query, "+
"json encoder said %v", t, err)
}
values[k] = []string{fmt.Sprintf(`%v`, string(b))}
}
}
if ddoc == "" && name == "_all_docs" {
u.Path = fmt.Sprintf("/%s/_all_docs", b.GetName())
} else {
u.Path = fmt.Sprintf("/%s/_design/%s/_view/%s", b.GetName(), ddoc, name)
}
u.RawQuery = values.Encode()
return u.String(), nil
} | go | func (b *Bucket) ViewURL(ddoc, name string,
params map[string]interface{}) (string, error) {
u, err := b.randomBaseURL()
if err != nil {
return "", err
}
values := url.Values{}
for k, v := range params {
switch t := v.(type) {
case DocID:
values[k] = []string{string(t)}
case string:
values[k] = []string{qParam(k, t)}
case int:
values[k] = []string{fmt.Sprintf(`%d`, t)}
case bool:
values[k] = []string{fmt.Sprintf(`%v`, t)}
default:
b, err := json.Marshal(v)
if err != nil {
return "", fmt.Errorf("unsupported value-type %T in Query, "+
"json encoder said %v", t, err)
}
values[k] = []string{fmt.Sprintf(`%v`, string(b))}
}
}
if ddoc == "" && name == "_all_docs" {
u.Path = fmt.Sprintf("/%s/_all_docs", b.GetName())
} else {
u.Path = fmt.Sprintf("/%s/_design/%s/_view/%s", b.GetName(), ddoc, name)
}
u.RawQuery = values.Encode()
return u.String(), nil
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"ViewURL",
"(",
"ddoc",
",",
"name",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"string",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"b",
".",
"randomBaseURL",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"values",
":=",
"url",
".",
"Values",
"{",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"params",
"{",
"switch",
"t",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"DocID",
":",
"values",
"[",
"k",
"]",
"=",
"[",
"]",
"string",
"{",
"string",
"(",
"t",
")",
"}",
"\n",
"case",
"string",
":",
"values",
"[",
"k",
"]",
"=",
"[",
"]",
"string",
"{",
"qParam",
"(",
"k",
",",
"t",
")",
"}",
"\n",
"case",
"int",
":",
"values",
"[",
"k",
"]",
"=",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"`%d`",
",",
"t",
")",
"}",
"\n",
"case",
"bool",
":",
"values",
"[",
"k",
"]",
"=",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"`%v`",
",",
"t",
")",
"}",
"\n",
"default",
":",
"b",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"t",
",",
"err",
")",
"\n",
"}",
"\n",
"values",
"[",
"k",
"]",
"=",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"`%v`",
",",
"string",
"(",
"b",
")",
")",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"ddoc",
"==",
"\"",
"\"",
"&&",
"name",
"==",
"\"",
"\"",
"{",
"u",
".",
"Path",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"u",
".",
"Path",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
".",
"GetName",
"(",
")",
",",
"ddoc",
",",
"name",
")",
"\n",
"}",
"\n",
"u",
".",
"RawQuery",
"=",
"values",
".",
"Encode",
"(",
")",
"\n\n",
"return",
"u",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] | // ViewURL constructs a URL for a view with the given ddoc, view name,
// and parameters. | [
"ViewURL",
"constructs",
"a",
"URL",
"for",
"a",
"view",
"with",
"the",
"given",
"ddoc",
"view",
"name",
"and",
"parameters",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/views.go#L114-L150 | train |
couchbase/go-couchbase | views.go | ViewCustom | func (b *Bucket) ViewCustom(ddoc, name string, params map[string]interface{},
vres interface{}) (err error) {
if SlowServerCallWarningThreshold > 0 {
defer slowLog(time.Now(), "call to ViewCustom(%q, %q)", ddoc, name)
}
if ViewCallback != nil {
defer func(t time.Time) { ViewCallback(ddoc, name, t, err) }(time.Now())
}
u, err := b.ViewURL(ddoc, name, params)
if err != nil {
return err
}
req, err := http.NewRequest("GET", u, nil)
if err != nil {
return err
}
ah := b.authHandler(false /* bucket not yet locked */)
maybeAddAuth(req, ah)
res, err := doHTTPRequest(req)
if err != nil {
return fmt.Errorf("error starting view req at %v: %v", u, err)
}
defer res.Body.Close()
if res.StatusCode != 200 {
bod := make([]byte, 512)
l, _ := res.Body.Read(bod)
return fmt.Errorf("error executing view req at %v: %v - %s",
u, res.Status, bod[:l])
}
body, err := ioutil.ReadAll(res.Body)
if err := json.Unmarshal(body, vres); err != nil {
return nil
}
return nil
} | go | func (b *Bucket) ViewCustom(ddoc, name string, params map[string]interface{},
vres interface{}) (err error) {
if SlowServerCallWarningThreshold > 0 {
defer slowLog(time.Now(), "call to ViewCustom(%q, %q)", ddoc, name)
}
if ViewCallback != nil {
defer func(t time.Time) { ViewCallback(ddoc, name, t, err) }(time.Now())
}
u, err := b.ViewURL(ddoc, name, params)
if err != nil {
return err
}
req, err := http.NewRequest("GET", u, nil)
if err != nil {
return err
}
ah := b.authHandler(false /* bucket not yet locked */)
maybeAddAuth(req, ah)
res, err := doHTTPRequest(req)
if err != nil {
return fmt.Errorf("error starting view req at %v: %v", u, err)
}
defer res.Body.Close()
if res.StatusCode != 200 {
bod := make([]byte, 512)
l, _ := res.Body.Read(bod)
return fmt.Errorf("error executing view req at %v: %v - %s",
u, res.Status, bod[:l])
}
body, err := ioutil.ReadAll(res.Body)
if err := json.Unmarshal(body, vres); err != nil {
return nil
}
return nil
} | [
"func",
"(",
"b",
"*",
"Bucket",
")",
"ViewCustom",
"(",
"ddoc",
",",
"name",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"vres",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"if",
"SlowServerCallWarningThreshold",
">",
"0",
"{",
"defer",
"slowLog",
"(",
"time",
".",
"Now",
"(",
")",
",",
"\"",
"\"",
",",
"ddoc",
",",
"name",
")",
"\n",
"}",
"\n\n",
"if",
"ViewCallback",
"!=",
"nil",
"{",
"defer",
"func",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"ViewCallback",
"(",
"ddoc",
",",
"name",
",",
"t",
",",
"err",
")",
"}",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n\n",
"u",
",",
"err",
":=",
"b",
".",
"ViewURL",
"(",
"ddoc",
",",
"name",
",",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"u",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"ah",
":=",
"b",
".",
"authHandler",
"(",
"false",
"/* bucket not yet locked */",
")",
"\n",
"maybeAddAuth",
"(",
"req",
",",
"ah",
")",
"\n\n",
"res",
",",
"err",
":=",
"doHTTPRequest",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"u",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"res",
".",
"StatusCode",
"!=",
"200",
"{",
"bod",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"512",
")",
"\n",
"l",
",",
"_",
":=",
"res",
".",
"Body",
".",
"Read",
"(",
"bod",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"u",
",",
"res",
".",
"Status",
",",
"bod",
"[",
":",
"l",
"]",
")",
"\n",
"}",
"\n\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"res",
".",
"Body",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"vres",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ViewCustom performs a view request that can map row values to a
// custom type.
//
// See the source to View for an example usage. | [
"ViewCustom",
"performs",
"a",
"view",
"request",
"that",
"can",
"map",
"row",
"values",
"to",
"a",
"custom",
"type",
".",
"See",
"the",
"source",
"to",
"View",
"for",
"an",
"example",
"usage",
"."
] | 6aeabeae85e5645306382779e3ee55a330ec558c | https://github.com/couchbase/go-couchbase/blob/6aeabeae85e5645306382779e3ee55a330ec558c/views.go#L159-L201 | train |
gogs/go-gogs-client | repo.go | ListMyRepos | func (c *Client) ListMyRepos() ([]*Repository, error) {
repos := make([]*Repository, 0, 10)
return repos, c.getParsedResponse("GET", "/user/repos", nil, nil, &repos)
} | go | func (c *Client) ListMyRepos() ([]*Repository, error) {
repos := make([]*Repository, 0, 10)
return repos, c.getParsedResponse("GET", "/user/repos", nil, nil, &repos)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListMyRepos",
"(",
")",
"(",
"[",
"]",
"*",
"Repository",
",",
"error",
")",
"{",
"repos",
":=",
"make",
"(",
"[",
"]",
"*",
"Repository",
",",
"0",
",",
"10",
")",
"\n",
"return",
"repos",
",",
"c",
".",
"getParsedResponse",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
",",
"nil",
",",
"&",
"repos",
")",
"\n",
"}"
] | // ListMyRepos lists all repositories for the authenticated user that has access to. | [
"ListMyRepos",
"lists",
"all",
"repositories",
"for",
"the",
"authenticated",
"user",
"that",
"has",
"access",
"to",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo.go#L49-L52 | train |
gogs/go-gogs-client | repo.go | CreateRepo | func (c *Client) CreateRepo(opt CreateRepoOption) (*Repository, error) {
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
}
repo := new(Repository)
return repo, c.getParsedResponse("POST", "/user/repos", jsonHeader, bytes.NewReader(body), repo)
} | go | func (c *Client) CreateRepo(opt CreateRepoOption) (*Repository, error) {
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
}
repo := new(Repository)
return repo, c.getParsedResponse("POST", "/user/repos", jsonHeader, bytes.NewReader(body), repo)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateRepo",
"(",
"opt",
"CreateRepoOption",
")",
"(",
"*",
"Repository",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"opt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"repo",
":=",
"new",
"(",
"Repository",
")",
"\n",
"return",
"repo",
",",
"c",
".",
"getParsedResponse",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"jsonHeader",
",",
"bytes",
".",
"NewReader",
"(",
"body",
")",
",",
"repo",
")",
"\n",
"}"
] | // CreateRepo creates a repository for authenticated user. | [
"CreateRepo",
"creates",
"a",
"repository",
"for",
"authenticated",
"user",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo.go#L75-L82 | train |
gogs/go-gogs-client | repo.go | CreateOrgRepo | func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, error) {
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
}
repo := new(Repository)
return repo, c.getParsedResponse("POST", fmt.Sprintf("/org/%s/repos", org), jsonHeader, bytes.NewReader(body), repo)
} | go | func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, error) {
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
}
repo := new(Repository)
return repo, c.getParsedResponse("POST", fmt.Sprintf("/org/%s/repos", org), jsonHeader, bytes.NewReader(body), repo)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateOrgRepo",
"(",
"org",
"string",
",",
"opt",
"CreateRepoOption",
")",
"(",
"*",
"Repository",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"opt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"repo",
":=",
"new",
"(",
"Repository",
")",
"\n",
"return",
"repo",
",",
"c",
".",
"getParsedResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"org",
")",
",",
"jsonHeader",
",",
"bytes",
".",
"NewReader",
"(",
"body",
")",
",",
"repo",
")",
"\n",
"}"
] | // CreateOrgRepo creates an organization repository for authenticated user. | [
"CreateOrgRepo",
"creates",
"an",
"organization",
"repository",
"for",
"authenticated",
"user",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo.go#L85-L92 | train |
gogs/go-gogs-client | repo.go | GetRepo | func (c *Client) GetRepo(owner, reponame string) (*Repository, error) {
repo := new(Repository)
return repo, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
} | go | func (c *Client) GetRepo(owner, reponame string) (*Repository, error) {
repo := new(Repository)
return repo, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetRepo",
"(",
"owner",
",",
"reponame",
"string",
")",
"(",
"*",
"Repository",
",",
"error",
")",
"{",
"repo",
":=",
"new",
"(",
"Repository",
")",
"\n",
"return",
"repo",
",",
"c",
".",
"getParsedResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"owner",
",",
"reponame",
")",
",",
"nil",
",",
"nil",
",",
"repo",
")",
"\n",
"}"
] | // GetRepo returns information of a repository of given owner. | [
"GetRepo",
"returns",
"information",
"of",
"a",
"repository",
"of",
"given",
"owner",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo.go#L95-L98 | train |
gogs/go-gogs-client | repo.go | DeleteRepo | func (c *Client) DeleteRepo(owner, repo string) error {
_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
return err
} | go | func (c *Client) DeleteRepo(owner, repo string) error {
_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteRepo",
"(",
"owner",
",",
"repo",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"getResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"owner",
",",
"repo",
")",
",",
"nil",
",",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteRepo deletes a repository of user or organization. | [
"DeleteRepo",
"deletes",
"a",
"repository",
"of",
"user",
"or",
"organization",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo.go#L101-L104 | train |
gogs/go-gogs-client | repo.go | EditIssueTracker | func (c *Client) EditIssueTracker(owner, repo string, opt EditIssueTrackerOption) error {
body, err := json.Marshal(&opt)
if err != nil {
return err
}
_, err = c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issue-tracker", owner, repo), jsonHeader, bytes.NewReader(body))
return err
} | go | func (c *Client) EditIssueTracker(owner, repo string, opt EditIssueTrackerOption) error {
body, err := json.Marshal(&opt)
if err != nil {
return err
}
_, err = c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issue-tracker", owner, repo), jsonHeader, bytes.NewReader(body))
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"EditIssueTracker",
"(",
"owner",
",",
"repo",
"string",
",",
"opt",
"EditIssueTrackerOption",
")",
"error",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"opt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"getResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"owner",
",",
"repo",
")",
",",
"jsonHeader",
",",
"bytes",
".",
"NewReader",
"(",
"body",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // EditIssueTracker updates issue tracker options of the repository. | [
"EditIssueTracker",
"updates",
"issue",
"tracker",
"options",
"of",
"the",
"repository",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo.go#L140-L147 | train |
gogs/go-gogs-client | issue_comment.go | ListIssueComments | func (c *Client) ListIssueComments(owner, repo string, index int64) ([]*Comment, error) {
comments := make([]*Comment, 0, 10)
return comments, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), nil, nil, &comments)
} | go | func (c *Client) ListIssueComments(owner, repo string, index int64) ([]*Comment, error) {
comments := make([]*Comment, 0, 10)
return comments, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), nil, nil, &comments)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListIssueComments",
"(",
"owner",
",",
"repo",
"string",
",",
"index",
"int64",
")",
"(",
"[",
"]",
"*",
"Comment",
",",
"error",
")",
"{",
"comments",
":=",
"make",
"(",
"[",
"]",
"*",
"Comment",
",",
"0",
",",
"10",
")",
"\n",
"return",
"comments",
",",
"c",
".",
"getParsedResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"owner",
",",
"repo",
",",
"index",
")",
",",
"nil",
",",
"nil",
",",
"&",
"comments",
")",
"\n",
"}"
] | // ListIssueComments list comments on an issue. | [
"ListIssueComments",
"list",
"comments",
"on",
"an",
"issue",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/issue_comment.go#L25-L28 | train |
gogs/go-gogs-client | issue_comment.go | ListRepoIssueComments | func (c *Client) ListRepoIssueComments(owner, repo string) ([]*Comment, error) {
comments := make([]*Comment, 0, 10)
return comments, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments", owner, repo), nil, nil, &comments)
} | go | func (c *Client) ListRepoIssueComments(owner, repo string) ([]*Comment, error) {
comments := make([]*Comment, 0, 10)
return comments, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments", owner, repo), nil, nil, &comments)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ListRepoIssueComments",
"(",
"owner",
",",
"repo",
"string",
")",
"(",
"[",
"]",
"*",
"Comment",
",",
"error",
")",
"{",
"comments",
":=",
"make",
"(",
"[",
"]",
"*",
"Comment",
",",
"0",
",",
"10",
")",
"\n",
"return",
"comments",
",",
"c",
".",
"getParsedResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"owner",
",",
"repo",
")",
",",
"nil",
",",
"nil",
",",
"&",
"comments",
")",
"\n",
"}"
] | // ListRepoIssueComments list comments for a given repo. | [
"ListRepoIssueComments",
"list",
"comments",
"for",
"a",
"given",
"repo",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/issue_comment.go#L31-L34 | train |
gogs/go-gogs-client | issue_comment.go | CreateIssueComment | func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, error) {
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
}
comment := new(Comment)
return comment, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), jsonHeader, bytes.NewReader(body), comment)
} | go | func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, error) {
body, err := json.Marshal(&opt)
if err != nil {
return nil, err
}
comment := new(Comment)
return comment, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), jsonHeader, bytes.NewReader(body), comment)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateIssueComment",
"(",
"owner",
",",
"repo",
"string",
",",
"index",
"int64",
",",
"opt",
"CreateIssueCommentOption",
")",
"(",
"*",
"Comment",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"opt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"comment",
":=",
"new",
"(",
"Comment",
")",
"\n",
"return",
"comment",
",",
"c",
".",
"getParsedResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"owner",
",",
"repo",
",",
"index",
")",
",",
"jsonHeader",
",",
"bytes",
".",
"NewReader",
"(",
"body",
")",
",",
"comment",
")",
"\n",
"}"
] | // CreateIssueComment create comment on an issue. | [
"CreateIssueComment",
"create",
"comment",
"on",
"an",
"issue",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/issue_comment.go#L42-L49 | train |
gogs/go-gogs-client | issue_comment.go | DeleteIssueComment | func (c *Client) DeleteIssueComment(owner, repo string, index, commentID int64) error {
_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/comments/%d", owner, repo, index, commentID), nil, nil)
return err
} | go | func (c *Client) DeleteIssueComment(owner, repo string, index, commentID int64) error {
_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/comments/%d", owner, repo, index, commentID), nil, nil)
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteIssueComment",
"(",
"owner",
",",
"repo",
"string",
",",
"index",
",",
"commentID",
"int64",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"getResponse",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"owner",
",",
"repo",
",",
"index",
",",
"commentID",
")",
",",
"nil",
",",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteIssueComment deletes an issue comment. | [
"DeleteIssueComment",
"deletes",
"an",
"issue",
"comment",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/issue_comment.go#L67-L70 | train |
gogs/go-gogs-client | repo_hook.go | ParseCreateHook | func ParseCreateHook(raw []byte) (*CreatePayload, error) {
hook := new(CreatePayload)
if err := json.Unmarshal(raw, hook); err != nil {
return nil, err
}
// it is possible the JSON was parsed, however,
// was not from Gogs (maybe was from Bitbucket)
// So we'll check to be sure certain key fields
// were populated
switch {
case hook.Repo == nil:
return nil, ErrInvalidReceiveHook
case len(hook.Ref) == 0:
return nil, ErrInvalidReceiveHook
}
return hook, nil
} | go | func ParseCreateHook(raw []byte) (*CreatePayload, error) {
hook := new(CreatePayload)
if err := json.Unmarshal(raw, hook); err != nil {
return nil, err
}
// it is possible the JSON was parsed, however,
// was not from Gogs (maybe was from Bitbucket)
// So we'll check to be sure certain key fields
// were populated
switch {
case hook.Repo == nil:
return nil, ErrInvalidReceiveHook
case len(hook.Ref) == 0:
return nil, ErrInvalidReceiveHook
}
return hook, nil
} | [
"func",
"ParseCreateHook",
"(",
"raw",
"[",
"]",
"byte",
")",
"(",
"*",
"CreatePayload",
",",
"error",
")",
"{",
"hook",
":=",
"new",
"(",
"CreatePayload",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"raw",
",",
"hook",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// it is possible the JSON was parsed, however,",
"// was not from Gogs (maybe was from Bitbucket)",
"// So we'll check to be sure certain key fields",
"// were populated",
"switch",
"{",
"case",
"hook",
".",
"Repo",
"==",
"nil",
":",
"return",
"nil",
",",
"ErrInvalidReceiveHook",
"\n",
"case",
"len",
"(",
"hook",
".",
"Ref",
")",
"==",
"0",
":",
"return",
"nil",
",",
"ErrInvalidReceiveHook",
"\n",
"}",
"\n",
"return",
"hook",
",",
"nil",
"\n",
"}"
] | // ParseCreateHook parses create event hook content. | [
"ParseCreateHook",
"parses",
"create",
"event",
"hook",
"content",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo_hook.go#L127-L144 | train |
gogs/go-gogs-client | repo_hook.go | ParsePushHook | func ParsePushHook(raw []byte) (*PushPayload, error) {
hook := new(PushPayload)
if err := json.Unmarshal(raw, hook); err != nil {
return nil, err
}
switch {
case hook.Repo == nil:
return nil, ErrInvalidReceiveHook
case len(hook.Ref) == 0:
return nil, ErrInvalidReceiveHook
}
return hook, nil
} | go | func ParsePushHook(raw []byte) (*PushPayload, error) {
hook := new(PushPayload)
if err := json.Unmarshal(raw, hook); err != nil {
return nil, err
}
switch {
case hook.Repo == nil:
return nil, ErrInvalidReceiveHook
case len(hook.Ref) == 0:
return nil, ErrInvalidReceiveHook
}
return hook, nil
} | [
"func",
"ParsePushHook",
"(",
"raw",
"[",
"]",
"byte",
")",
"(",
"*",
"PushPayload",
",",
"error",
")",
"{",
"hook",
":=",
"new",
"(",
"PushPayload",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"raw",
",",
"hook",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"{",
"case",
"hook",
".",
"Repo",
"==",
"nil",
":",
"return",
"nil",
",",
"ErrInvalidReceiveHook",
"\n",
"case",
"len",
"(",
"hook",
".",
"Ref",
")",
"==",
"0",
":",
"return",
"nil",
",",
"ErrInvalidReceiveHook",
"\n",
"}",
"\n",
"return",
"hook",
",",
"nil",
"\n",
"}"
] | // ParsePushHook parses push event hook content. | [
"ParsePushHook",
"parses",
"push",
"event",
"hook",
"content",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/repo_hook.go#L212-L225 | train |
gogs/go-gogs-client | gogs.go | NewClient | func NewClient(url, token string) *Client {
return &Client{
url: strings.TrimSuffix(url, "/"),
accessToken: token,
client: &http.Client{},
}
} | go | func NewClient(url, token string) *Client {
return &Client{
url: strings.TrimSuffix(url, "/"),
accessToken: token,
client: &http.Client{},
}
} | [
"func",
"NewClient",
"(",
"url",
",",
"token",
"string",
")",
"*",
"Client",
"{",
"return",
"&",
"Client",
"{",
"url",
":",
"strings",
".",
"TrimSuffix",
"(",
"url",
",",
"\"",
"\"",
")",
",",
"accessToken",
":",
"token",
",",
"client",
":",
"&",
"http",
".",
"Client",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewClient initializes and returns an API client. | [
"NewClient",
"initializes",
"and",
"returns",
"an",
"API",
"client",
"."
] | 1cd0db3113de87dbac702b9f1a08d9bd0e7142bb | https://github.com/gogs/go-gogs-client/blob/1cd0db3113de87dbac702b9f1a08d9bd0e7142bb/gogs.go#L28-L34 | train |
iron-io/functions | api/models/app.go | UpdateConfig | func (a *App) UpdateConfig(patch Config) {
if patch != nil {
if a.Config == nil {
a.Config = make(Config)
}
for k, v := range patch {
if v == "" {
delete(a.Config, k)
} else {
a.Config[k] = v
}
}
}
} | go | func (a *App) UpdateConfig(patch Config) {
if patch != nil {
if a.Config == nil {
a.Config = make(Config)
}
for k, v := range patch {
if v == "" {
delete(a.Config, k)
} else {
a.Config[k] = v
}
}
}
} | [
"func",
"(",
"a",
"*",
"App",
")",
"UpdateConfig",
"(",
"patch",
"Config",
")",
"{",
"if",
"patch",
"!=",
"nil",
"{",
"if",
"a",
".",
"Config",
"==",
"nil",
"{",
"a",
".",
"Config",
"=",
"make",
"(",
"Config",
")",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"patch",
"{",
"if",
"v",
"==",
"\"",
"\"",
"{",
"delete",
"(",
"a",
".",
"Config",
",",
"k",
")",
"\n",
"}",
"else",
"{",
"a",
".",
"Config",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // UpdateConfig adds entries from patch to a.Config, and removes entries with empty values. | [
"UpdateConfig",
"adds",
"entries",
"from",
"patch",
"to",
"a",
".",
"Config",
"and",
"removes",
"entries",
"with",
"empty",
"values",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/models/app.go#L74-L87 | train |
iron-io/functions | api/server/singleflight.go | do | func (g *singleflight) do(key models.RouteFilter, fn func() (interface{}, error)) (interface{}, error) {
g.mu.Lock()
if g.m == nil {
g.m = make(map[models.RouteFilter]*call)
}
if c, ok := g.m[key]; ok {
g.mu.Unlock()
c.wg.Wait()
return c.val, c.err
}
c := new(call)
c.wg.Add(1)
g.m[key] = c
g.mu.Unlock()
c.val, c.err = fn()
c.wg.Done()
g.mu.Lock()
delete(g.m, key)
g.mu.Unlock()
return c.val, c.err
} | go | func (g *singleflight) do(key models.RouteFilter, fn func() (interface{}, error)) (interface{}, error) {
g.mu.Lock()
if g.m == nil {
g.m = make(map[models.RouteFilter]*call)
}
if c, ok := g.m[key]; ok {
g.mu.Unlock()
c.wg.Wait()
return c.val, c.err
}
c := new(call)
c.wg.Add(1)
g.m[key] = c
g.mu.Unlock()
c.val, c.err = fn()
c.wg.Done()
g.mu.Lock()
delete(g.m, key)
g.mu.Unlock()
return c.val, c.err
} | [
"func",
"(",
"g",
"*",
"singleflight",
")",
"do",
"(",
"key",
"models",
".",
"RouteFilter",
",",
"fn",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"g",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"g",
".",
"m",
"==",
"nil",
"{",
"g",
".",
"m",
"=",
"make",
"(",
"map",
"[",
"models",
".",
"RouteFilter",
"]",
"*",
"call",
")",
"\n",
"}",
"\n",
"if",
"c",
",",
"ok",
":=",
"g",
".",
"m",
"[",
"key",
"]",
";",
"ok",
"{",
"g",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"return",
"c",
".",
"val",
",",
"c",
".",
"err",
"\n",
"}",
"\n",
"c",
":=",
"new",
"(",
"call",
")",
"\n",
"c",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"g",
".",
"m",
"[",
"key",
"]",
"=",
"c",
"\n",
"g",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
".",
"val",
",",
"c",
".",
"err",
"=",
"fn",
"(",
")",
"\n",
"c",
".",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"g",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"g",
".",
"m",
",",
"key",
")",
"\n",
"g",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"val",
",",
"c",
".",
"err",
"\n",
"}"
] | // do executes and returns the results of the given function, making
// sure that only one execution is in-flight for a given key at a
// time. If a duplicate comes in, the duplicate caller waits for the
// original to complete and receives the same results. | [
"do",
"executes",
"and",
"returns",
"the",
"results",
"of",
"the",
"given",
"function",
"making",
"sure",
"that",
"only",
"one",
"execution",
"is",
"in",
"-",
"flight",
"for",
"a",
"given",
"key",
"at",
"a",
"time",
".",
"If",
"a",
"duplicate",
"comes",
"in",
"the",
"duplicate",
"caller",
"waits",
"for",
"the",
"original",
"to",
"complete",
"and",
"receives",
"the",
"same",
"results",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/singleflight.go#L27-L50 | train |
iron-io/functions | lb/roundtripper.go | NewRoundTripper | func NewRoundTripper(ctx context.Context, nodes []string) *FallbackRoundTripper {
frt := &FallbackRoundTripper{
nodes: nodes,
fallback: make(map[string]string),
}
go frt.checkHealth(ctx)
return frt
} | go | func NewRoundTripper(ctx context.Context, nodes []string) *FallbackRoundTripper {
frt := &FallbackRoundTripper{
nodes: nodes,
fallback: make(map[string]string),
}
go frt.checkHealth(ctx)
return frt
} | [
"func",
"NewRoundTripper",
"(",
"ctx",
"context",
".",
"Context",
",",
"nodes",
"[",
"]",
"string",
")",
"*",
"FallbackRoundTripper",
"{",
"frt",
":=",
"&",
"FallbackRoundTripper",
"{",
"nodes",
":",
"nodes",
",",
"fallback",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
"\n",
"go",
"frt",
".",
"checkHealth",
"(",
"ctx",
")",
"\n",
"return",
"frt",
"\n",
"}"
] | // NewRoundTripper creates a new FallbackRoundTripper and triggers the internal
// host TCP health checks. | [
"NewRoundTripper",
"creates",
"a",
"new",
"FallbackRoundTripper",
"and",
"triggers",
"the",
"internal",
"host",
"TCP",
"health",
"checks",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/lb/roundtripper.go#L36-L43 | train |
iron-io/functions | api/models/new_task.go | Validate | func (m *NewTask) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateImage(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validatePriority(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *NewTask) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateImage(formats); err != nil {
// prop
res = append(res, err)
}
if err := m.validatePriority(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"NewTask",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateImage",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"// prop",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validatePriority",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"// prop",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this new task | [
"Validate",
"validates",
"this",
"new",
"task"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/models/new_task.go#L65-L82 | train |
iron-io/functions | fn/commands/images/build.go | Build | func (b *Buildcmd) Build(c *cli.Context) error {
verbwriter := common.Verbwriter(b.Verbose)
path, err := os.Getwd()
if err != nil {
return err
}
fn, err := common.FindFuncfile(path)
if err != nil {
return err
}
fmt.Fprintln(verbwriter, "building", fn)
ff, err := common.Buildfunc(verbwriter, fn)
if err != nil {
return err
}
fmt.Printf("Function %v built successfully.\n", ff.FullName())
return nil
} | go | func (b *Buildcmd) Build(c *cli.Context) error {
verbwriter := common.Verbwriter(b.Verbose)
path, err := os.Getwd()
if err != nil {
return err
}
fn, err := common.FindFuncfile(path)
if err != nil {
return err
}
fmt.Fprintln(verbwriter, "building", fn)
ff, err := common.Buildfunc(verbwriter, fn)
if err != nil {
return err
}
fmt.Printf("Function %v built successfully.\n", ff.FullName())
return nil
} | [
"func",
"(",
"b",
"*",
"Buildcmd",
")",
"Build",
"(",
"c",
"*",
"cli",
".",
"Context",
")",
"error",
"{",
"verbwriter",
":=",
"common",
".",
"Verbwriter",
"(",
"b",
".",
"Verbose",
")",
"\n\n",
"path",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"fn",
",",
"err",
":=",
"common",
".",
"FindFuncfile",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"verbwriter",
",",
"\"",
"\"",
",",
"fn",
")",
"\n",
"ff",
",",
"err",
":=",
"common",
".",
"Buildfunc",
"(",
"verbwriter",
",",
"fn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"ff",
".",
"FullName",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // build will take the found valid function and build it | [
"build",
"will",
"take",
"the",
"found",
"valid",
"function",
"and",
"build",
"it"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/fn/commands/images/build.go#L37-L57 | train |
iron-io/functions | api/mqs/new.go | New | func New(mqURL string) (models.MessageQueue, error) {
// Play with URL schemes here: https://play.golang.org/p/xWAf9SpCBW
u, err := url.Parse(mqURL)
if err != nil {
logrus.WithError(err).WithFields(logrus.Fields{"url": mqURL}).Fatal("bad MQ URL")
}
logrus.WithFields(logrus.Fields{"mq": u.Scheme}).Debug("selecting MQ")
switch u.Scheme {
case "memory":
return NewMemoryMQ(), nil
case "redis":
return NewRedisMQ(u)
case "bolt":
return NewBoltMQ(u)
}
if strings.HasPrefix(u.Scheme, "ironmq") {
return NewIronMQ(u), nil
}
return nil, fmt.Errorf("mq type not supported %v", u.Scheme)
} | go | func New(mqURL string) (models.MessageQueue, error) {
// Play with URL schemes here: https://play.golang.org/p/xWAf9SpCBW
u, err := url.Parse(mqURL)
if err != nil {
logrus.WithError(err).WithFields(logrus.Fields{"url": mqURL}).Fatal("bad MQ URL")
}
logrus.WithFields(logrus.Fields{"mq": u.Scheme}).Debug("selecting MQ")
switch u.Scheme {
case "memory":
return NewMemoryMQ(), nil
case "redis":
return NewRedisMQ(u)
case "bolt":
return NewBoltMQ(u)
}
if strings.HasPrefix(u.Scheme, "ironmq") {
return NewIronMQ(u), nil
}
return nil, fmt.Errorf("mq type not supported %v", u.Scheme)
} | [
"func",
"New",
"(",
"mqURL",
"string",
")",
"(",
"models",
".",
"MessageQueue",
",",
"error",
")",
"{",
"// Play with URL schemes here: https://play.golang.org/p/xWAf9SpCBW",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"mqURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"WithError",
"(",
"err",
")",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"mqURL",
"}",
")",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"u",
".",
"Scheme",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"switch",
"u",
".",
"Scheme",
"{",
"case",
"\"",
"\"",
":",
"return",
"NewMemoryMQ",
"(",
")",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"NewRedisMQ",
"(",
"u",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"NewBoltMQ",
"(",
"u",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"u",
".",
"Scheme",
",",
"\"",
"\"",
")",
"{",
"return",
"NewIronMQ",
"(",
"u",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"u",
".",
"Scheme",
")",
"\n",
"}"
] | // New will parse the URL and return the correct MQ implementation. | [
"New",
"will",
"parse",
"the",
"URL",
"and",
"return",
"the",
"correct",
"MQ",
"implementation",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/mqs/new.go#L13-L33 | train |
iron-io/functions | api/runner/worker.go | StartWorkers | func StartWorkers(ctx context.Context, rnr *Runner, tasks <-chan task.Request) {
var wg sync.WaitGroup
defer wg.Wait()
var hcmgr htfnmgr
for {
select {
case <-ctx.Done():
return
case task := <-tasks:
p := hcmgr.getPipe(ctx, rnr, task.Config)
if p == nil {
wg.Add(1)
go runTaskReq(rnr, &wg, task)
continue
}
rnr.Start()
select {
case <-ctx.Done():
return
case p <- task:
rnr.Complete()
}
}
}
} | go | func StartWorkers(ctx context.Context, rnr *Runner, tasks <-chan task.Request) {
var wg sync.WaitGroup
defer wg.Wait()
var hcmgr htfnmgr
for {
select {
case <-ctx.Done():
return
case task := <-tasks:
p := hcmgr.getPipe(ctx, rnr, task.Config)
if p == nil {
wg.Add(1)
go runTaskReq(rnr, &wg, task)
continue
}
rnr.Start()
select {
case <-ctx.Done():
return
case p <- task:
rnr.Complete()
}
}
}
} | [
"func",
"StartWorkers",
"(",
"ctx",
"context",
".",
"Context",
",",
"rnr",
"*",
"Runner",
",",
"tasks",
"<-",
"chan",
"task",
".",
"Request",
")",
"{",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"defer",
"wg",
".",
"Wait",
"(",
")",
"\n",
"var",
"hcmgr",
"htfnmgr",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"case",
"task",
":=",
"<-",
"tasks",
":",
"p",
":=",
"hcmgr",
".",
"getPipe",
"(",
"ctx",
",",
"rnr",
",",
"task",
".",
"Config",
")",
"\n",
"if",
"p",
"==",
"nil",
"{",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"runTaskReq",
"(",
"rnr",
",",
"&",
"wg",
",",
"task",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"rnr",
".",
"Start",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"case",
"p",
"<-",
"task",
":",
"rnr",
".",
"Complete",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // StartWorkers operates the common concurrency stream, ie, it will process all
// IronFunctions tasks, either sync or async. In the process, it also dispatches
// the workload to either regular or hot functions. | [
"StartWorkers",
"operates",
"the",
"common",
"concurrency",
"stream",
"ie",
"it",
"will",
"process",
"all",
"IronFunctions",
"tasks",
"either",
"sync",
"or",
"async",
".",
"In",
"the",
"process",
"it",
"also",
"dispatches",
"the",
"workload",
"to",
"either",
"regular",
"or",
"hot",
"functions",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/runner/worker.go#L77-L103 | train |
iron-io/functions | api/server/runner_listeners.go | AddRunnerListener | func (s *Server) AddRunnerListener(listener RunnerListener) {
s.runnerListeners = append(s.runnerListeners, listener)
} | go | func (s *Server) AddRunnerListener(listener RunnerListener) {
s.runnerListeners = append(s.runnerListeners, listener)
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"AddRunnerListener",
"(",
"listener",
"RunnerListener",
")",
"{",
"s",
".",
"runnerListeners",
"=",
"append",
"(",
"s",
".",
"runnerListeners",
",",
"listener",
")",
"\n",
"}"
] | // AddRunListeners adds a listener that will be fired before and after a function run. | [
"AddRunListeners",
"adds",
"a",
"listener",
"that",
"will",
"be",
"fired",
"before",
"and",
"after",
"a",
"function",
"run",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/runner_listeners.go#L16-L18 | train |
iron-io/functions | api/runner/async_runner.go | RunAsyncRunner | func RunAsyncRunner(ctx context.Context, tasksrv string, tasks chan task.Request, rnr *Runner) {
u := tasksrvURL(tasksrv)
startAsyncRunners(ctx, u, tasks, rnr)
<-ctx.Done()
} | go | func RunAsyncRunner(ctx context.Context, tasksrv string, tasks chan task.Request, rnr *Runner) {
u := tasksrvURL(tasksrv)
startAsyncRunners(ctx, u, tasks, rnr)
<-ctx.Done()
} | [
"func",
"RunAsyncRunner",
"(",
"ctx",
"context",
".",
"Context",
",",
"tasksrv",
"string",
",",
"tasks",
"chan",
"task",
".",
"Request",
",",
"rnr",
"*",
"Runner",
")",
"{",
"u",
":=",
"tasksrvURL",
"(",
"tasksrv",
")",
"\n\n",
"startAsyncRunners",
"(",
"ctx",
",",
"u",
",",
"tasks",
",",
"rnr",
")",
"\n",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"}"
] | // RunAsyncRunner pulls tasks off a queue and processes them | [
"RunAsyncRunner",
"pulls",
"tasks",
"off",
"a",
"queue",
"and",
"processes",
"them"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/runner/async_runner.go#L92-L97 | train |
iron-io/functions | api/server/server.go | NewFromEnv | func NewFromEnv(ctx context.Context) *Server {
ds, err := datastore.New(viper.GetString(EnvDBURL))
if err != nil {
logrus.WithError(err).Fatalln("Error initializing datastore.")
}
mq, err := mqs.New(viper.GetString(EnvMQURL))
if err != nil {
logrus.WithError(err).Fatal("Error initializing message queue.")
}
apiURL := viper.GetString(EnvAPIURL)
return New(ctx, ds, mq, apiURL)
} | go | func NewFromEnv(ctx context.Context) *Server {
ds, err := datastore.New(viper.GetString(EnvDBURL))
if err != nil {
logrus.WithError(err).Fatalln("Error initializing datastore.")
}
mq, err := mqs.New(viper.GetString(EnvMQURL))
if err != nil {
logrus.WithError(err).Fatal("Error initializing message queue.")
}
apiURL := viper.GetString(EnvAPIURL)
return New(ctx, ds, mq, apiURL)
} | [
"func",
"NewFromEnv",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"Server",
"{",
"ds",
",",
"err",
":=",
"datastore",
".",
"New",
"(",
"viper",
".",
"GetString",
"(",
"EnvDBURL",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"WithError",
"(",
"err",
")",
".",
"Fatalln",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"mq",
",",
"err",
":=",
"mqs",
".",
"New",
"(",
"viper",
".",
"GetString",
"(",
"EnvMQURL",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"WithError",
"(",
"err",
")",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"apiURL",
":=",
"viper",
".",
"GetString",
"(",
"EnvAPIURL",
")",
"\n\n",
"return",
"New",
"(",
"ctx",
",",
"ds",
",",
"mq",
",",
"apiURL",
")",
"\n",
"}"
] | // NewFromEnv creates a new IronFunctions server based on env vars. | [
"NewFromEnv",
"creates",
"a",
"new",
"IronFunctions",
"server",
"based",
"on",
"env",
"vars",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/server.go#L59-L73 | train |
iron-io/functions | api/server/server.go | New | func New(ctx context.Context, ds models.Datastore, mq models.MessageQueue, apiURL string, opts ...ServerOption) *Server {
metricLogger := runner.NewMetricLogger()
funcLogger := runner.NewFuncLogger()
rnr, err := runner.New(ctx, funcLogger, metricLogger)
if err != nil {
logrus.WithError(err).Fatalln("Failed to create a runner")
return nil
}
tasks := make(chan task.Request)
s := &Server{
Runner: rnr,
Router: gin.New(),
Datastore: ds,
MQ: mq,
hotroutes: routecache.New(cacheSize),
tasks: tasks,
Enqueue: DefaultEnqueue,
apiURL: apiURL,
}
s.Router.Use(prepareMiddleware(ctx))
s.bindHandlers(ctx)
s.setupMiddlewares()
for _, opt := range opts {
opt(s)
}
return s
} | go | func New(ctx context.Context, ds models.Datastore, mq models.MessageQueue, apiURL string, opts ...ServerOption) *Server {
metricLogger := runner.NewMetricLogger()
funcLogger := runner.NewFuncLogger()
rnr, err := runner.New(ctx, funcLogger, metricLogger)
if err != nil {
logrus.WithError(err).Fatalln("Failed to create a runner")
return nil
}
tasks := make(chan task.Request)
s := &Server{
Runner: rnr,
Router: gin.New(),
Datastore: ds,
MQ: mq,
hotroutes: routecache.New(cacheSize),
tasks: tasks,
Enqueue: DefaultEnqueue,
apiURL: apiURL,
}
s.Router.Use(prepareMiddleware(ctx))
s.bindHandlers(ctx)
s.setupMiddlewares()
for _, opt := range opts {
opt(s)
}
return s
} | [
"func",
"New",
"(",
"ctx",
"context",
".",
"Context",
",",
"ds",
"models",
".",
"Datastore",
",",
"mq",
"models",
".",
"MessageQueue",
",",
"apiURL",
"string",
",",
"opts",
"...",
"ServerOption",
")",
"*",
"Server",
"{",
"metricLogger",
":=",
"runner",
".",
"NewMetricLogger",
"(",
")",
"\n",
"funcLogger",
":=",
"runner",
".",
"NewFuncLogger",
"(",
")",
"\n\n",
"rnr",
",",
"err",
":=",
"runner",
".",
"New",
"(",
"ctx",
",",
"funcLogger",
",",
"metricLogger",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"WithError",
"(",
"err",
")",
".",
"Fatalln",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"tasks",
":=",
"make",
"(",
"chan",
"task",
".",
"Request",
")",
"\n",
"s",
":=",
"&",
"Server",
"{",
"Runner",
":",
"rnr",
",",
"Router",
":",
"gin",
".",
"New",
"(",
")",
",",
"Datastore",
":",
"ds",
",",
"MQ",
":",
"mq",
",",
"hotroutes",
":",
"routecache",
".",
"New",
"(",
"cacheSize",
")",
",",
"tasks",
":",
"tasks",
",",
"Enqueue",
":",
"DefaultEnqueue",
",",
"apiURL",
":",
"apiURL",
",",
"}",
"\n\n",
"s",
".",
"Router",
".",
"Use",
"(",
"prepareMiddleware",
"(",
"ctx",
")",
")",
"\n",
"s",
".",
"bindHandlers",
"(",
"ctx",
")",
"\n",
"s",
".",
"setupMiddlewares",
"(",
")",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"s",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // New creates a new IronFunctions server with the passed in datastore, message queue and API URL | [
"New",
"creates",
"a",
"new",
"IronFunctions",
"server",
"with",
"the",
"passed",
"in",
"datastore",
"message",
"queue",
"and",
"API",
"URL"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/server.go#L76-L106 | train |
iron-io/functions | api/models/id_status.go | Validate | func (m *IDStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateStatus(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m *IDStatus) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateStatus(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"*",
"IDStatus",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"err",
":=",
"m",
".",
"validateStatus",
"(",
"formats",
")",
";",
"err",
"!=",
"nil",
"{",
"// prop",
"res",
"=",
"append",
"(",
"res",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this Id status | [
"Validate",
"validates",
"this",
"Id",
"status"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/models/id_status.go#L70-L82 | train |
iron-io/functions | api/mqs/memory.go | pickEarliestNonblocking | func pickEarliestNonblocking(channels ...chan *models.Task) *models.Task {
if len(channels) == 0 {
return nil
}
select {
case job := <-channels[0]:
return job
default:
return pickEarliestNonblocking(channels[1:]...)
}
} | go | func pickEarliestNonblocking(channels ...chan *models.Task) *models.Task {
if len(channels) == 0 {
return nil
}
select {
case job := <-channels[0]:
return job
default:
return pickEarliestNonblocking(channels[1:]...)
}
} | [
"func",
"pickEarliestNonblocking",
"(",
"channels",
"...",
"chan",
"*",
"models",
".",
"Task",
")",
"*",
"models",
".",
"Task",
"{",
"if",
"len",
"(",
"channels",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"select",
"{",
"case",
"job",
":=",
"<-",
"channels",
"[",
"0",
"]",
":",
"return",
"job",
"\n",
"default",
":",
"return",
"pickEarliestNonblocking",
"(",
"channels",
"[",
"1",
":",
"]",
"...",
")",
"\n",
"}",
"\n",
"}"
] | // This is recursive, so be careful how many channels you pass in. | [
"This",
"is",
"recursive",
"so",
"be",
"careful",
"how",
"many",
"channels",
"you",
"pass",
"in",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/mqs/memory.go#L157-L168 | train |
iron-io/functions | fn/commands/images/bump.go | bump | func (b *bumpcmd) bump(c *cli.Context) error {
verbwriter := common.Verbwriter(b.verbose)
path, err := os.Getwd()
if err != nil {
return err
}
fn, err := common.FindFuncfile(path)
if err != nil {
return err
}
fmt.Fprintln(verbwriter, "bumping version for", fn)
funcfile, err := common.ParseFuncfile(fn)
if err != nil {
return err
}
err = funcfile.Bumpversion()
if err != nil {
return err
}
if err := common.StoreFuncfile(fn, funcfile); err != nil {
return err
}
fmt.Println("Bumped to version", funcfile.Version)
return nil
} | go | func (b *bumpcmd) bump(c *cli.Context) error {
verbwriter := common.Verbwriter(b.verbose)
path, err := os.Getwd()
if err != nil {
return err
}
fn, err := common.FindFuncfile(path)
if err != nil {
return err
}
fmt.Fprintln(verbwriter, "bumping version for", fn)
funcfile, err := common.ParseFuncfile(fn)
if err != nil {
return err
}
err = funcfile.Bumpversion()
if err != nil {
return err
}
if err := common.StoreFuncfile(fn, funcfile); err != nil {
return err
}
fmt.Println("Bumped to version", funcfile.Version)
return nil
} | [
"func",
"(",
"b",
"*",
"bumpcmd",
")",
"bump",
"(",
"c",
"*",
"cli",
".",
"Context",
")",
"error",
"{",
"verbwriter",
":=",
"common",
".",
"Verbwriter",
"(",
"b",
".",
"verbose",
")",
"\n\n",
"path",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"fn",
",",
"err",
":=",
"common",
".",
"FindFuncfile",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"verbwriter",
",",
"\"",
"\"",
",",
"fn",
")",
"\n\n",
"funcfile",
",",
"err",
":=",
"common",
".",
"ParseFuncfile",
"(",
"fn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"funcfile",
".",
"Bumpversion",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"common",
".",
"StoreFuncfile",
"(",
"fn",
",",
"funcfile",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"funcfile",
".",
"Version",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // bump will take the found valid function and bump its version | [
"bump",
"will",
"take",
"the",
"found",
"valid",
"function",
"and",
"bump",
"its",
"version"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/fn/commands/images/bump.go#L40-L70 | train |
iron-io/functions | api/models/reason.go | Validate | func (m Reason) Validate(formats strfmt.Registry) error {
var res []error
// value enum
if err := m.validateReasonEnum("", "body", m); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | go | func (m Reason) Validate(formats strfmt.Registry) error {
var res []error
// value enum
if err := m.validateReasonEnum("", "body", m); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"m",
"Reason",
")",
"Validate",
"(",
"formats",
"strfmt",
".",
"Registry",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"// value enum",
"if",
"err",
":=",
"m",
".",
"validateReasonEnum",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"errors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates this reason | [
"Validate",
"validates",
"this",
"reason"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/models/reason.go#L45-L57 | train |
iron-io/functions | api/models/route.go | SetDefaults | func (r *Route) SetDefaults() {
if r.Memory == 0 {
r.Memory = 128
}
if r.Type == TypeNone {
r.Type = TypeSync
}
if r.Format == "" {
r.Format = FormatDefault
}
if r.MaxConcurrency == 0 {
r.MaxConcurrency = 1
}
if r.Headers == nil {
r.Headers = http.Header{}
}
if r.Config == nil {
r.Config = map[string]string{}
}
if r.Timeout == 0 {
r.Timeout = defaultRouteTimeout
}
//if r.IdleTimeout == 0 {
// r.IdleTimeout = htfnScaleDownTimeout
//}
} | go | func (r *Route) SetDefaults() {
if r.Memory == 0 {
r.Memory = 128
}
if r.Type == TypeNone {
r.Type = TypeSync
}
if r.Format == "" {
r.Format = FormatDefault
}
if r.MaxConcurrency == 0 {
r.MaxConcurrency = 1
}
if r.Headers == nil {
r.Headers = http.Header{}
}
if r.Config == nil {
r.Config = map[string]string{}
}
if r.Timeout == 0 {
r.Timeout = defaultRouteTimeout
}
//if r.IdleTimeout == 0 {
// r.IdleTimeout = htfnScaleDownTimeout
//}
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"SetDefaults",
"(",
")",
"{",
"if",
"r",
".",
"Memory",
"==",
"0",
"{",
"r",
".",
"Memory",
"=",
"128",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Type",
"==",
"TypeNone",
"{",
"r",
".",
"Type",
"=",
"TypeSync",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Format",
"==",
"\"",
"\"",
"{",
"r",
".",
"Format",
"=",
"FormatDefault",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"MaxConcurrency",
"==",
"0",
"{",
"r",
".",
"MaxConcurrency",
"=",
"1",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Headers",
"==",
"nil",
"{",
"r",
".",
"Headers",
"=",
"http",
".",
"Header",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Config",
"==",
"nil",
"{",
"r",
".",
"Config",
"=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Timeout",
"==",
"0",
"{",
"r",
".",
"Timeout",
"=",
"defaultRouteTimeout",
"\n",
"}",
"\n\n",
"//if r.IdleTimeout == 0 {",
"//\tr.IdleTimeout = htfnScaleDownTimeout",
"//}",
"}"
] | // SetDefaults sets zeroed field to defaults. | [
"SetDefaults",
"sets",
"zeroed",
"field",
"to",
"defaults",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/models/route.go#L65-L97 | train |
iron-io/functions | api/models/route.go | Validate | func (r *Route) Validate(skipZero bool) error {
var res []error
if !skipZero {
if r.AppName == "" {
res = append(res, ErrRoutesValidationMissingAppName)
}
if r.Image == "" {
res = append(res, ErrRoutesValidationMissingImage)
}
if r.Path == "" {
res = append(res, ErrRoutesValidationMissingPath)
}
}
if !skipZero || r.Path != "" {
u, err := url.Parse(r.Path)
if err != nil {
res = append(res, ErrRoutesValidationPathMalformed)
}
if strings.Contains(u.Path, ":") {
res = append(res, ErrRoutesValidationFoundDynamicURL)
}
if !path.IsAbs(u.Path) {
res = append(res, ErrRoutesValidationInvalidPath)
}
}
if !skipZero || r.Type != "" {
if r.Type != TypeAsync && r.Type != TypeSync {
res = append(res, ErrRoutesValidationInvalidType)
}
}
if !skipZero || r.Format != "" {
if r.Format != FormatDefault && r.Format != FormatHTTP {
res = append(res, ErrRoutesValidationInvalidFormat)
}
}
if r.MaxConcurrency < 0 {
res = append(res, ErrRoutesValidationNegativeMaxConcurrency)
}
if r.Timeout < 0 {
res = append(res, ErrRoutesValidationNegativeTimeout)
}
if r.IdleTimeout < 0 {
res = append(res, ErrRoutesValidationNegativeIdleTimeout)
}
if len(res) > 0 {
return apiErrors.CompositeValidationError(res...)
}
return nil
} | go | func (r *Route) Validate(skipZero bool) error {
var res []error
if !skipZero {
if r.AppName == "" {
res = append(res, ErrRoutesValidationMissingAppName)
}
if r.Image == "" {
res = append(res, ErrRoutesValidationMissingImage)
}
if r.Path == "" {
res = append(res, ErrRoutesValidationMissingPath)
}
}
if !skipZero || r.Path != "" {
u, err := url.Parse(r.Path)
if err != nil {
res = append(res, ErrRoutesValidationPathMalformed)
}
if strings.Contains(u.Path, ":") {
res = append(res, ErrRoutesValidationFoundDynamicURL)
}
if !path.IsAbs(u.Path) {
res = append(res, ErrRoutesValidationInvalidPath)
}
}
if !skipZero || r.Type != "" {
if r.Type != TypeAsync && r.Type != TypeSync {
res = append(res, ErrRoutesValidationInvalidType)
}
}
if !skipZero || r.Format != "" {
if r.Format != FormatDefault && r.Format != FormatHTTP {
res = append(res, ErrRoutesValidationInvalidFormat)
}
}
if r.MaxConcurrency < 0 {
res = append(res, ErrRoutesValidationNegativeMaxConcurrency)
}
if r.Timeout < 0 {
res = append(res, ErrRoutesValidationNegativeTimeout)
}
if r.IdleTimeout < 0 {
res = append(res, ErrRoutesValidationNegativeIdleTimeout)
}
if len(res) > 0 {
return apiErrors.CompositeValidationError(res...)
}
return nil
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Validate",
"(",
"skipZero",
"bool",
")",
"error",
"{",
"var",
"res",
"[",
"]",
"error",
"\n\n",
"if",
"!",
"skipZero",
"{",
"if",
"r",
".",
"AppName",
"==",
"\"",
"\"",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationMissingAppName",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Image",
"==",
"\"",
"\"",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationMissingImage",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Path",
"==",
"\"",
"\"",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationMissingPath",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"skipZero",
"||",
"r",
".",
"Path",
"!=",
"\"",
"\"",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"r",
".",
"Path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationPathMalformed",
")",
"\n",
"}",
"\n\n",
"if",
"strings",
".",
"Contains",
"(",
"u",
".",
"Path",
",",
"\"",
"\"",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationFoundDynamicURL",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"path",
".",
"IsAbs",
"(",
"u",
".",
"Path",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationInvalidPath",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"skipZero",
"||",
"r",
".",
"Type",
"!=",
"\"",
"\"",
"{",
"if",
"r",
".",
"Type",
"!=",
"TypeAsync",
"&&",
"r",
".",
"Type",
"!=",
"TypeSync",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationInvalidType",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"skipZero",
"||",
"r",
".",
"Format",
"!=",
"\"",
"\"",
"{",
"if",
"r",
".",
"Format",
"!=",
"FormatDefault",
"&&",
"r",
".",
"Format",
"!=",
"FormatHTTP",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationInvalidFormat",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"MaxConcurrency",
"<",
"0",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationNegativeMaxConcurrency",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Timeout",
"<",
"0",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationNegativeTimeout",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"IdleTimeout",
"<",
"0",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"ErrRoutesValidationNegativeIdleTimeout",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"res",
")",
">",
"0",
"{",
"return",
"apiErrors",
".",
"CompositeValidationError",
"(",
"res",
"...",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates field values, skipping zeroed fields if skipZero is true. | [
"Validate",
"validates",
"field",
"values",
"skipping",
"zeroed",
"fields",
"if",
"skipZero",
"is",
"true",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/models/route.go#L100-L161 | train |
iron-io/functions | api/models/route.go | Update | func (r *Route) Update(new *Route) {
if new.Image != "" {
r.Image = new.Image
}
if new.Memory != 0 {
r.Memory = new.Memory
}
if new.Type != "" {
r.Type = new.Type
}
if new.Timeout != 0 {
r.Timeout = new.Timeout
}
if new.IdleTimeout != 0 {
r.IdleTimeout = new.IdleTimeout
}
if new.Format != "" {
r.Format = new.Format
}
if new.MaxConcurrency != 0 {
r.MaxConcurrency = new.MaxConcurrency
}
if new.JwtKey != "" {
r.JwtKey = new.JwtKey
}
if new.Headers != nil {
if r.Headers == nil {
r.Headers = make(http.Header)
}
for k, v := range new.Headers {
if len(v) == 0 {
r.Headers.Del(k)
} else {
for _, val := range v {
r.Headers.Add(k, val)
}
}
}
}
if new.Config != nil {
if r.Config == nil {
r.Config = make(Config)
}
for k, v := range new.Config {
if v == "" {
delete(r.Config, k)
} else {
r.Config[k] = v
}
}
}
} | go | func (r *Route) Update(new *Route) {
if new.Image != "" {
r.Image = new.Image
}
if new.Memory != 0 {
r.Memory = new.Memory
}
if new.Type != "" {
r.Type = new.Type
}
if new.Timeout != 0 {
r.Timeout = new.Timeout
}
if new.IdleTimeout != 0 {
r.IdleTimeout = new.IdleTimeout
}
if new.Format != "" {
r.Format = new.Format
}
if new.MaxConcurrency != 0 {
r.MaxConcurrency = new.MaxConcurrency
}
if new.JwtKey != "" {
r.JwtKey = new.JwtKey
}
if new.Headers != nil {
if r.Headers == nil {
r.Headers = make(http.Header)
}
for k, v := range new.Headers {
if len(v) == 0 {
r.Headers.Del(k)
} else {
for _, val := range v {
r.Headers.Add(k, val)
}
}
}
}
if new.Config != nil {
if r.Config == nil {
r.Config = make(Config)
}
for k, v := range new.Config {
if v == "" {
delete(r.Config, k)
} else {
r.Config[k] = v
}
}
}
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Update",
"(",
"new",
"*",
"Route",
")",
"{",
"if",
"new",
".",
"Image",
"!=",
"\"",
"\"",
"{",
"r",
".",
"Image",
"=",
"new",
".",
"Image",
"\n",
"}",
"\n",
"if",
"new",
".",
"Memory",
"!=",
"0",
"{",
"r",
".",
"Memory",
"=",
"new",
".",
"Memory",
"\n",
"}",
"\n",
"if",
"new",
".",
"Type",
"!=",
"\"",
"\"",
"{",
"r",
".",
"Type",
"=",
"new",
".",
"Type",
"\n",
"}",
"\n",
"if",
"new",
".",
"Timeout",
"!=",
"0",
"{",
"r",
".",
"Timeout",
"=",
"new",
".",
"Timeout",
"\n",
"}",
"\n",
"if",
"new",
".",
"IdleTimeout",
"!=",
"0",
"{",
"r",
".",
"IdleTimeout",
"=",
"new",
".",
"IdleTimeout",
"\n",
"}",
"\n",
"if",
"new",
".",
"Format",
"!=",
"\"",
"\"",
"{",
"r",
".",
"Format",
"=",
"new",
".",
"Format",
"\n",
"}",
"\n",
"if",
"new",
".",
"MaxConcurrency",
"!=",
"0",
"{",
"r",
".",
"MaxConcurrency",
"=",
"new",
".",
"MaxConcurrency",
"\n",
"}",
"\n",
"if",
"new",
".",
"JwtKey",
"!=",
"\"",
"\"",
"{",
"r",
".",
"JwtKey",
"=",
"new",
".",
"JwtKey",
"\n",
"}",
"\n\n",
"if",
"new",
".",
"Headers",
"!=",
"nil",
"{",
"if",
"r",
".",
"Headers",
"==",
"nil",
"{",
"r",
".",
"Headers",
"=",
"make",
"(",
"http",
".",
"Header",
")",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"new",
".",
"Headers",
"{",
"if",
"len",
"(",
"v",
")",
"==",
"0",
"{",
"r",
".",
"Headers",
".",
"Del",
"(",
"k",
")",
"\n",
"}",
"else",
"{",
"for",
"_",
",",
"val",
":=",
"range",
"v",
"{",
"r",
".",
"Headers",
".",
"Add",
"(",
"k",
",",
"val",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"new",
".",
"Config",
"!=",
"nil",
"{",
"if",
"r",
".",
"Config",
"==",
"nil",
"{",
"r",
".",
"Config",
"=",
"make",
"(",
"Config",
")",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"new",
".",
"Config",
"{",
"if",
"v",
"==",
"\"",
"\"",
"{",
"delete",
"(",
"r",
".",
"Config",
",",
"k",
")",
"\n",
"}",
"else",
"{",
"r",
".",
"Config",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Update updates fields in r with non-zero field values from new.
// 0-length slice Header values, and empty-string Config values trigger removal of map entry. | [
"Update",
"updates",
"fields",
"in",
"r",
"with",
"non",
"-",
"zero",
"field",
"values",
"from",
"new",
".",
"0",
"-",
"length",
"slice",
"Header",
"values",
"and",
"empty",
"-",
"string",
"Config",
"values",
"trigger",
"removal",
"of",
"map",
"entry",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/models/route.go#L173-L225 | train |
iron-io/functions | api/runner/protocol/factory.go | IsStreamable | func IsStreamable(p string) (bool, error) {
proto, err := New(Protocol(p), nil, nil)
if err != nil {
return false, err
}
return proto.IsStreamable(), nil
} | go | func IsStreamable(p string) (bool, error) {
proto, err := New(Protocol(p), nil, nil)
if err != nil {
return false, err
}
return proto.IsStreamable(), nil
} | [
"func",
"IsStreamable",
"(",
"p",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"proto",
",",
"err",
":=",
"New",
"(",
"Protocol",
"(",
"p",
")",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"proto",
".",
"IsStreamable",
"(",
")",
",",
"nil",
"\n",
"}"
] | // IsStreamable says whether the given protocol can be used for streaming into
// hot functions. | [
"IsStreamable",
"says",
"whether",
"the",
"given",
"protocol",
"can",
"be",
"used",
"for",
"streaming",
"into",
"hot",
"functions",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/runner/protocol/factory.go#L47-L53 | train |
iron-io/functions | api/server/special_handler.go | UseSpecialHandlers | func (s *Server) UseSpecialHandlers(ctx context.Context, req *http.Request, resp http.ResponseWriter) (context.Context, error) {
if len(s.specialHandlers) == 0 {
return ctx, ErrNoSpecialHandlerFound
}
c := &SpecialHandlerContext{
request: req,
response: resp,
ctx: ctx,
}
for _, l := range s.specialHandlers {
err := l.Handle(c)
if err != nil {
return c.ctx, err
}
}
return c.ctx, nil
} | go | func (s *Server) UseSpecialHandlers(ctx context.Context, req *http.Request, resp http.ResponseWriter) (context.Context, error) {
if len(s.specialHandlers) == 0 {
return ctx, ErrNoSpecialHandlerFound
}
c := &SpecialHandlerContext{
request: req,
response: resp,
ctx: ctx,
}
for _, l := range s.specialHandlers {
err := l.Handle(c)
if err != nil {
return c.ctx, err
}
}
return c.ctx, nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"UseSpecialHandlers",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"http",
".",
"Request",
",",
"resp",
"http",
".",
"ResponseWriter",
")",
"(",
"context",
".",
"Context",
",",
"error",
")",
"{",
"if",
"len",
"(",
"s",
".",
"specialHandlers",
")",
"==",
"0",
"{",
"return",
"ctx",
",",
"ErrNoSpecialHandlerFound",
"\n",
"}",
"\n\n",
"c",
":=",
"&",
"SpecialHandlerContext",
"{",
"request",
":",
"req",
",",
"response",
":",
"resp",
",",
"ctx",
":",
"ctx",
",",
"}",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"s",
".",
"specialHandlers",
"{",
"err",
":=",
"l",
".",
"Handle",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"ctx",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"c",
".",
"ctx",
",",
"nil",
"\n",
"}"
] | // UseSpecialHandlers execute all special handlers | [
"UseSpecialHandlers",
"execute",
"all",
"special",
"handlers"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/special_handler.go#L57-L74 | train |
iron-io/functions | api/server/internal/routecache/lru.go | New | func New(maxentries int) *Cache {
return &Cache{
MaxEntries: maxentries,
ll: list.New(),
cache: make(map[string]*list.Element),
}
} | go | func New(maxentries int) *Cache {
return &Cache{
MaxEntries: maxentries,
ll: list.New(),
cache: make(map[string]*list.Element),
}
} | [
"func",
"New",
"(",
"maxentries",
"int",
")",
"*",
"Cache",
"{",
"return",
"&",
"Cache",
"{",
"MaxEntries",
":",
"maxentries",
",",
"ll",
":",
"list",
".",
"New",
"(",
")",
",",
"cache",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"list",
".",
"Element",
")",
",",
"}",
"\n",
"}"
] | // New returns a route cache. | [
"New",
"returns",
"a",
"route",
"cache",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/internal/routecache/lru.go#L24-L30 | train |
iron-io/functions | api/server/internal/routecache/lru.go | Refresh | func (c *Cache) Refresh(route *models.Route) {
if c.cache == nil {
return
}
if ee, ok := c.cache[route.AppName+route.Path]; ok {
c.ll.MoveToFront(ee)
ee.Value = route
return
}
ele := c.ll.PushFront(route)
c.cache[route.AppName+route.Path] = ele
if c.MaxEntries != 0 && c.ll.Len() > c.MaxEntries {
c.removeOldest()
}
} | go | func (c *Cache) Refresh(route *models.Route) {
if c.cache == nil {
return
}
if ee, ok := c.cache[route.AppName+route.Path]; ok {
c.ll.MoveToFront(ee)
ee.Value = route
return
}
ele := c.ll.PushFront(route)
c.cache[route.AppName+route.Path] = ele
if c.MaxEntries != 0 && c.ll.Len() > c.MaxEntries {
c.removeOldest()
}
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"Refresh",
"(",
"route",
"*",
"models",
".",
"Route",
")",
"{",
"if",
"c",
".",
"cache",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"ee",
",",
"ok",
":=",
"c",
".",
"cache",
"[",
"route",
".",
"AppName",
"+",
"route",
".",
"Path",
"]",
";",
"ok",
"{",
"c",
".",
"ll",
".",
"MoveToFront",
"(",
"ee",
")",
"\n",
"ee",
".",
"Value",
"=",
"route",
"\n",
"return",
"\n",
"}",
"\n\n",
"ele",
":=",
"c",
".",
"ll",
".",
"PushFront",
"(",
"route",
")",
"\n",
"c",
".",
"cache",
"[",
"route",
".",
"AppName",
"+",
"route",
".",
"Path",
"]",
"=",
"ele",
"\n",
"if",
"c",
".",
"MaxEntries",
"!=",
"0",
"&&",
"c",
".",
"ll",
".",
"Len",
"(",
")",
">",
"c",
".",
"MaxEntries",
"{",
"c",
".",
"removeOldest",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Refresh updates internal linkedlist either adding a new route to the front,
// or moving it to the front when used. It will discard seldom used routes. | [
"Refresh",
"updates",
"internal",
"linkedlist",
"either",
"adding",
"a",
"new",
"route",
"to",
"the",
"front",
"or",
"moving",
"it",
"to",
"the",
"front",
"when",
"used",
".",
"It",
"will",
"discard",
"seldom",
"used",
"routes",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/internal/routecache/lru.go#L34-L50 | train |
iron-io/functions | api/server/internal/routecache/lru.go | Get | func (c *Cache) Get(appname, path string) (route *models.Route, ok bool) {
if c.cache == nil {
return
}
if ele, hit := c.cache[appname+path]; hit {
c.ll.MoveToFront(ele)
return ele.Value.(*models.Route), true
}
return
} | go | func (c *Cache) Get(appname, path string) (route *models.Route, ok bool) {
if c.cache == nil {
return
}
if ele, hit := c.cache[appname+path]; hit {
c.ll.MoveToFront(ele)
return ele.Value.(*models.Route), true
}
return
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"Get",
"(",
"appname",
",",
"path",
"string",
")",
"(",
"route",
"*",
"models",
".",
"Route",
",",
"ok",
"bool",
")",
"{",
"if",
"c",
".",
"cache",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"ele",
",",
"hit",
":=",
"c",
".",
"cache",
"[",
"appname",
"+",
"path",
"]",
";",
"hit",
"{",
"c",
".",
"ll",
".",
"MoveToFront",
"(",
"ele",
")",
"\n",
"return",
"ele",
".",
"Value",
".",
"(",
"*",
"models",
".",
"Route",
")",
",",
"true",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Get looks up a path's route from the cache. | [
"Get",
"looks",
"up",
"a",
"path",
"s",
"route",
"from",
"the",
"cache",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/internal/routecache/lru.go#L53-L62 | train |
iron-io/functions | api/server/internal/routecache/lru.go | Delete | func (c *Cache) Delete(appname, path string) {
if ele, hit := c.cache[appname+path]; hit {
c.removeElement(ele)
}
} | go | func (c *Cache) Delete(appname, path string) {
if ele, hit := c.cache[appname+path]; hit {
c.removeElement(ele)
}
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"Delete",
"(",
"appname",
",",
"path",
"string",
")",
"{",
"if",
"ele",
",",
"hit",
":=",
"c",
".",
"cache",
"[",
"appname",
"+",
"path",
"]",
";",
"hit",
"{",
"c",
".",
"removeElement",
"(",
"ele",
")",
"\n",
"}",
"\n",
"}"
] | // Delete removes the element for the given appname and path from the cache. | [
"Delete",
"removes",
"the",
"element",
"for",
"the",
"given",
"appname",
"and",
"path",
"from",
"the",
"cache",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/internal/routecache/lru.go#L65-L69 | train |
iron-io/functions | api/server/app_listeners.go | AddAppListener | func (s *Server) AddAppListener(listener AppListener) {
s.appListeners = append(s.appListeners, listener)
} | go | func (s *Server) AddAppListener(listener AppListener) {
s.appListeners = append(s.appListeners, listener)
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"AddAppListener",
"(",
"listener",
"AppListener",
")",
"{",
"s",
".",
"appListeners",
"=",
"append",
"(",
"s",
".",
"appListeners",
",",
"listener",
")",
"\n",
"}"
] | // AddAppCreateListener adds a listener that will be notified on App created. | [
"AddAppCreateListener",
"adds",
"a",
"listener",
"that",
"will",
"be",
"notified",
"on",
"App",
"created",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/app_listeners.go#L25-L27 | train |
iron-io/functions | api/server/tree.go | findCaseInsensitivePath | func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
return n.findCaseInsensitivePathRec(
path,
strings.ToLower(path),
make([]byte, 0, len(path)+1), // preallocate enough memory for new path
[4]byte{}, // empty rune buffer
fixTrailingSlash,
)
} | go | func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
return n.findCaseInsensitivePathRec(
path,
strings.ToLower(path),
make([]byte, 0, len(path)+1), // preallocate enough memory for new path
[4]byte{}, // empty rune buffer
fixTrailingSlash,
)
} | [
"func",
"(",
"n",
"*",
"node",
")",
"findCaseInsensitivePath",
"(",
"path",
"string",
",",
"fixTrailingSlash",
"bool",
")",
"(",
"ciPath",
"[",
"]",
"byte",
",",
"found",
"bool",
")",
"{",
"return",
"n",
".",
"findCaseInsensitivePathRec",
"(",
"path",
",",
"strings",
".",
"ToLower",
"(",
"path",
")",
",",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"path",
")",
"+",
"1",
")",
",",
"// preallocate enough memory for new path",
"[",
"4",
"]",
"byte",
"{",
"}",
",",
"// empty rune buffer",
"fixTrailingSlash",
",",
")",
"\n",
"}"
] | // Makes a case-insensitive lookup of the given path and tries to find a handler.
// It can optionally also fix trailing slashes.
// It returns the case-corrected path and a bool indicating whether the lookup
// was successful. | [
"Makes",
"a",
"case",
"-",
"insensitive",
"lookup",
"of",
"the",
"given",
"path",
"and",
"tries",
"to",
"find",
"a",
"handler",
".",
"It",
"can",
"optionally",
"also",
"fix",
"trailing",
"slashes",
".",
"It",
"returns",
"the",
"case",
"-",
"corrected",
"path",
"and",
"a",
"bool",
"indicating",
"whether",
"the",
"lookup",
"was",
"successful",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/server/tree.go#L458-L466 | train |
iron-io/functions | api/mqs/bolt.go | delayTask | func (mq *BoltDbMQ) delayTask(job *models.Task) (*models.Task, error) {
readyAt := time.Now().Add(time.Duration(job.Delay) * time.Second)
err := mq.db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket(delayQueueName)
id, _ := b.NextSequence()
buf, err := json.Marshal(job)
if err != nil {
return err
}
key := msgKey(id)
err = b.Put(key, buf)
if err != nil {
return err
}
pb := make([]byte, 4)
binary.BigEndian.PutUint32(pb[:], uint32(*job.Priority))
reservation := resKey(key, readyAt)
return b.Put(reservation, pb)
})
return job, err
} | go | func (mq *BoltDbMQ) delayTask(job *models.Task) (*models.Task, error) {
readyAt := time.Now().Add(time.Duration(job.Delay) * time.Second)
err := mq.db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket(delayQueueName)
id, _ := b.NextSequence()
buf, err := json.Marshal(job)
if err != nil {
return err
}
key := msgKey(id)
err = b.Put(key, buf)
if err != nil {
return err
}
pb := make([]byte, 4)
binary.BigEndian.PutUint32(pb[:], uint32(*job.Priority))
reservation := resKey(key, readyAt)
return b.Put(reservation, pb)
})
return job, err
} | [
"func",
"(",
"mq",
"*",
"BoltDbMQ",
")",
"delayTask",
"(",
"job",
"*",
"models",
".",
"Task",
")",
"(",
"*",
"models",
".",
"Task",
",",
"error",
")",
"{",
"readyAt",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"time",
".",
"Duration",
"(",
"job",
".",
"Delay",
")",
"*",
"time",
".",
"Second",
")",
"\n",
"err",
":=",
"mq",
".",
"db",
".",
"Update",
"(",
"func",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
")",
"error",
"{",
"b",
":=",
"tx",
".",
"Bucket",
"(",
"delayQueueName",
")",
"\n",
"id",
",",
"_",
":=",
"b",
".",
"NextSequence",
"(",
")",
"\n",
"buf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"job",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"key",
":=",
"msgKey",
"(",
"id",
")",
"\n",
"err",
"=",
"b",
".",
"Put",
"(",
"key",
",",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"pb",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"pb",
"[",
":",
"]",
",",
"uint32",
"(",
"*",
"job",
".",
"Priority",
")",
")",
"\n",
"reservation",
":=",
"resKey",
"(",
"key",
",",
"readyAt",
")",
"\n",
"return",
"b",
".",
"Put",
"(",
"reservation",
",",
"pb",
")",
"\n",
"}",
")",
"\n",
"return",
"job",
",",
"err",
"\n",
"}"
] | // We insert a "reservation" at readyAt, and store the json blob at the msg
// key. The timer loop plucks this out and puts it in the jobs bucket when the
// time elapses. The value stored at the reservation key is the priority. | [
"We",
"insert",
"a",
"reservation",
"at",
"readyAt",
"and",
"store",
"the",
"json",
"blob",
"at",
"the",
"msg",
"key",
".",
"The",
"timer",
"loop",
"plucks",
"this",
"out",
"and",
"puts",
"it",
"in",
"the",
"jobs",
"bucket",
"when",
"the",
"time",
"elapses",
".",
"The",
"value",
"stored",
"at",
"the",
"reservation",
"key",
"is",
"the",
"priority",
"."
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/mqs/bolt.go#L183-L205 | train |
iron-io/functions | fn/langs/base.go | GetLangHelper | func GetLangHelper(lang string) LangHelper {
switch lang {
case "go":
return &GoLangHelper{}
case "node":
return &NodeLangHelper{}
case "ruby":
return &RubyLangHelper{}
case "python":
return &PythonHelper{}
case "rust":
return &RustLangHelper{}
case "dotnet":
return &DotNetLangHelper{}
case "java":
return &JavaLangHelper{}
case "lambda-nodejs4.3":
return &LambdaNodeHelper{}
}
return nil
} | go | func GetLangHelper(lang string) LangHelper {
switch lang {
case "go":
return &GoLangHelper{}
case "node":
return &NodeLangHelper{}
case "ruby":
return &RubyLangHelper{}
case "python":
return &PythonHelper{}
case "rust":
return &RustLangHelper{}
case "dotnet":
return &DotNetLangHelper{}
case "java":
return &JavaLangHelper{}
case "lambda-nodejs4.3":
return &LambdaNodeHelper{}
}
return nil
} | [
"func",
"GetLangHelper",
"(",
"lang",
"string",
")",
"LangHelper",
"{",
"switch",
"lang",
"{",
"case",
"\"",
"\"",
":",
"return",
"&",
"GoLangHelper",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"&",
"NodeLangHelper",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"&",
"RubyLangHelper",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"&",
"PythonHelper",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"&",
"RustLangHelper",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"&",
"DotNetLangHelper",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"&",
"JavaLangHelper",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"return",
"&",
"LambdaNodeHelper",
"{",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // GetLangHelper returns a LangHelper for the passed in language | [
"GetLangHelper",
"returns",
"a",
"LangHelper",
"for",
"the",
"passed",
"in",
"language"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/fn/langs/base.go#L4-L24 | train |
iron-io/functions | api/runner/runner.go | queueHandler | func (r *Runner) queueHandler(ctx context.Context) {
consumeQueue:
for {
select {
case task := <-r.taskQueue:
r.handleTask(task)
case <-ctx.Done():
break consumeQueue
}
}
// consume remainders
for len(r.taskQueue) > 0 {
r.handleTask(<-r.taskQueue)
}
} | go | func (r *Runner) queueHandler(ctx context.Context) {
consumeQueue:
for {
select {
case task := <-r.taskQueue:
r.handleTask(task)
case <-ctx.Done():
break consumeQueue
}
}
// consume remainders
for len(r.taskQueue) > 0 {
r.handleTask(<-r.taskQueue)
}
} | [
"func",
"(",
"r",
"*",
"Runner",
")",
"queueHandler",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"consumeQueue",
":",
"for",
"{",
"select",
"{",
"case",
"task",
":=",
"<-",
"r",
".",
"taskQueue",
":",
"r",
".",
"handleTask",
"(",
"task",
")",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"break",
"consumeQueue",
"\n",
"}",
"\n",
"}",
"\n\n",
"// consume remainders",
"for",
"len",
"(",
"r",
".",
"taskQueue",
")",
">",
"0",
"{",
"r",
".",
"handleTask",
"(",
"<-",
"r",
".",
"taskQueue",
")",
"\n",
"}",
"\n",
"}"
] | // This routine checks for available memory;
// If there's memory then send signal to the task to proceed.
// If there's not available memory to run the task it waits
// If the task waits for more than X seconds it timeouts | [
"This",
"routine",
"checks",
"for",
"available",
"memory",
";",
"If",
"there",
"s",
"memory",
"then",
"send",
"signal",
"to",
"the",
"task",
"to",
"proceed",
".",
"If",
"there",
"s",
"not",
"available",
"memory",
"to",
"run",
"the",
"task",
"it",
"waits",
"If",
"the",
"task",
"waits",
"for",
"more",
"than",
"X",
"seconds",
"it",
"timeouts"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/runner/runner.go#L72-L87 | train |
iron-io/functions | api/runner/task.go | DockerAuth | func (t *containerTask) DockerAuth() (docker.AuthConfiguration, error) {
reg, _, _ := drivers.ParseImage(t.Image())
authconfig := docker.AuthConfiguration{}
if customAuth := registries.Find(reg); customAuth != nil {
authconfig = docker.AuthConfiguration{
Password: customAuth.Password,
ServerAddress: customAuth.Name,
Username: customAuth.Username,
}
}
return authconfig, nil
} | go | func (t *containerTask) DockerAuth() (docker.AuthConfiguration, error) {
reg, _, _ := drivers.ParseImage(t.Image())
authconfig := docker.AuthConfiguration{}
if customAuth := registries.Find(reg); customAuth != nil {
authconfig = docker.AuthConfiguration{
Password: customAuth.Password,
ServerAddress: customAuth.Name,
Username: customAuth.Username,
}
}
return authconfig, nil
} | [
"func",
"(",
"t",
"*",
"containerTask",
")",
"DockerAuth",
"(",
")",
"(",
"docker",
".",
"AuthConfiguration",
",",
"error",
")",
"{",
"reg",
",",
"_",
",",
"_",
":=",
"drivers",
".",
"ParseImage",
"(",
"t",
".",
"Image",
"(",
")",
")",
"\n",
"authconfig",
":=",
"docker",
".",
"AuthConfiguration",
"{",
"}",
"\n\n",
"if",
"customAuth",
":=",
"registries",
".",
"Find",
"(",
"reg",
")",
";",
"customAuth",
"!=",
"nil",
"{",
"authconfig",
"=",
"docker",
".",
"AuthConfiguration",
"{",
"Password",
":",
"customAuth",
".",
"Password",
",",
"ServerAddress",
":",
"customAuth",
".",
"Name",
",",
"Username",
":",
"customAuth",
".",
"Username",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"authconfig",
",",
"nil",
"\n",
"}"
] | // Implementing the docker.AuthConfiguration interface. Pulling in
// the docker repo password from environment variables | [
"Implementing",
"the",
"docker",
".",
"AuthConfiguration",
"interface",
".",
"Pulling",
"in",
"the",
"docker",
"repo",
"password",
"from",
"environment",
"variables"
] | d59d7d1c40b2ff26b1afee31bde64df444e96525 | https://github.com/iron-io/functions/blob/d59d7d1c40b2ff26b1afee31bde64df444e96525/api/runner/task.go#L91-L104 | train |
elastic/go-ucfg | flag/file.go | NewFlagFiles | func NewFlagFiles(
cfg *ucfg.Config,
extensions map[string]FileLoader,
opts ...ucfg.Option,
) *FlagValue {
return newFlagValue(cfg, opts, func(path string) (*ucfg.Config, error, error) {
ext := filepath.Ext(path)
loader := extensions[ext]
if loader == nil {
loader = extensions[""]
}
if loader == nil {
// TODO: better error message?
return nil, fmt.Errorf("no loader for file '%v' found", path), nil
}
cfg, err := loader(path, opts...)
return cfg, err, nil
})
} | go | func NewFlagFiles(
cfg *ucfg.Config,
extensions map[string]FileLoader,
opts ...ucfg.Option,
) *FlagValue {
return newFlagValue(cfg, opts, func(path string) (*ucfg.Config, error, error) {
ext := filepath.Ext(path)
loader := extensions[ext]
if loader == nil {
loader = extensions[""]
}
if loader == nil {
// TODO: better error message?
return nil, fmt.Errorf("no loader for file '%v' found", path), nil
}
cfg, err := loader(path, opts...)
return cfg, err, nil
})
} | [
"func",
"NewFlagFiles",
"(",
"cfg",
"*",
"ucfg",
".",
"Config",
",",
"extensions",
"map",
"[",
"string",
"]",
"FileLoader",
",",
"opts",
"...",
"ucfg",
".",
"Option",
",",
")",
"*",
"FlagValue",
"{",
"return",
"newFlagValue",
"(",
"cfg",
",",
"opts",
",",
"func",
"(",
"path",
"string",
")",
"(",
"*",
"ucfg",
".",
"Config",
",",
"error",
",",
"error",
")",
"{",
"ext",
":=",
"filepath",
".",
"Ext",
"(",
"path",
")",
"\n",
"loader",
":=",
"extensions",
"[",
"ext",
"]",
"\n",
"if",
"loader",
"==",
"nil",
"{",
"loader",
"=",
"extensions",
"[",
"\"",
"\"",
"]",
"\n",
"}",
"\n",
"if",
"loader",
"==",
"nil",
"{",
"// TODO: better error message?",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
")",
",",
"nil",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"loader",
"(",
"path",
",",
"opts",
"...",
")",
"\n",
"return",
"cfg",
",",
"err",
",",
"nil",
"\n",
"}",
")",
"\n",
"}"
] | // NewFlagFiles create a new flag, that will load external configurations file
// when being used. Configurations loaded from multiple files will be merged
// into one common Config object. If cfg is not nil, then the loaded
// configurations will be merged into cfg.
// The extensions parameter define custom file loaders for different file
// extensions. If extensions contains an entry with key "", then this loader
// will be used as default fallback. | [
"NewFlagFiles",
"create",
"a",
"new",
"flag",
"that",
"will",
"load",
"external",
"configurations",
"file",
"when",
"being",
"used",
".",
"Configurations",
"loaded",
"from",
"multiple",
"files",
"will",
"be",
"merged",
"into",
"one",
"common",
"Config",
"object",
".",
"If",
"cfg",
"is",
"not",
"nil",
"then",
"the",
"loaded",
"configurations",
"will",
"be",
"merged",
"into",
"cfg",
".",
"The",
"extensions",
"parameter",
"define",
"custom",
"file",
"loaders",
"for",
"different",
"file",
"extensions",
".",
"If",
"extensions",
"contains",
"an",
"entry",
"with",
"key",
"then",
"this",
"loader",
"will",
"be",
"used",
"as",
"default",
"fallback",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/flag/file.go#L38-L56 | train |
elastic/go-ucfg | unpack.go | valueIsUnpacker | func valueIsUnpacker(v reflect.Value) (reflect.Value, bool) {
for {
if implementsUnpacker(v.Type()) {
return v, true
}
if !v.CanAddr() {
break
}
v = v.Addr()
}
return reflect.Value{}, false
} | go | func valueIsUnpacker(v reflect.Value) (reflect.Value, bool) {
for {
if implementsUnpacker(v.Type()) {
return v, true
}
if !v.CanAddr() {
break
}
v = v.Addr()
}
return reflect.Value{}, false
} | [
"func",
"valueIsUnpacker",
"(",
"v",
"reflect",
".",
"Value",
")",
"(",
"reflect",
".",
"Value",
",",
"bool",
")",
"{",
"for",
"{",
"if",
"implementsUnpacker",
"(",
"v",
".",
"Type",
"(",
")",
")",
"{",
"return",
"v",
",",
"true",
"\n",
"}",
"\n\n",
"if",
"!",
"v",
".",
"CanAddr",
"(",
")",
"{",
"break",
"\n",
"}",
"\n",
"v",
"=",
"v",
".",
"Addr",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"reflect",
".",
"Value",
"{",
"}",
",",
"false",
"\n",
"}"
] | // valueIsUnpacker checks if v implements the Unpacker interface.
// If there exists a pointer to v, the pointer to v is also tested. | [
"valueIsUnpacker",
"checks",
"if",
"v",
"implements",
"the",
"Unpacker",
"interface",
".",
"If",
"there",
"exists",
"a",
"pointer",
"to",
"v",
"the",
"pointer",
"to",
"v",
"is",
"also",
"tested",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/unpack.go#L92-L105 | train |
elastic/go-ucfg | validator.go | RegisterValidator | func RegisterValidator(name string, cb ValidatorCallback) error {
if _, exists := validators[name]; exists {
return ErrDuplicateValidator
}
validators[name] = cb
return nil
} | go | func RegisterValidator(name string, cb ValidatorCallback) error {
if _, exists := validators[name]; exists {
return ErrDuplicateValidator
}
validators[name] = cb
return nil
} | [
"func",
"RegisterValidator",
"(",
"name",
"string",
",",
"cb",
"ValidatorCallback",
")",
"error",
"{",
"if",
"_",
",",
"exists",
":=",
"validators",
"[",
"name",
"]",
";",
"exists",
"{",
"return",
"ErrDuplicateValidator",
"\n",
"}",
"\n\n",
"validators",
"[",
"name",
"]",
"=",
"cb",
"\n",
"return",
"nil",
"\n",
"}"
] | // RegisterValidator adds a new validator option to the "validate" struct tag.
// The callback will be executed when unpacking into a struct field. | [
"RegisterValidator",
"adds",
"a",
"new",
"validator",
"option",
"to",
"the",
"validate",
"struct",
"tag",
".",
"The",
"callback",
"will",
"be",
"executed",
"when",
"unpacking",
"into",
"a",
"struct",
"field",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/validator.go#L70-L77 | train |
elastic/go-ucfg | validator.go | validateRequired | func validateRequired(v interface{}, name string) error {
if v == nil {
return ErrRequired
}
return validateNonEmpty(v, name)
} | go | func validateRequired(v interface{}, name string) error {
if v == nil {
return ErrRequired
}
return validateNonEmpty(v, name)
} | [
"func",
"validateRequired",
"(",
"v",
"interface",
"{",
"}",
",",
"name",
"string",
")",
"error",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"ErrRequired",
"\n",
"}",
"\n",
"return",
"validateNonEmpty",
"(",
"v",
",",
"name",
")",
"\n",
"}"
] | // validateRequired implements the `required` validation tag.
// If a field is required, it must be present in the config.
// If field is a string, regex or slice its length must be > 0. | [
"validateRequired",
"implements",
"the",
"required",
"validation",
"tag",
".",
"If",
"a",
"field",
"is",
"required",
"it",
"must",
"be",
"present",
"in",
"the",
"config",
".",
"If",
"field",
"is",
"a",
"string",
"regex",
"or",
"slice",
"its",
"length",
"must",
"be",
">",
"0",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/validator.go#L304-L309 | train |
elastic/go-ucfg | yaml/yaml.go | NewConfig | func NewConfig(in []byte, opts ...ucfg.Option) (*ucfg.Config, error) {
var m interface{}
if err := yaml.Unmarshal(in, &m); err != nil {
return nil, err
}
return ucfg.NewFrom(m, opts...)
} | go | func NewConfig(in []byte, opts ...ucfg.Option) (*ucfg.Config, error) {
var m interface{}
if err := yaml.Unmarshal(in, &m); err != nil {
return nil, err
}
return ucfg.NewFrom(m, opts...)
} | [
"func",
"NewConfig",
"(",
"in",
"[",
"]",
"byte",
",",
"opts",
"...",
"ucfg",
".",
"Option",
")",
"(",
"*",
"ucfg",
".",
"Config",
",",
"error",
")",
"{",
"var",
"m",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"yaml",
".",
"Unmarshal",
"(",
"in",
",",
"&",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"ucfg",
".",
"NewFrom",
"(",
"m",
",",
"opts",
"...",
")",
"\n",
"}"
] | // NewConfig creates a new configuration object from the YAML string passed via in. | [
"NewConfig",
"creates",
"a",
"new",
"configuration",
"object",
"from",
"the",
"YAML",
"string",
"passed",
"via",
"in",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/yaml/yaml.go#L29-L36 | train |
elastic/go-ucfg | yaml/yaml.go | NewConfigWithFile | func NewConfigWithFile(name string, opts ...ucfg.Option) (*ucfg.Config, error) {
input, err := ioutil.ReadFile(name)
if err != nil {
return nil, err
}
opts = append([]ucfg.Option{
ucfg.MetaData(ucfg.Meta{Source: name}),
}, opts...)
return NewConfig(input, opts...)
} | go | func NewConfigWithFile(name string, opts ...ucfg.Option) (*ucfg.Config, error) {
input, err := ioutil.ReadFile(name)
if err != nil {
return nil, err
}
opts = append([]ucfg.Option{
ucfg.MetaData(ucfg.Meta{Source: name}),
}, opts...)
return NewConfig(input, opts...)
} | [
"func",
"NewConfigWithFile",
"(",
"name",
"string",
",",
"opts",
"...",
"ucfg",
".",
"Option",
")",
"(",
"*",
"ucfg",
".",
"Config",
",",
"error",
")",
"{",
"input",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"opts",
"=",
"append",
"(",
"[",
"]",
"ucfg",
".",
"Option",
"{",
"ucfg",
".",
"MetaData",
"(",
"ucfg",
".",
"Meta",
"{",
"Source",
":",
"name",
"}",
")",
",",
"}",
",",
"opts",
"...",
")",
"\n",
"return",
"NewConfig",
"(",
"input",
",",
"opts",
"...",
")",
"\n",
"}"
] | // NewConfigWithFile loads a new configuration object from an external JSON file. | [
"NewConfigWithFile",
"loads",
"a",
"new",
"configuration",
"object",
"from",
"an",
"external",
"JSON",
"file",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/yaml/yaml.go#L39-L49 | train |
elastic/go-ucfg | ucfg.go | GetFields | func (c *Config) GetFields() []string {
var names []string
for k := range c.fields.dict() {
names = append(names, k)
}
return names
} | go | func (c *Config) GetFields() []string {
var names []string
for k := range c.fields.dict() {
names = append(names, k)
}
return names
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"GetFields",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"names",
"[",
"]",
"string",
"\n",
"for",
"k",
":=",
"range",
"c",
".",
"fields",
".",
"dict",
"(",
")",
"{",
"names",
"=",
"append",
"(",
"names",
",",
"k",
")",
"\n",
"}",
"\n",
"return",
"names",
"\n",
"}"
] | // GetFields returns a list of all top-level named keys in c. | [
"GetFields",
"returns",
"a",
"list",
"of",
"all",
"top",
"-",
"level",
"named",
"keys",
"in",
"c",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/ucfg.go#L121-L127 | train |
elastic/go-ucfg | ucfg.go | Has | func (c *Config) Has(name string, idx int, options ...Option) (bool, error) {
opts := makeOptions(options)
p := parsePathIdx(name, opts.pathSep, idx)
return p.Has(c, opts)
} | go | func (c *Config) Has(name string, idx int, options ...Option) (bool, error) {
opts := makeOptions(options)
p := parsePathIdx(name, opts.pathSep, idx)
return p.Has(c, opts)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Has",
"(",
"name",
"string",
",",
"idx",
"int",
",",
"options",
"...",
"Option",
")",
"(",
"bool",
",",
"error",
")",
"{",
"opts",
":=",
"makeOptions",
"(",
"options",
")",
"\n",
"p",
":=",
"parsePathIdx",
"(",
"name",
",",
"opts",
".",
"pathSep",
",",
"idx",
")",
"\n",
"return",
"p",
".",
"Has",
"(",
"c",
",",
"opts",
")",
"\n",
"}"
] | // Has checks if a field by the given path+idx configuration exists.
// Has returns an error if the path can not be resolved because a primitive
// value is found in the middle of the traversal. | [
"Has",
"checks",
"if",
"a",
"field",
"by",
"the",
"given",
"path",
"+",
"idx",
"configuration",
"exists",
".",
"Has",
"returns",
"an",
"error",
"if",
"the",
"path",
"can",
"not",
"be",
"resolved",
"because",
"a",
"primitive",
"value",
"is",
"found",
"in",
"the",
"middle",
"of",
"the",
"traversal",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/ucfg.go#L132-L136 | train |
elastic/go-ucfg | ucfg.go | HasField | func (c *Config) HasField(name string) bool {
_, ok := c.fields.get(name)
return ok
} | go | func (c *Config) HasField(name string) bool {
_, ok := c.fields.get(name)
return ok
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"HasField",
"(",
"name",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"c",
".",
"fields",
".",
"get",
"(",
"name",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // HasField checks if c has a top-level named key name. | [
"HasField",
"checks",
"if",
"c",
"has",
"a",
"top",
"-",
"level",
"named",
"key",
"name",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/ucfg.go#L139-L142 | train |
elastic/go-ucfg | ucfg.go | Path | func (c *Config) Path(sep string) string {
return c.ctx.path(sep)
} | go | func (c *Config) Path(sep string) string {
return c.ctx.path(sep)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Path",
"(",
"sep",
"string",
")",
"string",
"{",
"return",
"c",
".",
"ctx",
".",
"path",
"(",
"sep",
")",
"\n",
"}"
] | // Path gets the absolute path of c separated by sep. If c is a root-Config an
// empty string will be returned. | [
"Path",
"gets",
"the",
"absolute",
"path",
"of",
"c",
"separated",
"by",
"sep",
".",
"If",
"c",
"is",
"a",
"root",
"-",
"Config",
"an",
"empty",
"string",
"will",
"be",
"returned",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/ucfg.go#L175-L177 | train |
elastic/go-ucfg | ucfg.go | PathOf | func (c *Config) PathOf(field, sep string) string {
return c.ctx.pathOf(field, sep)
} | go | func (c *Config) PathOf(field, sep string) string {
return c.ctx.pathOf(field, sep)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"PathOf",
"(",
"field",
",",
"sep",
"string",
")",
"string",
"{",
"return",
"c",
".",
"ctx",
".",
"pathOf",
"(",
"field",
",",
"sep",
")",
"\n",
"}"
] | // PathOf gets the absolute path of a potential setting field in c with name
// separated by sep. | [
"PathOf",
"gets",
"the",
"absolute",
"path",
"of",
"a",
"potential",
"setting",
"field",
"in",
"c",
"with",
"name",
"separated",
"by",
"sep",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/ucfg.go#L181-L183 | train |
elastic/go-ucfg | ucfg.go | Parent | func (c *Config) Parent() *Config {
ctx := c.ctx
for {
if ctx.parent == nil {
return nil
}
switch p := ctx.parent.(type) {
case cfgSub:
return p.c
default:
return nil
}
}
} | go | func (c *Config) Parent() *Config {
ctx := c.ctx
for {
if ctx.parent == nil {
return nil
}
switch p := ctx.parent.(type) {
case cfgSub:
return p.c
default:
return nil
}
}
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Parent",
"(",
")",
"*",
"Config",
"{",
"ctx",
":=",
"c",
".",
"ctx",
"\n",
"for",
"{",
"if",
"ctx",
".",
"parent",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"switch",
"p",
":=",
"ctx",
".",
"parent",
".",
"(",
"type",
")",
"{",
"case",
"cfgSub",
":",
"return",
"p",
".",
"c",
"\n",
"default",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Parent returns the parent configuration or nil if c is already a root
// Configuration. | [
"Parent",
"returns",
"the",
"parent",
"configuration",
"or",
"nil",
"if",
"c",
"is",
"already",
"a",
"root",
"Configuration",
"."
] | c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab | https://github.com/elastic/go-ucfg/blob/c5859d30d9ff1bf630e2dfbe1498ad3d1b7607ab/ucfg.go#L187-L201 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.