id int32 0 167k | 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
27,000 | colinmarc/hdfs | stat.go | AccessTime | func (fi *FileInfo) AccessTime() time.Time {
return time.Unix(int64(fi.status.GetAccessTime())/1000, 0)
} | go | func (fi *FileInfo) AccessTime() time.Time {
return time.Unix(int64(fi.status.GetAccessTime())/1000, 0)
} | [
"func",
"(",
"fi",
"*",
"FileInfo",
")",
"AccessTime",
"(",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"int64",
"(",
"fi",
".",
"status",
".",
"GetAccessTime",
"(",
")",
")",
"/",
"1000",
",",
"0",
")",
"\n",
"}"
] | // AccessTime returns the last time the file was accessed. It's not part of the
// os.FileInfo interface. | [
"AccessTime",
"returns",
"the",
"last",
"time",
"the",
"file",
"was",
"accessed",
".",
"It",
"s",
"not",
"part",
"of",
"the",
"os",
".",
"FileInfo",
"interface",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/stat.go#L104-L106 |
27,001 | colinmarc/hdfs | client.go | NewClient | func NewClient(options ClientOptions) (*Client, error) {
var err error
if options.KerberosClient != nil && options.KerberosClient.Credentials == nil {
return nil, errors.New("kerberos enabled, but kerberos client is missing credentials")
}
if options.KerberosClient != nil && options.KerberosServicePrincipleName ... | go | func NewClient(options ClientOptions) (*Client, error) {
var err error
if options.KerberosClient != nil && options.KerberosClient.Credentials == nil {
return nil, errors.New("kerberos enabled, but kerberos client is missing credentials")
}
if options.KerberosClient != nil && options.KerberosServicePrincipleName ... | [
"func",
"NewClient",
"(",
"options",
"ClientOptions",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"options",
".",
"KerberosClient",
"!=",
"nil",
"&&",
"options",
".",
"KerberosClient",
".",
"Credentials",
"==",
"nil"... | // NewClient returns a connected Client for the given options, or an error if
// the client could not be created. | [
"NewClient",
"returns",
"a",
"connected",
"Client",
"for",
"the",
"given",
"options",
"or",
"an",
"error",
"if",
"the",
"client",
"could",
"not",
"be",
"created",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/client.go#L122-L147 |
27,002 | colinmarc/hdfs | client.go | CopyToLocal | func (c *Client) CopyToLocal(src string, dst string) error {
remote, err := c.Open(src)
if err != nil {
return err
}
defer remote.Close()
local, err := os.Create(dst)
if err != nil {
return err
}
defer local.Close()
_, err = io.Copy(local, remote)
return err
} | go | func (c *Client) CopyToLocal(src string, dst string) error {
remote, err := c.Open(src)
if err != nil {
return err
}
defer remote.Close()
local, err := os.Create(dst)
if err != nil {
return err
}
defer local.Close()
_, err = io.Copy(local, remote)
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CopyToLocal",
"(",
"src",
"string",
",",
"dst",
"string",
")",
"error",
"{",
"remote",
",",
"err",
":=",
"c",
".",
"Open",
"(",
"src",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
... | // CopyToLocal copies the HDFS file specified by src to the local file at dst.
// If dst already exists, it will be overwritten. | [
"CopyToLocal",
"copies",
"the",
"HDFS",
"file",
"specified",
"by",
"src",
"to",
"the",
"local",
"file",
"at",
"dst",
".",
"If",
"dst",
"already",
"exists",
"it",
"will",
"be",
"overwritten",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/client.go#L200-L215 |
27,003 | colinmarc/hdfs | internal/rpc/checksum_reader.go | SetDeadline | func (cr *ChecksumReader) SetDeadline(t time.Time) error {
cr.deadline = t
// Return the error at connection time.
return nil
} | go | func (cr *ChecksumReader) SetDeadline(t time.Time) error {
cr.deadline = t
// Return the error at connection time.
return nil
} | [
"func",
"(",
"cr",
"*",
"ChecksumReader",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"cr",
".",
"deadline",
"=",
"t",
"\n",
"// Return the error at connection time.",
"return",
"nil",
"\n",
"}"
] | // SetDeadline sets the deadline for future ReadChecksum calls. A zero value
// for t means Read will not time out. | [
"SetDeadline",
"sets",
"the",
"deadline",
"for",
"future",
"ReadChecksum",
"calls",
".",
"A",
"zero",
"value",
"for",
"t",
"means",
"Read",
"will",
"not",
"time",
"out",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/checksum_reader.go#L32-L36 |
27,004 | colinmarc/hdfs | internal/rpc/checksum_reader.go | ReadChecksum | func (cr *ChecksumReader) ReadChecksum() ([]byte, error) {
if cr.datanodes == nil {
locs := cr.Block.GetLocs()
datanodes := make([]string, len(locs))
for i, loc := range locs {
dn := loc.GetId()
datanodes[i] = getDatanodeAddress(dn, cr.UseDatanodeHostname)
}
cr.datanodes = newDatanodeFailover(datanode... | go | func (cr *ChecksumReader) ReadChecksum() ([]byte, error) {
if cr.datanodes == nil {
locs := cr.Block.GetLocs()
datanodes := make([]string, len(locs))
for i, loc := range locs {
dn := loc.GetId()
datanodes[i] = getDatanodeAddress(dn, cr.UseDatanodeHostname)
}
cr.datanodes = newDatanodeFailover(datanode... | [
"func",
"(",
"cr",
"*",
"ChecksumReader",
")",
"ReadChecksum",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"cr",
".",
"datanodes",
"==",
"nil",
"{",
"locs",
":=",
"cr",
".",
"Block",
".",
"GetLocs",
"(",
")",
"\n",
"datanodes",
... | // ReadChecksum returns the checksum of the block. | [
"ReadChecksum",
"returns",
"the",
"checksum",
"of",
"the",
"block",
"."
] | 6f7e441ec688730014b4ca08657db358d7a45b87 | https://github.com/colinmarc/hdfs/blob/6f7e441ec688730014b4ca08657db358d7a45b87/internal/rpc/checksum_reader.go#L39-L68 |
27,005 | gocelery/gocelery | convert.go | GetRealValue | func GetRealValue(val *reflect.Value) interface{} {
if val == nil {
return nil
}
switch val.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return val.Int()
case reflect.String:
return val.String()
case reflect.Bool:
return val.Bool()
case reflect.Uint, reflect.Uint8... | go | func GetRealValue(val *reflect.Value) interface{} {
if val == nil {
return nil
}
switch val.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return val.Int()
case reflect.String:
return val.String()
case reflect.Bool:
return val.Bool()
case reflect.Uint, reflect.Uint8... | [
"func",
"GetRealValue",
"(",
"val",
"*",
"reflect",
".",
"Value",
")",
"interface",
"{",
"}",
"{",
"if",
"val",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"switch",
"val",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Int",
",",
"... | // GetRealValue returns real value of reflect.Value
// Required for JSON Marshalling | [
"GetRealValue",
"returns",
"real",
"value",
"of",
"reflect",
".",
"Value",
"Required",
"for",
"JSON",
"Marshalling"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/convert.go#L13-L31 |
27,006 | gocelery/gocelery | message.go | GetTaskMessage | func (cm *CeleryMessage) GetTaskMessage() *TaskMessage {
// ensure content-type is 'application/json'
if cm.ContentType != "application/json" {
log.Println("unsupported content type " + cm.ContentType)
return nil
}
// ensure body encoding is base64
if cm.Properties.BodyEncoding != "base64" {
log.Println("uns... | go | func (cm *CeleryMessage) GetTaskMessage() *TaskMessage {
// ensure content-type is 'application/json'
if cm.ContentType != "application/json" {
log.Println("unsupported content type " + cm.ContentType)
return nil
}
// ensure body encoding is base64
if cm.Properties.BodyEncoding != "base64" {
log.Println("uns... | [
"func",
"(",
"cm",
"*",
"CeleryMessage",
")",
"GetTaskMessage",
"(",
")",
"*",
"TaskMessage",
"{",
"// ensure content-type is 'application/json'",
"if",
"cm",
".",
"ContentType",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
"+",
"cm",
".",
... | // GetTaskMessage retrieve and decode task messages from broker | [
"GetTaskMessage",
"retrieve",
"and",
"decode",
"task",
"messages",
"from",
"broker"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/message.go#L87-L110 |
27,007 | gocelery/gocelery | message.go | DecodeTaskMessage | func DecodeTaskMessage(encodedBody string) (*TaskMessage, error) {
body, err := base64.StdEncoding.DecodeString(encodedBody)
if err != nil {
return nil, err
}
message := taskMessagePool.Get().(*TaskMessage)
err = json.Unmarshal(body, message)
if err != nil {
return nil, err
}
return message, nil
} | go | func DecodeTaskMessage(encodedBody string) (*TaskMessage, error) {
body, err := base64.StdEncoding.DecodeString(encodedBody)
if err != nil {
return nil, err
}
message := taskMessagePool.Get().(*TaskMessage)
err = json.Unmarshal(body, message)
if err != nil {
return nil, err
}
return message, nil
} | [
"func",
"DecodeTaskMessage",
"(",
"encodedBody",
"string",
")",
"(",
"*",
"TaskMessage",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"encodedBody",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r... | // DecodeTaskMessage decodes base64 encrypted body and return TaskMessage object | [
"DecodeTaskMessage",
"decodes",
"base64",
"encrypted",
"body",
"and",
"return",
"TaskMessage",
"object"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/message.go#L156-L167 |
27,008 | gocelery/gocelery | message.go | Encode | func (tm *TaskMessage) Encode() (string, error) {
jsonData, err := json.Marshal(tm)
if err != nil {
return "", err
}
encodedData := base64.StdEncoding.EncodeToString(jsonData)
return encodedData, err
} | go | func (tm *TaskMessage) Encode() (string, error) {
jsonData, err := json.Marshal(tm)
if err != nil {
return "", err
}
encodedData := base64.StdEncoding.EncodeToString(jsonData)
return encodedData, err
} | [
"func",
"(",
"tm",
"*",
"TaskMessage",
")",
"Encode",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"jsonData",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"tm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
... | // Encode returns base64 json encoded string | [
"Encode",
"returns",
"base64",
"json",
"encoded",
"string"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/message.go#L170-L177 |
27,009 | gocelery/gocelery | amqp.go | deliveryAck | func deliveryAck(delivery amqp.Delivery) {
retryCount := 3
var err error
for retryCount > 0 {
if err = delivery.Ack(false); err == nil {
break
}
}
if err != nil {
log.Printf("amqp_backend: failed to acknowledge result message %+v: %+v", delivery.MessageId, err)
}
} | go | func deliveryAck(delivery amqp.Delivery) {
retryCount := 3
var err error
for retryCount > 0 {
if err = delivery.Ack(false); err == nil {
break
}
}
if err != nil {
log.Printf("amqp_backend: failed to acknowledge result message %+v: %+v", delivery.MessageId, err)
}
} | [
"func",
"deliveryAck",
"(",
"delivery",
"amqp",
".",
"Delivery",
")",
"{",
"retryCount",
":=",
"3",
"\n",
"var",
"err",
"error",
"\n",
"for",
"retryCount",
">",
"0",
"{",
"if",
"err",
"=",
"delivery",
".",
"Ack",
"(",
"false",
")",
";",
"err",
"==",
... | // deliveryAck acknowledges delivery message with retries on error | [
"deliveryAck",
"acknowledges",
"delivery",
"message",
"with",
"retries",
"on",
"error"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp.go#L14-L25 |
27,010 | gocelery/gocelery | worker.go | NewCeleryWorker | func NewCeleryWorker(broker CeleryBroker, backend CeleryBackend, numWorkers int) *CeleryWorker {
return &CeleryWorker{
broker: broker,
backend: backend,
numWorkers: numWorkers,
registeredTasks: map[string]interface{}{},
rateLimitPeriod: 100 * time.Millisecond,
}
} | go | func NewCeleryWorker(broker CeleryBroker, backend CeleryBackend, numWorkers int) *CeleryWorker {
return &CeleryWorker{
broker: broker,
backend: backend,
numWorkers: numWorkers,
registeredTasks: map[string]interface{}{},
rateLimitPeriod: 100 * time.Millisecond,
}
} | [
"func",
"NewCeleryWorker",
"(",
"broker",
"CeleryBroker",
",",
"backend",
"CeleryBackend",
",",
"numWorkers",
"int",
")",
"*",
"CeleryWorker",
"{",
"return",
"&",
"CeleryWorker",
"{",
"broker",
":",
"broker",
",",
"backend",
":",
"backend",
",",
"numWorkers",
... | // NewCeleryWorker returns new celery worker | [
"NewCeleryWorker",
"returns",
"new",
"celery",
"worker"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/worker.go#L29-L37 |
27,011 | gocelery/gocelery | worker.go | GetTask | func (w *CeleryWorker) GetTask(name string) interface{} {
w.taskLock.RLock()
task, ok := w.registeredTasks[name]
if !ok {
w.taskLock.RUnlock()
return nil
}
w.taskLock.RUnlock()
return task
} | go | func (w *CeleryWorker) GetTask(name string) interface{} {
w.taskLock.RLock()
task, ok := w.registeredTasks[name]
if !ok {
w.taskLock.RUnlock()
return nil
}
w.taskLock.RUnlock()
return task
} | [
"func",
"(",
"w",
"*",
"CeleryWorker",
")",
"GetTask",
"(",
"name",
"string",
")",
"interface",
"{",
"}",
"{",
"w",
".",
"taskLock",
".",
"RLock",
"(",
")",
"\n",
"task",
",",
"ok",
":=",
"w",
".",
"registeredTasks",
"[",
"name",
"]",
"\n",
"if",
... | // GetTask retrieves registered task | [
"GetTask",
"retrieves",
"registered",
"task"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/worker.go#L108-L117 |
27,012 | gocelery/gocelery | worker.go | RunTask | func (w *CeleryWorker) RunTask(message *TaskMessage) (*ResultMessage, error) {
// get task
task := w.GetTask(message.Task)
if task == nil {
return nil, fmt.Errorf("task %s is not registered", message.Task)
}
// convert to task interface
taskInterface, ok := task.(CeleryTask)
if ok {
if err := taskInterface... | go | func (w *CeleryWorker) RunTask(message *TaskMessage) (*ResultMessage, error) {
// get task
task := w.GetTask(message.Task)
if task == nil {
return nil, fmt.Errorf("task %s is not registered", message.Task)
}
// convert to task interface
taskInterface, ok := task.(CeleryTask)
if ok {
if err := taskInterface... | [
"func",
"(",
"w",
"*",
"CeleryWorker",
")",
"RunTask",
"(",
"message",
"*",
"TaskMessage",
")",
"(",
"*",
"ResultMessage",
",",
"error",
")",
"{",
"// get task",
"task",
":=",
"w",
".",
"GetTask",
"(",
"message",
".",
"Task",
")",
"\n",
"if",
"task",
... | // RunTask runs celery task | [
"RunTask",
"runs",
"celery",
"task"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/worker.go#L120-L144 |
27,013 | gocelery/gocelery | redis_backend.go | GetResult | func (cb *RedisCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
conn := cb.Get()
defer conn.Close()
val, err := conn.Do("GET", fmt.Sprintf("celery-task-meta-%s", taskID))
if err != nil {
return nil, err
}
if val == nil {
return nil, fmt.Errorf("result not available")
}
var resultMessage Res... | go | func (cb *RedisCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
conn := cb.Get()
defer conn.Close()
val, err := conn.Do("GET", fmt.Sprintf("celery-task-meta-%s", taskID))
if err != nil {
return nil, err
}
if val == nil {
return nil, fmt.Errorf("result not available")
}
var resultMessage Res... | [
"func",
"(",
"cb",
"*",
"RedisCeleryBackend",
")",
"GetResult",
"(",
"taskID",
"string",
")",
"(",
"*",
"ResultMessage",
",",
"error",
")",
"{",
"conn",
":=",
"cb",
".",
"Get",
"(",
")",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"val",
"... | // GetResult queries redis backend to get asynchronous result | [
"GetResult",
"queries",
"redis",
"backend",
"to",
"get",
"asynchronous",
"result"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_backend.go#L27-L43 |
27,014 | gocelery/gocelery | redis_backend.go | SetResult | func (cb *RedisCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
resBytes, err := json.Marshal(result)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("SETEX", fmt.Sprintf("celery-task-meta-%s", taskID), 86400, resBytes)
return err
} | go | func (cb *RedisCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
resBytes, err := json.Marshal(result)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("SETEX", fmt.Sprintf("celery-task-meta-%s", taskID), 86400, resBytes)
return err
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBackend",
")",
"SetResult",
"(",
"taskID",
"string",
",",
"result",
"*",
"ResultMessage",
")",
"error",
"{",
"resBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"... | // SetResult pushes result back into redis backend | [
"SetResult",
"pushes",
"result",
"back",
"into",
"redis",
"backend"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_backend.go#L46-L55 |
27,015 | gocelery/gocelery | gocelery.go | NewCeleryClient | func NewCeleryClient(broker CeleryBroker, backend CeleryBackend, numWorkers int) (*CeleryClient, error) {
return &CeleryClient{
broker,
backend,
NewCeleryWorker(broker, backend, numWorkers),
}, nil
} | go | func NewCeleryClient(broker CeleryBroker, backend CeleryBackend, numWorkers int) (*CeleryClient, error) {
return &CeleryClient{
broker,
backend,
NewCeleryWorker(broker, backend, numWorkers),
}, nil
} | [
"func",
"NewCeleryClient",
"(",
"broker",
"CeleryBroker",
",",
"backend",
"CeleryBackend",
",",
"numWorkers",
"int",
")",
"(",
"*",
"CeleryClient",
",",
"error",
")",
"{",
"return",
"&",
"CeleryClient",
"{",
"broker",
",",
"backend",
",",
"NewCeleryWorker",
"(... | // NewCeleryClient creates new celery client | [
"NewCeleryClient",
"creates",
"new",
"celery",
"client"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L33-L39 |
27,016 | gocelery/gocelery | gocelery.go | StartWorkerWithContext | func (cc *CeleryClient) StartWorkerWithContext(ctx context.Context) {
cc.worker.StartWorkerWithContext(ctx)
} | go | func (cc *CeleryClient) StartWorkerWithContext(ctx context.Context) {
cc.worker.StartWorkerWithContext(ctx)
} | [
"func",
"(",
"cc",
"*",
"CeleryClient",
")",
"StartWorkerWithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"cc",
".",
"worker",
".",
"StartWorkerWithContext",
"(",
"ctx",
")",
"\n",
"}"
] | // StartWorkerWithContext starts celery workers with given parent context | [
"StartWorkerWithContext",
"starts",
"celery",
"workers",
"with",
"given",
"parent",
"context"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L47-L49 |
27,017 | gocelery/gocelery | gocelery.go | Delay | func (cc *CeleryClient) Delay(task string, args ...interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Args = args
return cc.delay(celeryTask)
} | go | func (cc *CeleryClient) Delay(task string, args ...interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Args = args
return cc.delay(celeryTask)
} | [
"func",
"(",
"cc",
"*",
"CeleryClient",
")",
"Delay",
"(",
"task",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"AsyncResult",
",",
"error",
")",
"{",
"celeryTask",
":=",
"getTaskMessage",
"(",
"task",
")",
"\n",
"celeryTask",
".... | // Delay gets asynchronous result | [
"Delay",
"gets",
"asynchronous",
"result"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L67-L71 |
27,018 | gocelery/gocelery | gocelery.go | DelayKwargs | func (cc *CeleryClient) DelayKwargs(task string, args map[string]interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Kwargs = args
return cc.delay(celeryTask)
} | go | func (cc *CeleryClient) DelayKwargs(task string, args map[string]interface{}) (*AsyncResult, error) {
celeryTask := getTaskMessage(task)
celeryTask.Kwargs = args
return cc.delay(celeryTask)
} | [
"func",
"(",
"cc",
"*",
"CeleryClient",
")",
"DelayKwargs",
"(",
"task",
"string",
",",
"args",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"*",
"AsyncResult",
",",
"error",
")",
"{",
"celeryTask",
":=",
"getTaskMessage",
"(",
"task",
"... | // DelayKwargs gets asynchronous results with argument map | [
"DelayKwargs",
"gets",
"asynchronous",
"results",
"with",
"argument",
"map"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L74-L78 |
27,019 | gocelery/gocelery | gocelery.go | Get | func (ar *AsyncResult) Get(timeout time.Duration) (interface{}, error) {
ticker := time.NewTicker(50 * time.Millisecond)
timeoutChan := time.After(timeout)
for {
select {
case <-timeoutChan:
err := fmt.Errorf("%v timeout getting result for %s", timeout, ar.TaskID)
return nil, err
case <-ticker.C:
val,... | go | func (ar *AsyncResult) Get(timeout time.Duration) (interface{}, error) {
ticker := time.NewTicker(50 * time.Millisecond)
timeoutChan := time.After(timeout)
for {
select {
case <-timeoutChan:
err := fmt.Errorf("%v timeout getting result for %s", timeout, ar.TaskID)
return nil, err
case <-ticker.C:
val,... | [
"func",
"(",
"ar",
"*",
"AsyncResult",
")",
"Get",
"(",
"timeout",
"time",
".",
"Duration",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"50",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"t... | // Get gets actual result from backend
// It blocks for period of time set by timeout and returns error if unavailable | [
"Get",
"gets",
"actual",
"result",
"from",
"backend",
"It",
"blocks",
"for",
"period",
"of",
"time",
"set",
"by",
"timeout",
"and",
"returns",
"error",
"if",
"unavailable"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L120-L136 |
27,020 | gocelery/gocelery | gocelery.go | AsyncGet | func (ar *AsyncResult) AsyncGet() (interface{}, error) {
if ar.result != nil {
return ar.result.Result, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return nil, err
}
if val == nil {
return nil, err
}
if val.Status != "SUCCESS" {
return nil, fmt.Errorf("error response status %v", va... | go | func (ar *AsyncResult) AsyncGet() (interface{}, error) {
if ar.result != nil {
return ar.result.Result, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return nil, err
}
if val == nil {
return nil, err
}
if val.Status != "SUCCESS" {
return nil, fmt.Errorf("error response status %v", va... | [
"func",
"(",
"ar",
"*",
"AsyncResult",
")",
"AsyncGet",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"ar",
".",
"result",
"!=",
"nil",
"{",
"return",
"ar",
".",
"result",
".",
"Result",
",",
"nil",
"\n",
"}",
"\n",
"val",
... | // AsyncGet gets actual result from backend and returns nil if not available | [
"AsyncGet",
"gets",
"actual",
"result",
"from",
"backend",
"and",
"returns",
"nil",
"if",
"not",
"available"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L139-L155 |
27,021 | gocelery/gocelery | gocelery.go | Ready | func (ar *AsyncResult) Ready() (bool, error) {
if ar.result != nil {
return true, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return false, err
}
ar.result = val
return (val != nil), nil
} | go | func (ar *AsyncResult) Ready() (bool, error) {
if ar.result != nil {
return true, nil
}
val, err := ar.backend.GetResult(ar.TaskID)
if err != nil {
return false, err
}
ar.result = val
return (val != nil), nil
} | [
"func",
"(",
"ar",
"*",
"AsyncResult",
")",
"Ready",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"ar",
".",
"result",
"!=",
"nil",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"val",
",",
"err",
":=",
"ar",
".",
"backend",
".",
... | // Ready checks if actual result is ready | [
"Ready",
"checks",
"if",
"actual",
"result",
"is",
"ready"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/gocelery.go#L158-L168 |
27,022 | gocelery/gocelery | amqp_broker.go | NewAMQPExchange | func NewAMQPExchange(name string) *AMQPExchange {
return &AMQPExchange{
Name: name,
Type: "direct",
Durable: true,
AutoDelete: true,
}
} | go | func NewAMQPExchange(name string) *AMQPExchange {
return &AMQPExchange{
Name: name,
Type: "direct",
Durable: true,
AutoDelete: true,
}
} | [
"func",
"NewAMQPExchange",
"(",
"name",
"string",
")",
"*",
"AMQPExchange",
"{",
"return",
"&",
"AMQPExchange",
"{",
"Name",
":",
"name",
",",
"Type",
":",
"\"",
"\"",
",",
"Durable",
":",
"true",
",",
"AutoDelete",
":",
"true",
",",
"}",
"\n",
"}"
] | // NewAMQPExchange creates new AMQPExchange | [
"NewAMQPExchange",
"creates",
"new",
"AMQPExchange"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L24-L31 |
27,023 | gocelery/gocelery | amqp_broker.go | NewAMQPQueue | func NewAMQPQueue(name string) *AMQPQueue {
return &AMQPQueue{
Name: name,
Durable: true,
AutoDelete: false,
}
} | go | func NewAMQPQueue(name string) *AMQPQueue {
return &AMQPQueue{
Name: name,
Durable: true,
AutoDelete: false,
}
} | [
"func",
"NewAMQPQueue",
"(",
"name",
"string",
")",
"*",
"AMQPQueue",
"{",
"return",
"&",
"AMQPQueue",
"{",
"Name",
":",
"name",
",",
"Durable",
":",
"true",
",",
"AutoDelete",
":",
"false",
",",
"}",
"\n",
"}"
] | // NewAMQPQueue creates new AMQPQueue | [
"NewAMQPQueue",
"creates",
"new",
"AMQPQueue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L41-L47 |
27,024 | gocelery/gocelery | amqp_broker.go | NewAMQPConnection | func NewAMQPConnection(host string) (*amqp.Connection, *amqp.Channel) {
connection, err := amqp.Dial(host)
if err != nil {
panic(err)
}
channel, err := connection.Channel()
if err != nil {
panic(err)
}
return connection, channel
} | go | func NewAMQPConnection(host string) (*amqp.Connection, *amqp.Channel) {
connection, err := amqp.Dial(host)
if err != nil {
panic(err)
}
channel, err := connection.Channel()
if err != nil {
panic(err)
}
return connection, channel
} | [
"func",
"NewAMQPConnection",
"(",
"host",
"string",
")",
"(",
"*",
"amqp",
".",
"Connection",
",",
"*",
"amqp",
".",
"Channel",
")",
"{",
"connection",
",",
"err",
":=",
"amqp",
".",
"Dial",
"(",
"host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"p... | // NewAMQPConnection creates new AMQP channel | [
"NewAMQPConnection",
"creates",
"new",
"AMQP",
"channel"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L60-L71 |
27,025 | gocelery/gocelery | amqp_broker.go | NewAMQPCeleryBrokerByConnAndChannel | func NewAMQPCeleryBrokerByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBroker {
broker := &AMQPCeleryBroker{
Channel: channel,
connection: conn,
exchange: NewAMQPExchange("default"),
queue: NewAMQPQueue("celery"),
rate: 4,
}
if err := broker.CreateExchange(); err ... | go | func NewAMQPCeleryBrokerByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBroker {
broker := &AMQPCeleryBroker{
Channel: channel,
connection: conn,
exchange: NewAMQPExchange("default"),
queue: NewAMQPQueue("celery"),
rate: 4,
}
if err := broker.CreateExchange(); err ... | [
"func",
"NewAMQPCeleryBrokerByConnAndChannel",
"(",
"conn",
"*",
"amqp",
".",
"Connection",
",",
"channel",
"*",
"amqp",
".",
"Channel",
")",
"*",
"AMQPCeleryBroker",
"{",
"broker",
":=",
"&",
"AMQPCeleryBroker",
"{",
"Channel",
":",
"channel",
",",
"connection"... | // NewAMQPCeleryBrokerByConnAndChannel creates new AMQPCeleryBroker using AMQP conn and channel | [
"NewAMQPCeleryBrokerByConnAndChannel",
"creates",
"new",
"AMQPCeleryBroker",
"using",
"AMQP",
"conn",
"and",
"channel"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L79-L100 |
27,026 | gocelery/gocelery | amqp_broker.go | StartConsumingChannel | func (b *AMQPCeleryBroker) StartConsumingChannel() error {
channel, err := b.Consume(b.queue.Name, "", false, false, false, false, nil)
if err != nil {
return err
}
b.consumingChannel = channel
return nil
} | go | func (b *AMQPCeleryBroker) StartConsumingChannel() error {
channel, err := b.Consume(b.queue.Name, "", false, false, false, false, nil)
if err != nil {
return err
}
b.consumingChannel = channel
return nil
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"StartConsumingChannel",
"(",
")",
"error",
"{",
"channel",
",",
"err",
":=",
"b",
".",
"Consume",
"(",
"b",
".",
"queue",
".",
"Name",
",",
"\"",
"\"",
",",
"false",
",",
"false",
",",
"false",
",",
... | // StartConsumingChannel spawns receiving channel on AMQP queue | [
"StartConsumingChannel",
"spawns",
"receiving",
"channel",
"on",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L103-L110 |
27,027 | gocelery/gocelery | amqp_broker.go | SendCeleryMessage | func (b *AMQPCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
taskMessage := message.GetTaskMessage()
queueName := "celery"
_, err := b.QueueDeclare(
queueName, // name
true, // durable
false, // autoDelete
false, // exclusive
false, // noWait
nil, // args
)
if err... | go | func (b *AMQPCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
taskMessage := message.GetTaskMessage()
queueName := "celery"
_, err := b.QueueDeclare(
queueName, // name
true, // durable
false, // autoDelete
false, // exclusive
false, // noWait
nil, // args
)
if err... | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"SendCeleryMessage",
"(",
"message",
"*",
"CeleryMessage",
")",
"error",
"{",
"taskMessage",
":=",
"message",
".",
"GetTaskMessage",
"(",
")",
"\n",
"queueName",
":=",
"\"",
"\"",
"\n",
"_",
",",
"err",
":=",... | // SendCeleryMessage sends CeleryMessage to broker | [
"SendCeleryMessage",
"sends",
"CeleryMessage",
"to",
"broker"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L113-L159 |
27,028 | gocelery/gocelery | amqp_broker.go | GetTaskMessage | func (b *AMQPCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
select {
case delivery := <-b.consumingChannel:
deliveryAck(delivery)
var taskMessage TaskMessage
if err := json.Unmarshal(delivery.Body, &taskMessage); err != nil {
return nil, err
}
return &taskMessage, nil
default:
return nil, fmt.... | go | func (b *AMQPCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
select {
case delivery := <-b.consumingChannel:
deliveryAck(delivery)
var taskMessage TaskMessage
if err := json.Unmarshal(delivery.Body, &taskMessage); err != nil {
return nil, err
}
return &taskMessage, nil
default:
return nil, fmt.... | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"GetTaskMessage",
"(",
")",
"(",
"*",
"TaskMessage",
",",
"error",
")",
"{",
"select",
"{",
"case",
"delivery",
":=",
"<-",
"b",
".",
"consumingChannel",
":",
"deliveryAck",
"(",
"delivery",
")",
"\n",
"var... | // GetTaskMessage retrieves task message from AMQP queue | [
"GetTaskMessage",
"retrieves",
"task",
"message",
"from",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L162-L174 |
27,029 | gocelery/gocelery | amqp_broker.go | CreateExchange | func (b *AMQPCeleryBroker) CreateExchange() error {
return b.ExchangeDeclare(
b.exchange.Name,
b.exchange.Type,
b.exchange.Durable,
b.exchange.AutoDelete,
false,
false,
nil,
)
} | go | func (b *AMQPCeleryBroker) CreateExchange() error {
return b.ExchangeDeclare(
b.exchange.Name,
b.exchange.Type,
b.exchange.Durable,
b.exchange.AutoDelete,
false,
false,
nil,
)
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"CreateExchange",
"(",
")",
"error",
"{",
"return",
"b",
".",
"ExchangeDeclare",
"(",
"b",
".",
"exchange",
".",
"Name",
",",
"b",
".",
"exchange",
".",
"Type",
",",
"b",
".",
"exchange",
".",
"Durable",
... | // CreateExchange declares AMQP exchange with stored configuration | [
"CreateExchange",
"declares",
"AMQP",
"exchange",
"with",
"stored",
"configuration"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L177-L187 |
27,030 | gocelery/gocelery | amqp_broker.go | CreateQueue | func (b *AMQPCeleryBroker) CreateQueue() error {
_, err := b.QueueDeclare(
b.queue.Name,
b.queue.Durable,
b.queue.AutoDelete,
false,
false,
nil,
)
return err
} | go | func (b *AMQPCeleryBroker) CreateQueue() error {
_, err := b.QueueDeclare(
b.queue.Name,
b.queue.Durable,
b.queue.AutoDelete,
false,
false,
nil,
)
return err
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBroker",
")",
"CreateQueue",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"b",
".",
"QueueDeclare",
"(",
"b",
".",
"queue",
".",
"Name",
",",
"b",
".",
"queue",
".",
"Durable",
",",
"b",
".",
"queue",
".",
"Aut... | // CreateQueue declares AMQP Queue with stored configuration | [
"CreateQueue",
"declares",
"AMQP",
"Queue",
"with",
"stored",
"configuration"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_broker.go#L190-L200 |
27,031 | gocelery/gocelery | amqp_backend.go | NewAMQPCeleryBackendByConnAndChannel | func NewAMQPCeleryBackendByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBackend {
backend := &AMQPCeleryBackend{
Channel: channel,
connection: conn,
}
return backend
} | go | func NewAMQPCeleryBackendByConnAndChannel(conn *amqp.Connection, channel *amqp.Channel) *AMQPCeleryBackend {
backend := &AMQPCeleryBackend{
Channel: channel,
connection: conn,
}
return backend
} | [
"func",
"NewAMQPCeleryBackendByConnAndChannel",
"(",
"conn",
"*",
"amqp",
".",
"Connection",
",",
"channel",
"*",
"amqp",
".",
"Channel",
")",
"*",
"AMQPCeleryBackend",
"{",
"backend",
":=",
"&",
"AMQPCeleryBackend",
"{",
"Channel",
":",
"channel",
",",
"connect... | // NewAMQPCeleryBackendByConnAndChannel creates new AMQPCeleryBackend by AMQP connection and channel | [
"NewAMQPCeleryBackendByConnAndChannel",
"creates",
"new",
"AMQPCeleryBackend",
"by",
"AMQP",
"connection",
"and",
"channel"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L23-L29 |
27,032 | gocelery/gocelery | amqp_backend.go | NewAMQPCeleryBackend | func NewAMQPCeleryBackend(host string) *AMQPCeleryBackend {
backend := NewAMQPCeleryBackendByConnAndChannel(NewAMQPConnection(host))
backend.host = host
return backend
} | go | func NewAMQPCeleryBackend(host string) *AMQPCeleryBackend {
backend := NewAMQPCeleryBackendByConnAndChannel(NewAMQPConnection(host))
backend.host = host
return backend
} | [
"func",
"NewAMQPCeleryBackend",
"(",
"host",
"string",
")",
"*",
"AMQPCeleryBackend",
"{",
"backend",
":=",
"NewAMQPCeleryBackendByConnAndChannel",
"(",
"NewAMQPConnection",
"(",
"host",
")",
")",
"\n",
"backend",
".",
"host",
"=",
"host",
"\n",
"return",
"backend... | // NewAMQPCeleryBackend creates new AMQPCeleryBackend | [
"NewAMQPCeleryBackend",
"creates",
"new",
"AMQPCeleryBackend"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L32-L36 |
27,033 | gocelery/gocelery | amqp_backend.go | Reconnect | func (b *AMQPCeleryBackend) Reconnect() {
b.connection.Close()
conn, channel := NewAMQPConnection(b.host)
b.Channel = channel
b.connection = conn
} | go | func (b *AMQPCeleryBackend) Reconnect() {
b.connection.Close()
conn, channel := NewAMQPConnection(b.host)
b.Channel = channel
b.connection = conn
} | [
"func",
"(",
"b",
"*",
"AMQPCeleryBackend",
")",
"Reconnect",
"(",
")",
"{",
"b",
".",
"connection",
".",
"Close",
"(",
")",
"\n",
"conn",
",",
"channel",
":=",
"NewAMQPConnection",
"(",
"b",
".",
"host",
")",
"\n",
"b",
".",
"Channel",
"=",
"channel... | // Reconnect reconnects to AMQP server | [
"Reconnect",
"reconnects",
"to",
"AMQP",
"server"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L39-L44 |
27,034 | gocelery/gocelery | amqp_backend.go | GetResult | func (b *AMQPCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
queueName := strings.Replace(taskID, "-", "", -1)
args := amqp.Table{"x-expires": int32(86400000)}
_, err := b.QueueDeclare(
queueName, // name
true, // durable
true, // autoDelete
false, // exclusive
false, ... | go | func (b *AMQPCeleryBackend) GetResult(taskID string) (*ResultMessage, error) {
queueName := strings.Replace(taskID, "-", "", -1)
args := amqp.Table{"x-expires": int32(86400000)}
_, err := b.QueueDeclare(
queueName, // name
true, // durable
true, // autoDelete
false, // exclusive
false, ... | [
"func",
"(",
"b",
"*",
"AMQPCeleryBackend",
")",
"GetResult",
"(",
"taskID",
"string",
")",
"(",
"*",
"ResultMessage",
",",
"error",
")",
"{",
"queueName",
":=",
"strings",
".",
"Replace",
"(",
"taskID",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1... | // GetResult retrieves result from AMQP queue | [
"GetResult",
"retrieves",
"result",
"from",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L47-L92 |
27,035 | gocelery/gocelery | amqp_backend.go | SetResult | func (b *AMQPCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
result.ID = taskID
//queueName := taskID
queueName := strings.Replace(taskID, "-", "", -1)
// autodelete is automatically set to true by python
// (406) PRECONDITION_FAILED - inequivalent arg 'durable' for queue 'bc58c0d895c7421... | go | func (b *AMQPCeleryBackend) SetResult(taskID string, result *ResultMessage) error {
result.ID = taskID
//queueName := taskID
queueName := strings.Replace(taskID, "-", "", -1)
// autodelete is automatically set to true by python
// (406) PRECONDITION_FAILED - inequivalent arg 'durable' for queue 'bc58c0d895c7421... | [
"func",
"(",
"b",
"*",
"AMQPCeleryBackend",
")",
"SetResult",
"(",
"taskID",
"string",
",",
"result",
"*",
"ResultMessage",
")",
"error",
"{",
"result",
".",
"ID",
"=",
"taskID",
"\n\n",
"//queueName := taskID",
"queueName",
":=",
"strings",
".",
"Replace",
... | // SetResult sets result back to AMQP queue | [
"SetResult",
"sets",
"result",
"back",
"to",
"AMQP",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/amqp_backend.go#L95-L149 |
27,036 | gocelery/gocelery | redis_broker.go | NewRedisPool | func NewRedisPool(uri string) *redis.Pool {
return &redis.Pool{
MaxIdle: 3,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.DialURL(uri)
if err != nil {
return nil, err
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err :=... | go | func NewRedisPool(uri string) *redis.Pool {
return &redis.Pool{
MaxIdle: 3,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.DialURL(uri)
if err != nil {
return nil, err
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err :=... | [
"func",
"NewRedisPool",
"(",
"uri",
"string",
")",
"*",
"redis",
".",
"Pool",
"{",
"return",
"&",
"redis",
".",
"Pool",
"{",
"MaxIdle",
":",
"3",
",",
"IdleTimeout",
":",
"240",
"*",
"time",
".",
"Second",
",",
"Dial",
":",
"func",
"(",
")",
"(",
... | // NewRedisPool creates pool of redis connections from given connection string | [
"NewRedisPool",
"creates",
"pool",
"of",
"redis",
"connections",
"from",
"given",
"connection",
"string"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L22-L38 |
27,037 | gocelery/gocelery | redis_broker.go | SendCeleryMessage | func (cb *RedisCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
jsonBytes, err := json.Marshal(message)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("LPUSH", cb.queueName, jsonBytes)
if err != nil {
return err
}
return nil
} | go | func (cb *RedisCeleryBroker) SendCeleryMessage(message *CeleryMessage) error {
jsonBytes, err := json.Marshal(message)
if err != nil {
return err
}
conn := cb.Get()
defer conn.Close()
_, err = conn.Do("LPUSH", cb.queueName, jsonBytes)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBroker",
")",
"SendCeleryMessage",
"(",
"message",
"*",
"CeleryMessage",
")",
"error",
"{",
"jsonBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"er... | // SendCeleryMessage sends CeleryMessage to redis queue | [
"SendCeleryMessage",
"sends",
"CeleryMessage",
"to",
"redis",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L49-L61 |
27,038 | gocelery/gocelery | redis_broker.go | GetCeleryMessage | func (cb *RedisCeleryBroker) GetCeleryMessage() (*CeleryMessage, error) {
conn := cb.Get()
defer conn.Close()
messageJSON, err := conn.Do("BLPOP", cb.queueName, "1")
if err != nil {
return nil, err
}
if messageJSON == nil {
return nil, fmt.Errorf("null message received from redis")
}
messageList := messageJ... | go | func (cb *RedisCeleryBroker) GetCeleryMessage() (*CeleryMessage, error) {
conn := cb.Get()
defer conn.Close()
messageJSON, err := conn.Do("BLPOP", cb.queueName, "1")
if err != nil {
return nil, err
}
if messageJSON == nil {
return nil, fmt.Errorf("null message received from redis")
}
messageList := messageJ... | [
"func",
"(",
"cb",
"*",
"RedisCeleryBroker",
")",
"GetCeleryMessage",
"(",
")",
"(",
"*",
"CeleryMessage",
",",
"error",
")",
"{",
"conn",
":=",
"cb",
".",
"Get",
"(",
")",
"\n",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"messageJSON",
",",
"err... | // GetCeleryMessage retrieves celery message from redis queue | [
"GetCeleryMessage",
"retrieves",
"celery",
"message",
"from",
"redis",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L64-L83 |
27,039 | gocelery/gocelery | redis_broker.go | GetTaskMessage | func (cb *RedisCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
celeryMessage, err := cb.GetCeleryMessage()
if err != nil {
return nil, err
}
return celeryMessage.GetTaskMessage(), nil
} | go | func (cb *RedisCeleryBroker) GetTaskMessage() (*TaskMessage, error) {
celeryMessage, err := cb.GetCeleryMessage()
if err != nil {
return nil, err
}
return celeryMessage.GetTaskMessage(), nil
} | [
"func",
"(",
"cb",
"*",
"RedisCeleryBroker",
")",
"GetTaskMessage",
"(",
")",
"(",
"*",
"TaskMessage",
",",
"error",
")",
"{",
"celeryMessage",
",",
"err",
":=",
"cb",
".",
"GetCeleryMessage",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"n... | // GetTaskMessage retrieves task message from redis queue | [
"GetTaskMessage",
"retrieves",
"task",
"message",
"from",
"redis",
"queue"
] | b32fedd18857d5975170395a2b8145ed7d1b5885 | https://github.com/gocelery/gocelery/blob/b32fedd18857d5975170395a2b8145ed7d1b5885/redis_broker.go#L86-L92 |
27,040 | pseudomuto/protoc-gen-doc | filters.go | NoBrFilter | func NoBrFilter(content string) string {
normalized := strings.Replace(content, "\r\n", "\n", -1)
paragraphs := multiNewlinePattern.Split(normalized, -1)
for i, p := range paragraphs {
withoutCR := strings.Replace(p, "\r", " ", -1)
withoutLF := strings.Replace(withoutCR, "\n", " ", -1)
paragraphs[i] = spacePat... | go | func NoBrFilter(content string) string {
normalized := strings.Replace(content, "\r\n", "\n", -1)
paragraphs := multiNewlinePattern.Split(normalized, -1)
for i, p := range paragraphs {
withoutCR := strings.Replace(p, "\r", " ", -1)
withoutLF := strings.Replace(withoutCR, "\n", " ", -1)
paragraphs[i] = spacePat... | [
"func",
"NoBrFilter",
"(",
"content",
"string",
")",
"string",
"{",
"normalized",
":=",
"strings",
".",
"Replace",
"(",
"content",
",",
"\"",
"\\r",
"\\n",
"\"",
",",
"\"",
"\\n",
"\"",
",",
"-",
"1",
")",
"\n",
"paragraphs",
":=",
"multiNewlinePattern",... | // NoBrFilter removes single CR and LF from content. | [
"NoBrFilter",
"removes",
"single",
"CR",
"and",
"LF",
"from",
"content",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/filters.go#L29-L38 |
27,041 | pseudomuto/protoc-gen-doc | template.go | NewTemplate | func NewTemplate(descs []*protokit.FileDescriptor) *Template {
files := make([]*File, 0, len(descs))
for _, f := range descs {
file := &File{
Name: f.GetName(),
Description: description(f.GetSyntaxComments().String()),
Package: f.GetPackage(),
HasEnums: len(f.Enums) > 0,
HasExt... | go | func NewTemplate(descs []*protokit.FileDescriptor) *Template {
files := make([]*File, 0, len(descs))
for _, f := range descs {
file := &File{
Name: f.GetName(),
Description: description(f.GetSyntaxComments().String()),
Package: f.GetPackage(),
HasEnums: len(f.Enums) > 0,
HasExt... | [
"func",
"NewTemplate",
"(",
"descs",
"[",
"]",
"*",
"protokit",
".",
"FileDescriptor",
")",
"*",
"Template",
"{",
"files",
":=",
"make",
"(",
"[",
"]",
"*",
"File",
",",
"0",
",",
"len",
"(",
"descs",
")",
")",
"\n\n",
"for",
"_",
",",
"f",
":=",... | // NewTemplate creates a Template object from a set of descriptors. | [
"NewTemplate",
"creates",
"a",
"Template",
"object",
"from",
"a",
"set",
"of",
"descriptors",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L24-L79 |
27,042 | pseudomuto/protoc-gen-doc | template.go | FieldOptions | func (m Message) FieldOptions() []string {
optionSet := make(map[string]struct{})
for _, field := range m.Fields {
for option := range field.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
o... | go | func (m Message) FieldOptions() []string {
optionSet := make(map[string]struct{})
for _, field := range m.Fields {
for option := range field.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
o... | [
"func",
"(",
"m",
"Message",
")",
"FieldOptions",
"(",
")",
"[",
"]",
"string",
"{",
"optionSet",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"field",
":=",
"range",
"m",
".",
"Fields",
"{",
"for"... | // FieldOptions returns all options that are set on the fields in this message. | [
"FieldOptions",
"returns",
"all",
"options",
"that",
"are",
"set",
"on",
"the",
"fields",
"in",
"this",
"message",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L190-L206 |
27,043 | pseudomuto/protoc-gen-doc | template.go | FieldsWithOption | func (m Message) FieldsWithOption(optionName string) []*MessageField {
fields := make([]*MessageField, 0, len(m.Fields))
for _, field := range m.Fields {
if _, ok := field.Options[optionName]; ok {
fields = append(fields, field)
}
}
if len(fields) > 0 {
return fields
}
return nil
} | go | func (m Message) FieldsWithOption(optionName string) []*MessageField {
fields := make([]*MessageField, 0, len(m.Fields))
for _, field := range m.Fields {
if _, ok := field.Options[optionName]; ok {
fields = append(fields, field)
}
}
if len(fields) > 0 {
return fields
}
return nil
} | [
"func",
"(",
"m",
"Message",
")",
"FieldsWithOption",
"(",
"optionName",
"string",
")",
"[",
"]",
"*",
"MessageField",
"{",
"fields",
":=",
"make",
"(",
"[",
"]",
"*",
"MessageField",
",",
"0",
",",
"len",
"(",
"m",
".",
"Fields",
")",
")",
"\n",
"... | // FieldsWithOption returns all fields that have the given option set.
// If no single value has the option set, this returns nil. | [
"FieldsWithOption",
"returns",
"all",
"fields",
"that",
"have",
"the",
"given",
"option",
"set",
".",
"If",
"no",
"single",
"value",
"has",
"the",
"option",
"set",
"this",
"returns",
"nil",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L210-L221 |
27,044 | pseudomuto/protoc-gen-doc | template.go | ValueOptions | func (e Enum) ValueOptions() []string {
optionSet := make(map[string]struct{})
for _, value := range e.Values {
for option := range value.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
opti... | go | func (e Enum) ValueOptions() []string {
optionSet := make(map[string]struct{})
for _, value := range e.Values {
for option := range value.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {
opti... | [
"func",
"(",
"e",
"Enum",
")",
"ValueOptions",
"(",
")",
"[",
"]",
"string",
"{",
"optionSet",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"e",
".",
"Values",
"{",
"for",
... | // ValueOptions returns all options that are set on the values in this enum. | [
"ValueOptions",
"returns",
"all",
"options",
"that",
"are",
"set",
"on",
"the",
"values",
"in",
"this",
"enum",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L267-L283 |
27,045 | pseudomuto/protoc-gen-doc | template.go | ValuesWithOption | func (e Enum) ValuesWithOption(optionName string) []*EnumValue {
values := make([]*EnumValue, 0, len(e.Values))
for _, value := range e.Values {
if _, ok := value.Options[optionName]; ok {
values = append(values, value)
}
}
if len(values) > 0 {
return values
}
return nil
} | go | func (e Enum) ValuesWithOption(optionName string) []*EnumValue {
values := make([]*EnumValue, 0, len(e.Values))
for _, value := range e.Values {
if _, ok := value.Options[optionName]; ok {
values = append(values, value)
}
}
if len(values) > 0 {
return values
}
return nil
} | [
"func",
"(",
"e",
"Enum",
")",
"ValuesWithOption",
"(",
"optionName",
"string",
")",
"[",
"]",
"*",
"EnumValue",
"{",
"values",
":=",
"make",
"(",
"[",
"]",
"*",
"EnumValue",
",",
"0",
",",
"len",
"(",
"e",
".",
"Values",
")",
")",
"\n",
"for",
"... | // ValuesWithOption returns all values that have the given option set.
// If no single value has the option set, this returns nil. | [
"ValuesWithOption",
"returns",
"all",
"values",
"that",
"have",
"the",
"given",
"option",
"set",
".",
"If",
"no",
"single",
"value",
"has",
"the",
"option",
"set",
"this",
"returns",
"nil",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L287-L298 |
27,046 | pseudomuto/protoc-gen-doc | template.go | MethodOptions | func (s Service) MethodOptions() []string {
optionSet := make(map[string]struct{})
for _, method := range s.Methods {
for option := range method.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {... | go | func (s Service) MethodOptions() []string {
optionSet := make(map[string]struct{})
for _, method := range s.Methods {
for option := range method.Options {
optionSet[option] = struct{}{}
}
}
if len(optionSet) == 0 {
return nil
}
options := make([]string, 0, len(optionSet))
for option := range optionSet {... | [
"func",
"(",
"s",
"Service",
")",
"MethodOptions",
"(",
")",
"[",
"]",
"string",
"{",
"optionSet",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"method",
":=",
"range",
"s",
".",
"Methods",
"{",
"f... | // MethodOptions returns all options that are set on the methods in this service. | [
"MethodOptions",
"returns",
"all",
"options",
"that",
"are",
"set",
"on",
"the",
"methods",
"in",
"this",
"service",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L327-L343 |
27,047 | pseudomuto/protoc-gen-doc | template.go | MethodsWithOption | func (s Service) MethodsWithOption(optionName string) []*ServiceMethod {
methods := make([]*ServiceMethod, 0, len(s.Methods))
for _, method := range s.Methods {
if _, ok := method.Options[optionName]; ok {
methods = append(methods, method)
}
}
if len(methods) > 0 {
return methods
}
return nil
} | go | func (s Service) MethodsWithOption(optionName string) []*ServiceMethod {
methods := make([]*ServiceMethod, 0, len(s.Methods))
for _, method := range s.Methods {
if _, ok := method.Options[optionName]; ok {
methods = append(methods, method)
}
}
if len(methods) > 0 {
return methods
}
return nil
} | [
"func",
"(",
"s",
"Service",
")",
"MethodsWithOption",
"(",
"optionName",
"string",
")",
"[",
"]",
"*",
"ServiceMethod",
"{",
"methods",
":=",
"make",
"(",
"[",
"]",
"*",
"ServiceMethod",
",",
"0",
",",
"len",
"(",
"s",
".",
"Methods",
")",
")",
"\n"... | // MethodsWithOption returns all methods that have the given option set.
// If no single method has the option set, this returns nil. | [
"MethodsWithOption",
"returns",
"all",
"methods",
"that",
"have",
"the",
"given",
"option",
"set",
".",
"If",
"no",
"single",
"method",
"has",
"the",
"option",
"set",
"this",
"returns",
"nil",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/template.go#L347-L358 |
27,048 | pseudomuto/protoc-gen-doc | plugin.go | Generate | func (p *Plugin) Generate(r *plugin_go.CodeGeneratorRequest) (*plugin_go.CodeGeneratorResponse, error) {
options, err := ParseOptions(r)
if err != nil {
return nil, err
}
result := excludeUnwantedProtos(protokit.ParseCodeGenRequest(r), options.ExcludePatterns)
template := NewTemplate(result)
customTemplate :=... | go | func (p *Plugin) Generate(r *plugin_go.CodeGeneratorRequest) (*plugin_go.CodeGeneratorResponse, error) {
options, err := ParseOptions(r)
if err != nil {
return nil, err
}
result := excludeUnwantedProtos(protokit.ParseCodeGenRequest(r), options.ExcludePatterns)
template := NewTemplate(result)
customTemplate :=... | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"Generate",
"(",
"r",
"*",
"plugin_go",
".",
"CodeGeneratorRequest",
")",
"(",
"*",
"plugin_go",
".",
"CodeGeneratorResponse",
",",
"error",
")",
"{",
"options",
",",
"err",
":=",
"ParseOptions",
"(",
"r",
")",
"\n",... | // Generate compiles the documentation and generates the CodeGeneratorResponse to send back to protoc. It does this
// by rendering a template based on the options parsed from the CodeGeneratorRequest. | [
"Generate",
"compiles",
"the",
"documentation",
"and",
"generates",
"the",
"CodeGeneratorResponse",
"to",
"send",
"back",
"to",
"protoc",
".",
"It",
"does",
"this",
"by",
"rendering",
"a",
"template",
"based",
"on",
"the",
"options",
"parsed",
"from",
"the",
"... | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/plugin.go#L29-L61 |
27,049 | pseudomuto/protoc-gen-doc | extensions/extensions.go | Transform | func Transform(extensions map[string]interface{}) map[string]interface{} {
if extensions == nil {
return nil
}
out := make(map[string]interface{}, len(extensions))
for name, payload := range extensions {
transform, ok := transformers[name]
if !ok {
// No transformer registered, skip.
continue
}
tran... | go | func Transform(extensions map[string]interface{}) map[string]interface{} {
if extensions == nil {
return nil
}
out := make(map[string]interface{}, len(extensions))
for name, payload := range extensions {
transform, ok := transformers[name]
if !ok {
// No transformer registered, skip.
continue
}
tran... | [
"func",
"Transform",
"(",
"extensions",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"if",
"extensions",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
... | // Transform the extensions using the registered transformers. | [
"Transform",
"the",
"extensions",
"using",
"the",
"registered",
"transformers",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/extensions/extensions.go#L16-L35 |
27,050 | pseudomuto/protoc-gen-doc | extensions/lyft_validate/lyft_validate.go | Rules | func (v ValidateExtension) Rules() []ValidateRule {
if v.FieldRules == nil {
return nil
}
if v.rules == nil {
v.rules = flattenRules("", reflect.ValueOf(v.FieldRules))
}
return v.rules
} | go | func (v ValidateExtension) Rules() []ValidateRule {
if v.FieldRules == nil {
return nil
}
if v.rules == nil {
v.rules = flattenRules("", reflect.ValueOf(v.FieldRules))
}
return v.rules
} | [
"func",
"(",
"v",
"ValidateExtension",
")",
"Rules",
"(",
")",
"[",
"]",
"ValidateRule",
"{",
"if",
"v",
".",
"FieldRules",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"v",
".",
"rules",
"==",
"nil",
"{",
"v",
".",
"rules",
"=",
"fl... | // Rules returns the set of rules for this extension. | [
"Rules",
"returns",
"the",
"set",
"of",
"rules",
"for",
"this",
"extension",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/extensions/lyft_validate/lyft_validate.go#L28-L36 |
27,051 | pseudomuto/protoc-gen-doc | cmd/protoc-gen-doc/flags.go | PrintHelp | func (f *Flags) PrintHelp() {
fmt.Fprintf(f.writer, "Usage of %s:\n", f.appName)
fmt.Fprintf(f.writer, "%s\n", helpMessage)
fmt.Fprintf(f.writer, "FLAGS\n")
f.flagSet.PrintDefaults()
} | go | func (f *Flags) PrintHelp() {
fmt.Fprintf(f.writer, "Usage of %s:\n", f.appName)
fmt.Fprintf(f.writer, "%s\n", helpMessage)
fmt.Fprintf(f.writer, "FLAGS\n")
f.flagSet.PrintDefaults()
} | [
"func",
"(",
"f",
"*",
"Flags",
")",
"PrintHelp",
"(",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"f",
".",
"writer",
",",
"\"",
"\\n",
"\"",
",",
"f",
".",
"appName",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"f",
".",
"writer",
",",
"\"",
"\\n",
"\... | // PrintHelp prints the usage string including all flags to the `io.Writer` that was supplied to the `Flags` object. | [
"PrintHelp",
"prints",
"the",
"usage",
"string",
"including",
"all",
"flags",
"to",
"the",
"io",
".",
"Writer",
"that",
"was",
"supplied",
"to",
"the",
"Flags",
"object",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/cmd/protoc-gen-doc/flags.go#L68-L73 |
27,052 | pseudomuto/protoc-gen-doc | cmd/protoc-gen-doc/flags.go | PrintVersion | func (f *Flags) PrintVersion() {
fmt.Fprintf(f.writer, "%s version %s\n", f.appName, Version())
} | go | func (f *Flags) PrintVersion() {
fmt.Fprintf(f.writer, "%s version %s\n", f.appName, Version())
} | [
"func",
"(",
"f",
"*",
"Flags",
")",
"PrintVersion",
"(",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"f",
".",
"writer",
",",
"\"",
"\\n",
"\"",
",",
"f",
".",
"appName",
",",
"Version",
"(",
")",
")",
"\n",
"}"
] | // PrintVersion prints the version string to the `io.Writer` that was supplied to the `Flags` object. | [
"PrintVersion",
"prints",
"the",
"version",
"string",
"to",
"the",
"io",
".",
"Writer",
"that",
"was",
"supplied",
"to",
"the",
"Flags",
"object",
"."
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/cmd/protoc-gen-doc/flags.go#L76-L78 |
27,053 | pseudomuto/protoc-gen-doc | extensions/validator_field/validator_field.go | Rules | func (v ValidatorExtension) Rules() []ValidatorRule {
if v.FieldValidator == nil {
return nil
}
if v.rules != nil {
return v.rules
}
vv := reflect.ValueOf(*v.FieldValidator)
vt := vv.Type()
for i := 0; i < vt.NumField(); i++ {
tag, ok := vt.Field(i).Tag.Lookup("protobuf")
if !ok {
continue
}
for _... | go | func (v ValidatorExtension) Rules() []ValidatorRule {
if v.FieldValidator == nil {
return nil
}
if v.rules != nil {
return v.rules
}
vv := reflect.ValueOf(*v.FieldValidator)
vt := vv.Type()
for i := 0; i < vt.NumField(); i++ {
tag, ok := vt.Field(i).Tag.Lookup("protobuf")
if !ok {
continue
}
for _... | [
"func",
"(",
"v",
"ValidatorExtension",
")",
"Rules",
"(",
")",
"[",
"]",
"ValidatorRule",
"{",
"if",
"v",
".",
"FieldValidator",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"v",
".",
"rules",
"!=",
"nil",
"{",
"return",
"v",
".",
"ru... | // Rules returns all active rules | [
"Rules",
"returns",
"all",
"active",
"rules"
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/extensions/validator_field/validator_field.go#L45-L73 |
27,054 | pseudomuto/protoc-gen-doc | cmd/protoc-gen-doc/main.go | HandleFlags | func HandleFlags(f *Flags) bool {
if !f.HasMatch() {
return false
}
if f.ShowHelp() {
f.PrintHelp()
}
if f.ShowVersion() {
f.PrintVersion()
}
return true
} | go | func HandleFlags(f *Flags) bool {
if !f.HasMatch() {
return false
}
if f.ShowHelp() {
f.PrintHelp()
}
if f.ShowVersion() {
f.PrintVersion()
}
return true
} | [
"func",
"HandleFlags",
"(",
"f",
"*",
"Flags",
")",
"bool",
"{",
"if",
"!",
"f",
".",
"HasMatch",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"ShowHelp",
"(",
")",
"{",
"f",
".",
"PrintHelp",
"(",
")",
"\n",
"}",
"\n\n"... | // HandleFlags checks if there's a match and returns true if it was "handled" | [
"HandleFlags",
"checks",
"if",
"there",
"s",
"a",
"match",
"and",
"returns",
"true",
"if",
"it",
"was",
"handled"
] | f824a8908ce33f213b2dba1bf7be83384c5c51e8 | https://github.com/pseudomuto/protoc-gen-doc/blob/f824a8908ce33f213b2dba1bf7be83384c5c51e8/cmd/protoc-gen-doc/main.go#L39-L53 |
27,055 | pressly/sup | ssh.go | initAuthMethod | func initAuthMethod() {
var signers []ssh.Signer
// If there's a running SSH Agent, try to use its Private keys.
sock, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK"))
if err == nil {
agent := agent.NewClient(sock)
signers, _ = agent.Signers()
}
// Try to read user's SSH private keys form the standard pa... | go | func initAuthMethod() {
var signers []ssh.Signer
// If there's a running SSH Agent, try to use its Private keys.
sock, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK"))
if err == nil {
agent := agent.NewClient(sock)
signers, _ = agent.Signers()
}
// Try to read user's SSH private keys form the standard pa... | [
"func",
"initAuthMethod",
"(",
")",
"{",
"var",
"signers",
"[",
"]",
"ssh",
".",
"Signer",
"\n\n",
"// If there's a running SSH Agent, try to use its Private keys.",
"sock",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"\"",
"\"",
",",
"os",
".",
"Getenv",
"(",
... | // initAuthMethod initiates SSH authentication method. | [
"initAuthMethod",
"initiates",
"SSH",
"authentication",
"method",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L83-L111 |
27,056 | pressly/sup | ssh.go | Run | func (c *SSHClient) Run(task *Task) error {
if c.running {
return fmt.Errorf("Session already running")
}
if c.sessOpened {
return fmt.Errorf("Session already connected")
}
sess, err := c.conn.NewSession()
if err != nil {
return err
}
c.remoteStdin, err = sess.StdinPipe()
if err != nil {
return err
... | go | func (c *SSHClient) Run(task *Task) error {
if c.running {
return fmt.Errorf("Session already running")
}
if c.sessOpened {
return fmt.Errorf("Session already connected")
}
sess, err := c.conn.NewSession()
if err != nil {
return err
}
c.remoteStdin, err = sess.StdinPipe()
if err != nil {
return err
... | [
"func",
"(",
"c",
"*",
"SSHClient",
")",
"Run",
"(",
"task",
"*",
"Task",
")",
"error",
"{",
"if",
"c",
".",
"running",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"sessOpened",
"{",
"return",
"fm... | // Run runs the task.Run command remotely on c.host. | [
"Run",
"runs",
"the",
"task",
".",
"Run",
"command",
"remotely",
"on",
"c",
".",
"host",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L154-L204 |
27,057 | pressly/sup | ssh.go | Wait | func (c *SSHClient) Wait() error {
if !c.running {
return fmt.Errorf("Trying to wait on stopped session")
}
err := c.sess.Wait()
c.sess.Close()
c.running = false
c.sessOpened = false
return err
} | go | func (c *SSHClient) Wait() error {
if !c.running {
return fmt.Errorf("Trying to wait on stopped session")
}
err := c.sess.Wait()
c.sess.Close()
c.running = false
c.sessOpened = false
return err
} | [
"func",
"(",
"c",
"*",
"SSHClient",
")",
"Wait",
"(",
")",
"error",
"{",
"if",
"!",
"c",
".",
"running",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"c",
".",
"sess",
".",
"Wait",
"(",
")",
"\n",... | // Wait waits until the remote command finishes and exits.
// It closes the SSH session. | [
"Wait",
"waits",
"until",
"the",
"remote",
"command",
"finishes",
"and",
"exits",
".",
"It",
"closes",
"the",
"SSH",
"session",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L208-L219 |
27,058 | pressly/sup | ssh.go | DialThrough | func (sc *SSHClient) DialThrough(net, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
conn, err := sc.conn.Dial(net, addr)
if err != nil {
return nil, err
}
c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
return ssh.NewClient(c, chans, reqs), nil
... | go | func (sc *SSHClient) DialThrough(net, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
conn, err := sc.conn.Dial(net, addr)
if err != nil {
return nil, err
}
c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
return ssh.NewClient(c, chans, reqs), nil
... | [
"func",
"(",
"sc",
"*",
"SSHClient",
")",
"DialThrough",
"(",
"net",
",",
"addr",
"string",
",",
"config",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"*",
"ssh",
".",
"Client",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"sc",
".",
"conn",
... | // DialThrough will create a new connection from the ssh server sc is connected to. DialThrough is an SSHDialer. | [
"DialThrough",
"will",
"create",
"a",
"new",
"connection",
"from",
"the",
"ssh",
"server",
"sc",
"is",
"connected",
"to",
".",
"DialThrough",
"is",
"an",
"SSHDialer",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L222-L233 |
27,059 | pressly/sup | ssh.go | Close | func (c *SSHClient) Close() error {
if c.sessOpened {
c.sess.Close()
c.sessOpened = false
}
if !c.connOpened {
return fmt.Errorf("Trying to close the already closed connection")
}
err := c.conn.Close()
c.connOpened = false
c.running = false
return err
} | go | func (c *SSHClient) Close() error {
if c.sessOpened {
c.sess.Close()
c.sessOpened = false
}
if !c.connOpened {
return fmt.Errorf("Trying to close the already closed connection")
}
err := c.conn.Close()
c.connOpened = false
c.running = false
return err
} | [
"func",
"(",
"c",
"*",
"SSHClient",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"c",
".",
"sessOpened",
"{",
"c",
".",
"sess",
".",
"Close",
"(",
")",
"\n",
"c",
".",
"sessOpened",
"=",
"false",
"\n",
"}",
"\n",
"if",
"!",
"c",
".",
"connOpened... | // Close closes the underlying SSH connection and session. | [
"Close",
"closes",
"the",
"underlying",
"SSH",
"connection",
"and",
"session",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/ssh.go#L236-L250 |
27,060 | pressly/sup | supfile.go | Set | func (e *EnvList) Set(key, value string) {
for i, v := range *e {
if v.Key == key {
(*e)[i].Value = value
return
}
}
*e = append(*e, &EnvVar{
Key: key,
Value: value,
})
} | go | func (e *EnvList) Set(key, value string) {
for i, v := range *e {
if v.Key == key {
(*e)[i].Value = value
return
}
}
*e = append(*e, &EnvVar{
Key: key,
Value: value,
})
} | [
"func",
"(",
"e",
"*",
"EnvList",
")",
"Set",
"(",
"key",
",",
"value",
"string",
")",
"{",
"for",
"i",
",",
"v",
":=",
"range",
"*",
"e",
"{",
"if",
"v",
".",
"Key",
"==",
"key",
"{",
"(",
"*",
"e",
")",
"[",
"i",
"]",
".",
"Value",
"=",... | // Set key to be equal value in this list. | [
"Set",
"key",
"to",
"be",
"equal",
"value",
"in",
"this",
"list",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/supfile.go#L199-L211 |
27,061 | pressly/sup | supfile.go | NewSupfile | func NewSupfile(data []byte) (*Supfile, error) {
var conf Supfile
if err := yaml.Unmarshal(data, &conf); err != nil {
return nil, err
}
// API backward compatibility. Will be deprecated in v1.0.
switch conf.Version {
case "":
conf.Version = "0.1"
fallthrough
case "0.1":
for _, cmd := range conf.Comman... | go | func NewSupfile(data []byte) (*Supfile, error) {
var conf Supfile
if err := yaml.Unmarshal(data, &conf); err != nil {
return nil, err
}
// API backward compatibility. Will be deprecated in v1.0.
switch conf.Version {
case "":
conf.Version = "0.1"
fallthrough
case "0.1":
for _, cmd := range conf.Comman... | [
"func",
"NewSupfile",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"Supfile",
",",
"error",
")",
"{",
"var",
"conf",
"Supfile",
"\n\n",
"if",
"err",
":=",
"yaml",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"conf",
")",
";",
"err",
"!=",
"nil",
"{"... | // NewSupfile parses configuration file and returns Supfile or error. | [
"NewSupfile",
"parses",
"configuration",
"file",
"and",
"returns",
"Supfile",
"or",
"error",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/supfile.go#L266-L328 |
27,062 | pressly/sup | supfile.go | ParseInventory | func (n Network) ParseInventory() ([]string, error) {
if n.Inventory == "" {
return nil, nil
}
cmd := exec.Command("/bin/sh", "-c", n.Inventory)
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, n.Env.Slice()...)
cmd.Stderr = os.Stderr
output, err := cmd.Output()
if err != nil {
return nil, err
}
var hos... | go | func (n Network) ParseInventory() ([]string, error) {
if n.Inventory == "" {
return nil, nil
}
cmd := exec.Command("/bin/sh", "-c", n.Inventory)
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, n.Env.Slice()...)
cmd.Stderr = os.Stderr
output, err := cmd.Output()
if err != nil {
return nil, err
}
var hos... | [
"func",
"(",
"n",
"Network",
")",
"ParseInventory",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"n",
".",
"Inventory",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command"... | // ParseInventory runs the inventory command, if provided, and appends
// the command's output lines to the manually defined list of hosts. | [
"ParseInventory",
"runs",
"the",
"inventory",
"command",
"if",
"provided",
"and",
"appends",
"the",
"command",
"s",
"output",
"lines",
"to",
"the",
"manually",
"defined",
"list",
"of",
"hosts",
"."
] | be6dff41589b713547415b72660885dd7a045f8f | https://github.com/pressly/sup/blob/be6dff41589b713547415b72660885dd7a045f8f/supfile.go#L332-L366 |
27,063 | bndr/gojenkins | jenkins.go | Info | func (j *Jenkins) Info() (*ExecutorResponse, error) {
_, err := j.Requester.Get("/", j.Raw, nil)
if err != nil {
return nil, err
}
return j.Raw, nil
} | go | func (j *Jenkins) Info() (*ExecutorResponse, error) {
_, err := j.Requester.Get("/", j.Raw, nil)
if err != nil {
return nil, err
}
return j.Raw, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"Info",
"(",
")",
"(",
"*",
"ExecutorResponse",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"Get",
"(",
"\"",
"\"",
",",
"j",
".",
"Raw",
",",
"nil",
")",
"\n\n",
"if",
"er... | // Get Basic Information About Jenkins | [
"Get",
"Basic",
"Information",
"About",
"Jenkins"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L84-L91 |
27,064 | bndr/gojenkins | jenkins.go | SafeRestart | func (j *Jenkins) SafeRestart() error {
_, err := j.Requester.Post("/safeRestart", strings.NewReader(""), struct{}{}, map[string]string{})
return err
} | go | func (j *Jenkins) SafeRestart() error {
_, err := j.Requester.Post("/safeRestart", strings.NewReader(""), struct{}{}, map[string]string{})
return err
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"SafeRestart",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"Post",
"(",
"\"",
"\"",
",",
"strings",
".",
"NewReader",
"(",
"\"",
"\"",
")",
",",
"struct",
"{",
"}",
"{",
"}",... | // SafeRestart jenkins, restart will be done when there are no jobs running | [
"SafeRestart",
"jenkins",
"restart",
"will",
"be",
"done",
"when",
"there",
"are",
"no",
"jobs",
"running"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L94-L97 |
27,065 | bndr/gojenkins | jenkins.go | DeleteNode | func (j *Jenkins) DeleteNode(name string) (bool, error) {
node := Node{Jenkins: j, Raw: new(NodeResponse), Base: "/computer/" + name}
return node.Delete()
} | go | func (j *Jenkins) DeleteNode(name string) (bool, error) {
node := Node{Jenkins: j, Raw: new(NodeResponse), Base: "/computer/" + name}
return node.Delete()
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"DeleteNode",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"node",
":=",
"Node",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"NodeResponse",
")",
",",
"Base",
":",
"\"",
"\"",
... | // Delete a Jenkins slave node | [
"Delete",
"a",
"Jenkins",
"slave",
"node"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L179-L182 |
27,066 | bndr/gojenkins | jenkins.go | RenameJob | func (j *Jenkins) RenameJob(job string, name string) *Job {
jobObj := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + job}
jobObj.Rename(name)
return &jobObj
} | go | func (j *Jenkins) RenameJob(job string, name string) *Job {
jobObj := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + job}
jobObj.Rename(name)
return &jobObj
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"RenameJob",
"(",
"job",
"string",
",",
"name",
"string",
")",
"*",
"Job",
"{",
"jobObj",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResponse",
")",
",",
"Base",
":",
"\"",
"\"",... | // Rename a job.
// First parameter job old name, Second parameter job new name. | [
"Rename",
"a",
"job",
".",
"First",
"parameter",
"job",
"old",
"name",
"Second",
"parameter",
"job",
"new",
"name",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L231-L235 |
27,067 | bndr/gojenkins | jenkins.go | CopyJob | func (j *Jenkins) CopyJob(copyFrom string, newName string) (*Job, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + copyFrom}
_, err := job.Poll()
if err != nil {
return nil, err
}
return job.Copy(newName)
} | go | func (j *Jenkins) CopyJob(copyFrom string, newName string) (*Job, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + copyFrom}
_, err := job.Poll()
if err != nil {
return nil, err
}
return job.Copy(newName)
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"CopyJob",
"(",
"copyFrom",
"string",
",",
"newName",
"string",
")",
"(",
"*",
"Job",
",",
"error",
")",
"{",
"job",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResponse",
")",
",... | // Create a copy of a job.
// First parameter Name of the job to copy from, Second parameter new job name. | [
"Create",
"a",
"copy",
"of",
"a",
"job",
".",
"First",
"parameter",
"Name",
"of",
"the",
"job",
"to",
"copy",
"from",
"Second",
"parameter",
"new",
"job",
"name",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L239-L246 |
27,068 | bndr/gojenkins | jenkins.go | DeleteJob | func (j *Jenkins) DeleteJob(name string) (bool, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
return job.Delete()
} | go | func (j *Jenkins) DeleteJob(name string) (bool, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
return job.Delete()
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"DeleteJob",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"job",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResponse",
")",
",",
"Base",
":",
"\"",
"\"",
"+... | // Delete a job. | [
"Delete",
"a",
"job",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L249-L252 |
27,069 | bndr/gojenkins | jenkins.go | BuildJob | func (j *Jenkins) BuildJob(name string, options ...interface{}) (int64, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
var params map[string]string
if len(options) > 0 {
params, _ = options[0].(map[string]string)
}
return job.InvokeSimple(params)
} | go | func (j *Jenkins) BuildJob(name string, options ...interface{}) (int64, error) {
job := Job{Jenkins: j, Raw: new(JobResponse), Base: "/job/" + name}
var params map[string]string
if len(options) > 0 {
params, _ = options[0].(map[string]string)
}
return job.InvokeSimple(params)
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"BuildJob",
"(",
"name",
"string",
",",
"options",
"...",
"interface",
"{",
"}",
")",
"(",
"int64",
",",
"error",
")",
"{",
"job",
":=",
"Job",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"JobResp... | // Invoke a job.
// First parameter job name, second parameter is optional Build parameters. | [
"Invoke",
"a",
"job",
".",
"First",
"parameter",
"job",
"name",
"second",
"parameter",
"is",
"optional",
"Build",
"parameters",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L256-L263 |
27,070 | bndr/gojenkins | jenkins.go | GetAllJobNames | func (j *Jenkins) GetAllJobNames() ([]InnerJob, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
return exec.Raw.Jobs, nil
} | go | func (j *Jenkins) GetAllJobNames() ([]InnerJob, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
return exec.Raw.Jobs, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetAllJobNames",
"(",
")",
"(",
"[",
"]",
"InnerJob",
",",
"error",
")",
"{",
"exec",
":=",
"Executor",
"{",
"Raw",
":",
"new",
"(",
"ExecutorResponse",
")",
",",
"Jenkins",
":",
"j",
"}",
"\n",
"_",
",",
"... | // Get Only Array of Job Names, Color, URL
// Does not query each single Job. | [
"Get",
"Only",
"Array",
"of",
"Job",
"Names",
"Color",
"URL",
"Does",
"not",
"query",
"each",
"single",
"Job",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L372-L381 |
27,071 | bndr/gojenkins | jenkins.go | GetAllJobs | func (j *Jenkins) GetAllJobs() ([]*Job, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
jobs := make([]*Job, len(exec.Raw.Jobs))
for i, job := range exec.Raw.Jobs {
ji, err := j.GetJob(job.Name)
if err !=... | go | func (j *Jenkins) GetAllJobs() ([]*Job, error) {
exec := Executor{Raw: new(ExecutorResponse), Jenkins: j}
_, err := j.Requester.GetJSON("/", exec.Raw, nil)
if err != nil {
return nil, err
}
jobs := make([]*Job, len(exec.Raw.Jobs))
for i, job := range exec.Raw.Jobs {
ji, err := j.GetJob(job.Name)
if err !=... | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetAllJobs",
"(",
")",
"(",
"[",
"]",
"*",
"Job",
",",
"error",
")",
"{",
"exec",
":=",
"Executor",
"{",
"Raw",
":",
"new",
"(",
"ExecutorResponse",
")",
",",
"Jenkins",
":",
"j",
"}",
"\n",
"_",
",",
"er... | // Get All Possible Job Objects.
// Each job will be queried. | [
"Get",
"All",
"Possible",
"Job",
"Objects",
".",
"Each",
"job",
"will",
"be",
"queried",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L385-L402 |
27,072 | bndr/gojenkins | jenkins.go | GetQueue | func (j *Jenkins) GetQueue() (*Queue, error) {
q := &Queue{Jenkins: j, Raw: new(queueResponse), Base: j.GetQueueUrl()}
_, err := q.Poll()
if err != nil {
return nil, err
}
return q, nil
} | go | func (j *Jenkins) GetQueue() (*Queue, error) {
q := &Queue{Jenkins: j, Raw: new(queueResponse), Base: j.GetQueueUrl()}
_, err := q.Poll()
if err != nil {
return nil, err
}
return q, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetQueue",
"(",
")",
"(",
"*",
"Queue",
",",
"error",
")",
"{",
"q",
":=",
"&",
"Queue",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"queueResponse",
")",
",",
"Base",
":",
"j",
".",
"GetQueueU... | // Returns a Queue | [
"Returns",
"a",
"Queue"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L405-L412 |
27,073 | bndr/gojenkins | jenkins.go | GetQueueItem | func (j *Jenkins) GetQueueItem(id int64) (*Task, error) {
t := &Task{Raw: new(taskResponse), Jenkins: j, Base: j.getQueueItemURL(id)}
_, err := t.Poll()
if err != nil {
return nil, err
}
return t, nil
} | go | func (j *Jenkins) GetQueueItem(id int64) (*Task, error) {
t := &Task{Raw: new(taskResponse), Jenkins: j, Base: j.getQueueItemURL(id)}
_, err := t.Poll()
if err != nil {
return nil, err
}
return t, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetQueueItem",
"(",
"id",
"int64",
")",
"(",
"*",
"Task",
",",
"error",
")",
"{",
"t",
":=",
"&",
"Task",
"{",
"Raw",
":",
"new",
"(",
"taskResponse",
")",
",",
"Jenkins",
":",
"j",
",",
"Base",
":",
"j",... | // GetQueueItem returns a single queue Task | [
"GetQueueItem",
"returns",
"a",
"single",
"queue",
"Task"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L419-L426 |
27,074 | bndr/gojenkins | jenkins.go | GetArtifactData | func (j *Jenkins) GetArtifactData(id string) (*FingerPrintResponse, error) {
fp := FingerPrint{Jenkins: j, Base: "/fingerprint/", Id: id, Raw: new(FingerPrintResponse)}
return fp.GetInfo()
} | go | func (j *Jenkins) GetArtifactData(id string) (*FingerPrintResponse, error) {
fp := FingerPrint{Jenkins: j, Base: "/fingerprint/", Id: id, Raw: new(FingerPrintResponse)}
return fp.GetInfo()
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetArtifactData",
"(",
"id",
"string",
")",
"(",
"*",
"FingerPrintResponse",
",",
"error",
")",
"{",
"fp",
":=",
"FingerPrint",
"{",
"Jenkins",
":",
"j",
",",
"Base",
":",
"\"",
"\"",
",",
"Id",
":",
"id",
",... | // Get Artifact data by Hash | [
"Get",
"Artifact",
"data",
"by",
"Hash"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L433-L436 |
27,075 | bndr/gojenkins | jenkins.go | GetPlugins | func (j *Jenkins) GetPlugins(depth int) (*Plugins, error) {
p := Plugins{Jenkins: j, Raw: new(PluginResponse), Base: "/pluginManager", Depth: depth}
_, err := p.Poll()
if err != nil {
return nil, err
}
return &p, nil
} | go | func (j *Jenkins) GetPlugins(depth int) (*Plugins, error) {
p := Plugins{Jenkins: j, Raw: new(PluginResponse), Base: "/pluginManager", Depth: depth}
_, err := p.Poll()
if err != nil {
return nil, err
}
return &p, nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"GetPlugins",
"(",
"depth",
"int",
")",
"(",
"*",
"Plugins",
",",
"error",
")",
"{",
"p",
":=",
"Plugins",
"{",
"Jenkins",
":",
"j",
",",
"Raw",
":",
"new",
"(",
"PluginResponse",
")",
",",
"Base",
":",
"\""... | // Returns the list of all plugins installed on the Jenkins server.
// You can supply depth parameter, to limit how much data is returned. | [
"Returns",
"the",
"list",
"of",
"all",
"plugins",
"installed",
"on",
"the",
"Jenkins",
"server",
".",
"You",
"can",
"supply",
"depth",
"parameter",
"to",
"limit",
"how",
"much",
"data",
"is",
"returned",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L440-L447 |
27,076 | bndr/gojenkins | jenkins.go | UninstallPlugin | func (j *Jenkins) UninstallPlugin(name string) error {
url := fmt.Sprintf("/pluginManager/plugin/%s/doUninstall", name)
resp, err := j.Requester.Post(url, strings.NewReader(""), struct{}{}, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid status code returned: %d", resp.StatusCode)
}
r... | go | func (j *Jenkins) UninstallPlugin(name string) error {
url := fmt.Sprintf("/pluginManager/plugin/%s/doUninstall", name)
resp, err := j.Requester.Post(url, strings.NewReader(""), struct{}{}, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid status code returned: %d", resp.StatusCode)
}
r... | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"UninstallPlugin",
"(",
"name",
"string",
")",
"error",
"{",
"url",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"resp",
",",
"err",
":=",
"j",
".",
"Requester",
".",
"Post",
"(",
"u... | // UninstallPlugin plugin otherwise returns error | [
"UninstallPlugin",
"plugin",
"otherwise",
"returns",
"error"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L450-L457 |
27,077 | bndr/gojenkins | jenkins.go | HasPlugin | func (j *Jenkins) HasPlugin(name string) (*Plugin, error) {
p, err := j.GetPlugins(1)
if err != nil {
return nil, err
}
return p.Contains(name), nil
} | go | func (j *Jenkins) HasPlugin(name string) (*Plugin, error) {
p, err := j.GetPlugins(1)
if err != nil {
return nil, err
}
return p.Contains(name), nil
} | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"HasPlugin",
"(",
"name",
"string",
")",
"(",
"*",
"Plugin",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"j",
".",
"GetPlugins",
"(",
"1",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",... | // Check if the plugin is installed on the server.
// Depth level 1 is used. If you need to go deeper, you can use GetPlugins, and iterate through them. | [
"Check",
"if",
"the",
"plugin",
"is",
"installed",
"on",
"the",
"server",
".",
"Depth",
"level",
"1",
"is",
"used",
".",
"If",
"you",
"need",
"to",
"go",
"deeper",
"you",
"can",
"use",
"GetPlugins",
"and",
"iterate",
"through",
"them",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L461-L468 |
27,078 | bndr/gojenkins | jenkins.go | InstallPlugin | func (j *Jenkins) InstallPlugin(name string, version string) error {
xml := fmt.Sprintf(`<jenkins><install plugin="%s@%s" /></jenkins>`, name, version)
resp, err := j.Requester.PostXML("/pluginManager/installNecessaryPlugins", xml, j.Raw, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid... | go | func (j *Jenkins) InstallPlugin(name string, version string) error {
xml := fmt.Sprintf(`<jenkins><install plugin="%s@%s" /></jenkins>`, name, version)
resp, err := j.Requester.PostXML("/pluginManager/installNecessaryPlugins", xml, j.Raw, map[string]string{})
if resp.StatusCode != 200 {
return fmt.Errorf("Invalid... | [
"func",
"(",
"j",
"*",
"Jenkins",
")",
"InstallPlugin",
"(",
"name",
"string",
",",
"version",
"string",
")",
"error",
"{",
"xml",
":=",
"fmt",
".",
"Sprintf",
"(",
"`<jenkins><install plugin=\"%s@%s\" /></jenkins>`",
",",
"name",
",",
"version",
")",
"\n",
... | //InstallPlugin with given version and name | [
"InstallPlugin",
"with",
"given",
"version",
"and",
"name"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/jenkins.go#L471-L479 |
27,079 | bndr/gojenkins | credentials.go | List | func (cm CredentialsManager) List(domain string) ([]string, error) {
idsResponse := credentialIDs{}
ids := make([]string, 0)
err := cm.handleResponse(cm.J.Requester.Get(cm.fillURL(credentialsListURL, domain), &idsResponse, listQuery))
if err != nil {
return ids, err
}
for _, id := range idsResponse.Credential... | go | func (cm CredentialsManager) List(domain string) ([]string, error) {
idsResponse := credentialIDs{}
ids := make([]string, 0)
err := cm.handleResponse(cm.J.Requester.Get(cm.fillURL(credentialsListURL, domain), &idsResponse, listQuery))
if err != nil {
return ids, err
}
for _, id := range idsResponse.Credential... | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"List",
"(",
"domain",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"idsResponse",
":=",
"credentialIDs",
"{",
"}",
"\n",
"ids",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
... | //List ids if credentials stored inside provided domain | [
"List",
"ids",
"if",
"credentials",
"stored",
"inside",
"provided",
"domain"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L110-L124 |
27,080 | bndr/gojenkins | credentials.go | Add | func (cm CredentialsManager) Add(domain string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(createCredentialsURL, domain), creds)
} | go | func (cm CredentialsManager) Add(domain string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(createCredentialsURL, domain), creds)
} | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"Add",
"(",
"domain",
"string",
",",
"creds",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"cm",
".",
"postCredsXML",
"(",
"cm",
".",
"fillURL",
"(",
"createCredentialsURL",
",",
"domain",
")",
",",
"c... | //Add credential to given domain, creds must be struct which is parsable to xml | [
"Add",
"credential",
"to",
"given",
"domain",
"creds",
"must",
"be",
"struct",
"which",
"is",
"parsable",
"to",
"xml"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L139-L141 |
27,081 | bndr/gojenkins | credentials.go | Delete | func (cm CredentialsManager) Delete(domain string, id string) error {
return cm.handleResponse(cm.J.Requester.Post(cm.fillURL(deleteCredentialURL, domain, id), nil, cm.J.Raw, map[string]string{}))
} | go | func (cm CredentialsManager) Delete(domain string, id string) error {
return cm.handleResponse(cm.J.Requester.Post(cm.fillURL(deleteCredentialURL, domain, id), nil, cm.J.Raw, map[string]string{}))
} | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"Delete",
"(",
"domain",
"string",
",",
"id",
"string",
")",
"error",
"{",
"return",
"cm",
".",
"handleResponse",
"(",
"cm",
".",
"J",
".",
"Requester",
".",
"Post",
"(",
"cm",
".",
"fillURL",
"(",
"deleteC... | //Delete credential in given domain with given id | [
"Delete",
"credential",
"in",
"given",
"domain",
"with",
"given",
"id"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L144-L146 |
27,082 | bndr/gojenkins | credentials.go | Update | func (cm CredentialsManager) Update(domain string, id string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(configCredentialURL, domain, id), creds)
} | go | func (cm CredentialsManager) Update(domain string, id string, creds interface{}) error {
return cm.postCredsXML(cm.fillURL(configCredentialURL, domain, id), creds)
} | [
"func",
"(",
"cm",
"CredentialsManager",
")",
"Update",
"(",
"domain",
"string",
",",
"id",
"string",
",",
"creds",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"cm",
".",
"postCredsXML",
"(",
"cm",
".",
"fillURL",
"(",
"configCredentialURL",
",",
... | //Update credential in given domain with given id, creds must be pointer to struct which is parsable to xml | [
"Update",
"credential",
"in",
"given",
"domain",
"with",
"given",
"id",
"creds",
"must",
"be",
"pointer",
"to",
"struct",
"which",
"is",
"parsable",
"to",
"xml"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/credentials.go#L149-L151 |
27,083 | bndr/gojenkins | request.go | redirectPolicyFunc | func (r *Requester) redirectPolicyFunc(req *http.Request, via []*http.Request) error {
if r.BasicAuth != nil {
req.SetBasicAuth(r.BasicAuth.Username, r.BasicAuth.Password)
}
return nil
} | go | func (r *Requester) redirectPolicyFunc(req *http.Request, via []*http.Request) error {
if r.BasicAuth != nil {
req.SetBasicAuth(r.BasicAuth.Username, r.BasicAuth.Password)
}
return nil
} | [
"func",
"(",
"r",
"*",
"Requester",
")",
"redirectPolicyFunc",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"via",
"[",
"]",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"if",
"r",
".",
"BasicAuth",
"!=",
"nil",
"{",
"req",
".",
"SetBasicAuth",
... | //Add auth on redirect if required. | [
"Add",
"auth",
"on",
"redirect",
"if",
"required",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/request.go#L138-L143 |
27,084 | bndr/gojenkins | artifact.go | GetData | func (a Artifact) GetData() ([]byte, error) {
var data string
response, err := a.Jenkins.Requester.Get(a.Path, &data, nil)
if err != nil {
return nil, err
}
code := response.StatusCode
if code != 200 {
Error.Printf("Jenkins responded with StatusCode: %d", code)
return nil, errors.New("Could not get File C... | go | func (a Artifact) GetData() ([]byte, error) {
var data string
response, err := a.Jenkins.Requester.Get(a.Path, &data, nil)
if err != nil {
return nil, err
}
code := response.StatusCode
if code != 200 {
Error.Printf("Jenkins responded with StatusCode: %d", code)
return nil, errors.New("Could not get File C... | [
"func",
"(",
"a",
"Artifact",
")",
"GetData",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"data",
"string",
"\n",
"response",
",",
"err",
":=",
"a",
".",
"Jenkins",
".",
"Requester",
".",
"Get",
"(",
"a",
".",
"Path",
",",
"... | // Get raw byte data of Artifact | [
"Get",
"raw",
"byte",
"data",
"of",
"Artifact"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/artifact.go#L36-L50 |
27,085 | bndr/gojenkins | artifact.go | Save | func (a Artifact) Save(path string) (bool, error) {
data, err := a.GetData()
if err != nil {
return false, errors.New("No Data received, not saving file.")
}
if _, err = os.Stat(path); err == nil {
Warning.Println("Local Copy already exists, Overwriting...")
}
err = ioutil.WriteFile(path, data, 0644)
a.va... | go | func (a Artifact) Save(path string) (bool, error) {
data, err := a.GetData()
if err != nil {
return false, errors.New("No Data received, not saving file.")
}
if _, err = os.Stat(path); err == nil {
Warning.Println("Local Copy already exists, Overwriting...")
}
err = ioutil.WriteFile(path, data, 0644)
a.va... | [
"func",
"(",
"a",
"Artifact",
")",
"Save",
"(",
"path",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"a",
".",
"GetData",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"errors",
".",
"... | // Save artifact to a specific path, using your own filename. | [
"Save",
"artifact",
"to",
"a",
"specific",
"path",
"using",
"your",
"own",
"filename",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/artifact.go#L53-L71 |
27,086 | bndr/gojenkins | artifact.go | SaveToDir | func (a Artifact) SaveToDir(dir string) (bool, error) {
if _, err := os.Stat(dir); err != nil {
Error.Printf("can't save artifact: directory %s does not exist", dir)
return false, fmt.Errorf("can't save artifact: directory %s does not exist", dir)
}
saved, err := a.Save(path.Join(dir, a.FileName))
if err != nil... | go | func (a Artifact) SaveToDir(dir string) (bool, error) {
if _, err := os.Stat(dir); err != nil {
Error.Printf("can't save artifact: directory %s does not exist", dir)
return false, fmt.Errorf("can't save artifact: directory %s does not exist", dir)
}
saved, err := a.Save(path.Join(dir, a.FileName))
if err != nil... | [
"func",
"(",
"a",
"Artifact",
")",
"SaveToDir",
"(",
"dir",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
";",
"err",
"!=",
"nil",
"{",
"Error",
".",
"Printf",
"(",
"\"",
... | // Save Artifact to directory using Artifact filename. | [
"Save",
"Artifact",
"to",
"directory",
"using",
"Artifact",
"filename",
"."
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/artifact.go#L74-L84 |
27,087 | bndr/gojenkins | artifact.go | validateDownload | func (a Artifact) validateDownload(path string) (bool, error) {
localHash := a.getMD5local(path)
fp := FingerPrint{Jenkins: a.Jenkins, Base: "/fingerprint/", Id: localHash, Raw: new(FingerPrintResponse)}
valid, err := fp.ValidateForBuild(a.FileName, a.Build)
if err != nil {
return false, err
}
if !valid {
... | go | func (a Artifact) validateDownload(path string) (bool, error) {
localHash := a.getMD5local(path)
fp := FingerPrint{Jenkins: a.Jenkins, Base: "/fingerprint/", Id: localHash, Raw: new(FingerPrintResponse)}
valid, err := fp.ValidateForBuild(a.FileName, a.Build)
if err != nil {
return false, err
}
if !valid {
... | [
"func",
"(",
"a",
"Artifact",
")",
"validateDownload",
"(",
"path",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"localHash",
":=",
"a",
".",
"getMD5local",
"(",
"path",
")",
"\n\n",
"fp",
":=",
"FingerPrint",
"{",
"Jenkins",
":",
"a",
".",
"J... | // Compare Remote and local MD5 | [
"Compare",
"Remote",
"and",
"local",
"MD5"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/artifact.go#L87-L101 |
27,088 | bndr/gojenkins | artifact.go | getMD5local | func (a Artifact) getMD5local(path string) string {
h := md5.New()
localFile, err := os.Open(path)
if err != nil {
return ""
}
buffer := make([]byte, 2^20)
n, err := localFile.Read(buffer)
defer localFile.Close()
for err == nil {
io.WriteString(h, string(buffer[0:n]))
n, err = localFile.Read(buffer)
}
r... | go | func (a Artifact) getMD5local(path string) string {
h := md5.New()
localFile, err := os.Open(path)
if err != nil {
return ""
}
buffer := make([]byte, 2^20)
n, err := localFile.Read(buffer)
defer localFile.Close()
for err == nil {
io.WriteString(h, string(buffer[0:n]))
n, err = localFile.Read(buffer)
}
r... | [
"func",
"(",
"a",
"Artifact",
")",
"getMD5local",
"(",
"path",
"string",
")",
"string",
"{",
"h",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"localFile",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // Get Local MD5 | [
"Get",
"Local",
"MD5"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/artifact.go#L104-L118 |
27,089 | bndr/gojenkins | job.go | GetAllBuildIds | func (j *Job) GetAllBuildIds() ([]JobBuild, error) {
var buildsResp struct {
Builds []JobBuild `json:"allBuilds"`
}
_, err := j.Jenkins.Requester.GetJSON(j.Base, &buildsResp, map[string]string{"tree": "allBuilds[number,url]"})
if err != nil {
return nil, err
}
return buildsResp.Builds, nil
} | go | func (j *Job) GetAllBuildIds() ([]JobBuild, error) {
var buildsResp struct {
Builds []JobBuild `json:"allBuilds"`
}
_, err := j.Jenkins.Requester.GetJSON(j.Base, &buildsResp, map[string]string{"tree": "allBuilds[number,url]"})
if err != nil {
return nil, err
}
return buildsResp.Builds, nil
} | [
"func",
"(",
"j",
"*",
"Job",
")",
"GetAllBuildIds",
"(",
")",
"(",
"[",
"]",
"JobBuild",
",",
"error",
")",
"{",
"var",
"buildsResp",
"struct",
"{",
"Builds",
"[",
"]",
"JobBuild",
"`json:\"allBuilds\"`",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"j",... | // Returns All Builds with Number and URL | [
"Returns",
"All",
"Builds",
"with",
"Number",
"and",
"URL"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/job.go#L192-L201 |
27,090 | bndr/gojenkins | pipeline.go | update | func (run *PipelineRun) update() {
href := run.URLs["self"]["href"]
if matches := baseURLRegex.FindStringSubmatch(href); len(matches) > 1 {
run.Base = matches[1]
}
for i := range run.Stages {
run.Stages[i].Run = run
href := run.Stages[i].URLs["self"]["href"]
if matches := baseURLRegex.FindStringSubmatch(hre... | go | func (run *PipelineRun) update() {
href := run.URLs["self"]["href"]
if matches := baseURLRegex.FindStringSubmatch(href); len(matches) > 1 {
run.Base = matches[1]
}
for i := range run.Stages {
run.Stages[i].Run = run
href := run.Stages[i].URLs["self"]["href"]
if matches := baseURLRegex.FindStringSubmatch(hre... | [
"func",
"(",
"run",
"*",
"PipelineRun",
")",
"update",
"(",
")",
"{",
"href",
":=",
"run",
".",
"URLs",
"[",
"\"",
"\"",
"]",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"matches",
":=",
"baseURLRegex",
".",
"FindStringSubmatch",
"(",
"href",
")",
";",
"len"... | // utility function to fill in the Base fields under PipelineRun | [
"utility",
"function",
"to",
"fill",
"in",
"the",
"Base",
"fields",
"under",
"PipelineRun"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/pipeline.go#L86-L98 |
27,091 | bndr/gojenkins | views.go | AddJob | func (v *View) AddJob(name string) (bool, error) {
url := "/addJobToView"
qr := map[string]string{"name": name}
resp, err := v.Jenkins.Requester.Post(v.Base+url, nil, nil, qr)
if err != nil {
return false, err
}
if resp.StatusCode == 200 {
return true, nil
}
return false, errors.New(strconv.Itoa(resp.Status... | go | func (v *View) AddJob(name string) (bool, error) {
url := "/addJobToView"
qr := map[string]string{"name": name}
resp, err := v.Jenkins.Requester.Post(v.Base+url, nil, nil, qr)
if err != nil {
return false, err
}
if resp.StatusCode == 200 {
return true, nil
}
return false, errors.New(strconv.Itoa(resp.Status... | [
"func",
"(",
"v",
"*",
"View",
")",
"AddJob",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"url",
":=",
"\"",
"\"",
"\n",
"qr",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"name",
"}",
"\n",
"resp",
",... | // Returns True if successfully added Job, otherwise false | [
"Returns",
"True",
"if",
"successfully",
"added",
"Job",
"otherwise",
"false"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/views.go#L45-L56 |
27,092 | bndr/gojenkins | build_history.go | parseBuildHistory | func parseBuildHistory(d io.Reader) []*History {
z := html.NewTokenizer(d)
depth := 0
buildRowCellDepth := -1
builds := make([]*History, 0)
isInsideDisplayName := false
var curBuild *History
for {
tt := z.Next()
switch tt {
case html.ErrorToken:
if z.Err() == io.EOF {
return builds
}
case html.... | go | func parseBuildHistory(d io.Reader) []*History {
z := html.NewTokenizer(d)
depth := 0
buildRowCellDepth := -1
builds := make([]*History, 0)
isInsideDisplayName := false
var curBuild *History
for {
tt := z.Next()
switch tt {
case html.ErrorToken:
if z.Err() == io.EOF {
return builds
}
case html.... | [
"func",
"parseBuildHistory",
"(",
"d",
"io",
".",
"Reader",
")",
"[",
"]",
"*",
"History",
"{",
"z",
":=",
"html",
".",
"NewTokenizer",
"(",
"d",
")",
"\n",
"depth",
":=",
"0",
"\n",
"buildRowCellDepth",
":=",
"-",
"1",
"\n",
"builds",
":=",
"make",
... | // Parse jenkins ajax response in order find the current jenkins build history | [
"Parse",
"jenkins",
"ajax",
"response",
"in",
"order",
"find",
"the",
"current",
"jenkins",
"build",
"history"
] | de43c03cf849dd63a9737df6e05791c7a176c93d | https://github.com/bndr/gojenkins/blob/de43c03cf849dd63a9737df6e05791c7a176c93d/build_history.go#L12-L91 |
27,093 | jlaffaye/ftp | scanner.go | NextFields | func (s *scanner) NextFields(count int) []string {
fields := make([]string, 0, count)
for i := 0; i < count; i++ {
if field := s.Next(); field != "" {
fields = append(fields, field)
} else {
break
}
}
return fields
} | go | func (s *scanner) NextFields(count int) []string {
fields := make([]string, 0, count)
for i := 0; i < count; i++ {
if field := s.Next(); field != "" {
fields = append(fields, field)
} else {
break
}
}
return fields
} | [
"func",
"(",
"s",
"*",
"scanner",
")",
"NextFields",
"(",
"count",
"int",
")",
"[",
"]",
"string",
"{",
"fields",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"count",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"count",
";",
"i... | // NextFields returns the next `count` fields | [
"NextFields",
"returns",
"the",
"next",
"count",
"fields"
] | 6a014d5e22e6a0b7c1fcb65f59872e4dd1227111 | https://github.com/jlaffaye/ftp/blob/6a014d5e22e6a0b7c1fcb65f59872e4dd1227111/scanner.go#L17-L27 |
27,094 | jlaffaye/ftp | scanner.go | Next | func (s *scanner) Next() string {
sLen := len(s.bytes)
// skip trailing whitespace
for s.position < sLen {
if s.bytes[s.position] != ' ' {
break
}
s.position++
}
start := s.position
// skip non-whitespace
for s.position < sLen {
if s.bytes[s.position] == ' ' {
s.position++
return string(s.byt... | go | func (s *scanner) Next() string {
sLen := len(s.bytes)
// skip trailing whitespace
for s.position < sLen {
if s.bytes[s.position] != ' ' {
break
}
s.position++
}
start := s.position
// skip non-whitespace
for s.position < sLen {
if s.bytes[s.position] == ' ' {
s.position++
return string(s.byt... | [
"func",
"(",
"s",
"*",
"scanner",
")",
"Next",
"(",
")",
"string",
"{",
"sLen",
":=",
"len",
"(",
"s",
".",
"bytes",
")",
"\n\n",
"// skip trailing whitespace",
"for",
"s",
".",
"position",
"<",
"sLen",
"{",
"if",
"s",
".",
"bytes",
"[",
"s",
".",
... | // Next returns the next field | [
"Next",
"returns",
"the",
"next",
"field"
] | 6a014d5e22e6a0b7c1fcb65f59872e4dd1227111 | https://github.com/jlaffaye/ftp/blob/6a014d5e22e6a0b7c1fcb65f59872e4dd1227111/scanner.go#L30-L53 |
27,095 | jlaffaye/ftp | scanner.go | Remaining | func (s *scanner) Remaining() string {
return string(s.bytes[s.position:len(s.bytes)])
} | go | func (s *scanner) Remaining() string {
return string(s.bytes[s.position:len(s.bytes)])
} | [
"func",
"(",
"s",
"*",
"scanner",
")",
"Remaining",
"(",
")",
"string",
"{",
"return",
"string",
"(",
"s",
".",
"bytes",
"[",
"s",
".",
"position",
":",
"len",
"(",
"s",
".",
"bytes",
")",
"]",
")",
"\n",
"}"
] | // Remaining returns the remaining string | [
"Remaining",
"returns",
"the",
"remaining",
"string"
] | 6a014d5e22e6a0b7c1fcb65f59872e4dd1227111 | https://github.com/jlaffaye/ftp/blob/6a014d5e22e6a0b7c1fcb65f59872e4dd1227111/scanner.go#L56-L58 |
27,096 | jlaffaye/ftp | ftp.go | Dial | func Dial(addr string, options ...DialOption) (*ServerConn, error) {
do := &dialOptions{}
for _, option := range options {
option.setup(do)
}
if do.location == nil {
do.location = time.UTC
}
tconn := do.conn
if tconn == nil {
var err error
if do.dialFunc != nil {
tconn, err = do.dialFunc("tcp", add... | go | func Dial(addr string, options ...DialOption) (*ServerConn, error) {
do := &dialOptions{}
for _, option := range options {
option.setup(do)
}
if do.location == nil {
do.location = time.UTC
}
tconn := do.conn
if tconn == nil {
var err error
if do.dialFunc != nil {
tconn, err = do.dialFunc("tcp", add... | [
"func",
"Dial",
"(",
"addr",
"string",
",",
"options",
"...",
"DialOption",
")",
"(",
"*",
"ServerConn",
",",
"error",
")",
"{",
"do",
":=",
"&",
"dialOptions",
"{",
"}",
"\n",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"option",
".",
... | // Dial connects to the specified address with optinal options | [
"Dial",
"connects",
"to",
"the",
"specified",
"address",
"with",
"optinal",
"options"
] | 6a014d5e22e6a0b7c1fcb65f59872e4dd1227111 | https://github.com/jlaffaye/ftp/blob/6a014d5e22e6a0b7c1fcb65f59872e4dd1227111/ftp.go#L76-L140 |
27,097 | jlaffaye/ftp | ftp.go | DialWithTimeout | func DialWithTimeout(timeout time.Duration) DialOption {
return DialOption{func(do *dialOptions) {
do.dialer.Timeout = timeout
}}
} | go | func DialWithTimeout(timeout time.Duration) DialOption {
return DialOption{func(do *dialOptions) {
do.dialer.Timeout = timeout
}}
} | [
"func",
"DialWithTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"DialOption",
"{",
"return",
"DialOption",
"{",
"func",
"(",
"do",
"*",
"dialOptions",
")",
"{",
"do",
".",
"dialer",
".",
"Timeout",
"=",
"timeout",
"\n",
"}",
"}",
"\n",
"}"
] | // DialWithTimeout returns a DialOption that configures the ServerConn with specified timeout | [
"DialWithTimeout",
"returns",
"a",
"DialOption",
"that",
"configures",
"the",
"ServerConn",
"with",
"specified",
"timeout"
] | 6a014d5e22e6a0b7c1fcb65f59872e4dd1227111 | https://github.com/jlaffaye/ftp/blob/6a014d5e22e6a0b7c1fcb65f59872e4dd1227111/ftp.go#L143-L147 |
27,098 | jlaffaye/ftp | ftp.go | DialWithDialer | func DialWithDialer(dialer net.Dialer) DialOption {
return DialOption{func(do *dialOptions) {
do.dialer = dialer
}}
} | go | func DialWithDialer(dialer net.Dialer) DialOption {
return DialOption{func(do *dialOptions) {
do.dialer = dialer
}}
} | [
"func",
"DialWithDialer",
"(",
"dialer",
"net",
".",
"Dialer",
")",
"DialOption",
"{",
"return",
"DialOption",
"{",
"func",
"(",
"do",
"*",
"dialOptions",
")",
"{",
"do",
".",
"dialer",
"=",
"dialer",
"\n",
"}",
"}",
"\n",
"}"
] | // DialWithDialer returns a DialOption that configures the ServerConn with specified net.Dialer | [
"DialWithDialer",
"returns",
"a",
"DialOption",
"that",
"configures",
"the",
"ServerConn",
"with",
"specified",
"net",
".",
"Dialer"
] | 6a014d5e22e6a0b7c1fcb65f59872e4dd1227111 | https://github.com/jlaffaye/ftp/blob/6a014d5e22e6a0b7c1fcb65f59872e4dd1227111/ftp.go#L150-L154 |
27,099 | jlaffaye/ftp | ftp.go | DialWithNetConn | func DialWithNetConn(conn net.Conn) DialOption {
return DialOption{func(do *dialOptions) {
do.conn = conn
}}
} | go | func DialWithNetConn(conn net.Conn) DialOption {
return DialOption{func(do *dialOptions) {
do.conn = conn
}}
} | [
"func",
"DialWithNetConn",
"(",
"conn",
"net",
".",
"Conn",
")",
"DialOption",
"{",
"return",
"DialOption",
"{",
"func",
"(",
"do",
"*",
"dialOptions",
")",
"{",
"do",
".",
"conn",
"=",
"conn",
"\n",
"}",
"}",
"\n",
"}"
] | // DialWithNetConn returns a DialOption that configures the ServerConn with the underlying net.Conn | [
"DialWithNetConn",
"returns",
"a",
"DialOption",
"that",
"configures",
"the",
"ServerConn",
"with",
"the",
"underlying",
"net",
".",
"Conn"
] | 6a014d5e22e6a0b7c1fcb65f59872e4dd1227111 | https://github.com/jlaffaye/ftp/blob/6a014d5e22e6a0b7c1fcb65f59872e4dd1227111/ftp.go#L157-L161 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.