id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c27700 |
}
v := ctx.Value(signatureCtx)
if v == nil {
return nil
}
signature, _ := v.(*Signature)
return signature
} | |
c27701 |
arg0Type := taskFuncType.In(0)
if IsContextType(arg0Type) {
task.UseContext = true
}
}
if err := task.ReflectArgs(args); err != nil {
return nil, fmt.Errorf("Reflect task args error: %s", err)
}
return task, nil
} | |
c27702 | task.UseContext = true
}
}
if err := task.ReflectArgs(args); err != nil {
return nil, fmt.Errorf("Reflect task args error: %s", err)
}
return task, nil
} | |
c27703 | span from the span context if found or start a new trace with the function name.
// For clarity add the machinery component tag.
span := opentracing.StartSpan(
operationName,
ConsumerOption(spanContext),
MachineryTag,
)
// Log any error but don't fail
if err != nil {
span.LogFields(opentracing_log.Error(... | |
c27704 | if err := opentracing.GlobalTracer().Inject(span.Context(), opentracing.TextMap, headers); err != nil {
span.LogFields(opentracing_log.Error(err))
}
return headers
} | |
c27705 |
for {
whetherContinue, err := b.consumeDeliveries(deliveries, concurrency, taskProcessor, pool, errorsChan)
if err != nil {
return err
}
if whetherContinue == false {
return nil
}
}
} | |
c27706 |
// and leave the message in the queue
if !b.IsTaskRegistered(sig.Name) {
return fmt.Errorf("task %s is not registered", sig.Name)
}
err := taskProcessor.Process(sig)
if err != nil {
return err
}
// Delete message after successfully consuming and processing the message
if err = b.deleteOne(delivery); err !... | |
c27707 |
ReceiptHandle: delivery.Messages[0].ReceiptHandle,
})
if err != nil {
return err
}
return nil
} | |
c27708 | b.queueUrl
} else {
return aws.String(b.GetConfig().Broker + "/" + b.GetConfig().DefaultQueue)
}
} | |
c27709 | qURL,
MaxNumberOfMessages: aws.Int64(1),
WaitTimeSeconds: aws.Int64(int64(waitTimeSeconds)),
}
if visibilityTimeout != nil {
input.VisibilityTimeout = aws.Int64(int64(*visibilityTimeout))
}
result, err := b.service.ReceiveMessage(input)
if err != nil {
return nil, err
}
return result, err
} | |
c27710 | concurrency; i++ {
pool <- struct{}{}
}
} | |
c27711 | processed concurrently
go func() {
if err := b.consumeOne(d, taskProcessor); err != nil {
errorsChan <- err
}
b.processingWG.Done()
if concurrency > 0 {
// give worker back to pool
pool <- struct{}{}
}
}()
case <-b.GetStopChan():
return false, nil
}
return true, nil
} | |
c27712 | if err != nil {
return true, err
}
if len(output.Messages) == 0 {
return true, nil
}
go func() { deliveries <- output }()
}
return true, nil
} | |
c27713 | = taskProcessor.CustomQueue()
}
return aws.String(b.GetConfig().Broker + "/" + queueName)
} | |
c27714 |
for i, signature := range group.Tasks {
taskUUIDs[i] = signature.UUID
}
return taskUUIDs
} | |
c27715 | := len(signatures) - 1; i > 0; i-- {
if i > 0 {
signatures[i-1].OnSuccess = []*Signature{signatures[i]}
}
}
chain := &Chain{Tasks: signatures}
return chain, nil
} | |
c27716 | signatureID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", signatureID)
}
signature.GroupUUID = groupID
signature.GroupTaskCount = len(signatures)
}
return &Group{
GroupUUID: groupID,
Tasks: signatures,
}, nil
} | |
c27717 | // queue binding args
)
if err != nil {
return nil, err
}
defer b.Close(channel, conn)
d, ok, err := channel.Get(
taskUUID, // queue name
false, // multiple
)
if err != nil {
return nil, err
}
if !ok {
return nil, errors.New("No state ready")
}
d.Ack(false)
state := new(tasks.Tas... | |
c27718 | 0 {
// // expire results after 1 hour by default
resultsExpireIn = config.DefaultResultsExpireIn * 1000
}
return resultsExpireIn
} | |
c27719 |
}
}
return c, err
},
// PINGs connections that have been idle more than 10 seconds
TestOnBorrow: func(c redis.Conn, t time.Time) error {
if time.Since(t) < time.Duration(10*time.Second) {
return nil
}
_, err := c.Do("PING")
return err
},
}
} | |
c27720 | opts = append(opts, redis.DialTLSConfig(tlsConfig), redis.DialUseTLS(true))
}
if password != "" {
opts = append(opts, redis.DialPassword(password))
}
if socketPath != "" {
return redis.Dial("unix", socketPath, opts...)
}
return redis.Dial("tcp", host, opts...)
} | |
c27721 | taskState: new(tasks.TaskState),
backend: backend,
}
} | |
c27722 | &ChordAsyncResult{
groupAsyncResults: asyncResults,
chordAsyncResult: NewAsyncResult(chordCallback, backend),
backend: backend,
}
} | |
c27723 |
asyncResults[i] = NewAsyncResult(task, backend)
}
return &ChainAsyncResult{
asyncResults: asyncResults,
backend: backend,
}
} | |
c27724 | asyncResult.taskState.IsCompleted() {
asyncResult.backend.PurgeState(asyncResult.taskState.TaskUUID)
}
if asyncResult.taskState.IsFailure() {
return nil, errors.New(asyncResult.taskState.Error)
}
if asyncResult.taskState.IsSuccess() {
return tasks.ReflectTaskResults(asyncResult.taskState.Results)
}
retu... | |
c27725 |
}
taskState, err := asyncResult.backend.GetState(asyncResult.Signature.UUID)
if err == nil {
asyncResult.taskState = taskState
}
return asyncResult.taskState
} | |
c27726 | value
if t.NumOut() < 1 {
return ErrTaskReturnsNoValue
}
// Last return value must be error
lastReturnType := t.Out(t.NumOut() - 1)
errorInterface := reflect.TypeOf((*error)(nil)).Elem()
if !lastReturnType.Implements(errorInterface) {
return ErrLastReturnValueMustBeError
}
return nil
} | |
c27727 | // Check if needed tables exist
err := backend.checkRequiredTablesIfExist()
if err != nil {
log.FATAL.Printf("Failed to prepare tables. Error: %v", err)
}
return backend
} | |
c27728 | newCnf, newErr := fromEnvironment()
if newErr != nil {
log.WARNING.Printf("Failed to reload config from the environment: %v", newErr)
continue
}
*cnf = *newCnf
// log.INFO.Printf("Successfully reloaded config from the environment")
}
}()
}
return cnf, nil
} | |
c27729 | Broker{cnf: cnf, retry: true}
} | |
c27730 | := range b.registeredTaskNames {
if registeredTaskName == name {
return true
}
}
return false
} | |
c27731 | b.retryFunc = retry.Closure()
}
b.stopChan = make(chan int)
b.retryStopChan = make(chan int)
} | |
c27732 | 1:
log.WARNING.Print("Stopping retry closure.")
default:
}
// Notifying the stop channel stops consuming of messages
select {
case b.stopChan <- 1:
log.WARNING.Print("Stop channel")
default:
}
} | |
c27733 | Key: groupMeta.GroupUUID,
Value: encoded,
Expiration: b.getExpirationTimestamp(),
})
} | |
c27734 | config.DefaultResultsExpireIn
}
return int32(time.Now().Unix() + int64(expiresIn))
} | |
c27735 | b.client == nil {
b.client = gomemcache.New(b.servers...)
}
return b.client
} | |
c27736 | make(map[string][]string),
tasks: make(map[string][]byte),
}
} | |
c27737 | newCnf, newErr := fromFile(cnfPath)
if newErr != nil {
log.WARNING.Printf("Failed to reload config from file %s: %v", cnfPath, newErr)
continue
}
*cnf = *newCnf
// log.INFO.Printf("Successfully reloaded config from file %s", cnfPath)
}
}()
}
return cnf, nil
} | |
c27738 | data := make([]byte, 1000)
count, err := file.Read(data)
if err != nil {
return nil, fmt.Errorf("Read from file error: %s", err)
}
return data[:count], nil
} | |
c27739 | UUID: fmt.Sprintf("task_%v", signatureID),
Name: name,
Args: args,
}, nil
} | |
c27740 | ok := broker.(eager.Mode)
if ok {
// we don't have to call worker.Launch in eager mode
eager.AssignWorker(srv.NewWorker("eager", 0))
}
return srv, nil
} | |
c27741 | server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: "",
}
} | |
c27742 | {
return &Worker{
server: server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: queue,
}
} | |
c27743 | = namedTaskFuncs
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | |
c27744 | != nil {
return err
}
server.registeredTasks[name] = taskFunc
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | |
c27745 | ok := server.registeredTasks[name]
return ok
} | |
c27746 | nil, fmt.Errorf("Task not registered error: %s", name)
}
return taskFunc, nil
} | |
c27747 | = fmt.Sprintf("task_%v", taskID)
}
// Set initial task state to PENDING
if err := server.backend.SetStatePending(signature); err != nil {
return nil, fmt.Errorf("Set state pending error: %s", err)
}
if server.prePublishHandler != nil {
server.prePublishHandler(signature)
}
if err := server.broker.Publish... | |
c27748 | server.SendTaskWithContext(context.Background(), signature)
} | |
c27749 | "SendChain", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowChainTag)
defer span.Finish()
tracing.AnnotateSpanWithChainInfo(span, chain)
return server.SendChain(chain)
} | |
c27750 | return nil, err
}
return result.NewChainAsyncResult(chain.Tasks, server.backend), nil
} | |
c27751 | }
}()
for i, signature := range group.Tasks {
if sendConcurrency > 0 {
<-pool
}
go func(s *tasks.Signature, index int) {
defer wg.Done()
// Publish task
err := server.broker.Publish(ctx, s)
if sendConcurrency > 0 {
pool <- struct{}{}
}
if err != nil {
errorsChan <- fmt.Error... | |
c27752 | server.SendGroupWithContext(context.Background(), group, sendConcurrency)
} | |
c27753 |
_, err := server.SendGroupWithContext(ctx, chord.Group, sendConcurrency)
if err != nil {
return nil, err
}
return result.NewChordAsyncResult(
chord.Group.Tasks,
chord.Callback,
server.backend,
), nil
} | |
c27754 | server.SendChordWithContext(context.Background(), chord, sendConcurrency)
} | |
c27755 | range server.registeredTasks {
taskNames[i] = name
i++
}
return taskNames
} | |
c27756 | DEBUG = l
INFO = l
WARNING = l
ERROR = l
FATAL = l
} | |
c27757 | decoder := json.NewDecoder(bytes.NewReader(result))
decoder.UseNumber()
if err := decoder.Decode(signature); err != nil {
return nil, err
}
taskSignatures[i] = signature
}
return taskSignatures, nil
} | |
c27758 | err != nil {
return []byte{}, err
}
// items[0] - the name of the key where an element was popped
// items[1] - the value of the popped element
if len(items) != 2 {
return []byte{}, redis.ErrNil
}
result = items[1]
return result, nil
} | |
c27759 |
b.redsync = redsync.New([]redsync.Pool{b.pool})
})
return b.pool.Get()
} | |
c27760 | a, b = b, a+b
return a
}
} | |
c27761 |
num := fib()
for num <= start {
num = fib()
}
return num
} | |
c27762 | err == nil {
jsonResults[i] = &tasks.TaskResult{
Type: "json",
Value: jsonResult,
}
continue
}
}
jsonResults[i] = result
}
return jsonResults
} | |
c27763 | _, err := b.groupMetasCollection.UpdateOne(context.Background(), query, change, options.Update().SetUpsert(true))
return err
} | |
c27764 | := b.groupMetasCollection.UpdateOne(context.Background(), bson.M{"_id": groupUUID}, update, options.Update())
return err
} | |
c27765 |
b.groupMetasCollection = b.client.Database(database).Collection("group_metas")
err = b.createMongoIndexes(database)
if err != nil {
return err
}
return nil
} | |
c27766 | strings.HasPrefix(uri, "mongodb+srv://") == false {
uri = fmt.Sprintf("mongodb://%s", uri)
}
client, err := mongo.NewClient(options.Client().ApplyURI(uri))
if err != nil {
return nil, err
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := client.Connect(c... | |
c27767 |
},
mongo.IndexModel{
Keys: bson.M{"lock": 1},
Options: options.Index().SetBackground(true).SetExpireAfterSeconds(expireIn),
},
})
if err != nil {
return err
}
return err
} | |
c27768 | {
return ErrCouldNotUnmarshaTaskSignature{msg: msg, reason: err.Error()}
} | |
c27769 | ErrRetryTaskLater{msg: msg, retryIn: retryIn}
} | |
c27770 | int64(expiresIn))
conn := b.open()
defer conn.Close()
_, err := conn.Do("EXPIREAT", key, expirationTimestamp)
if err != nil {
return err
}
return nil
} | |
c27771 | // queue declare args
queueBindingArgs, // queue binding args
)
if err != nil {
return nil, err
}
// Reconnect to the channel if it disconnects/errors out
go func() {
select {
case err = <-conn.errorchan:
log.INFO.Printf("Error occured on queue: %s. Reconnecting... | |
c27772 | // queue delete when unused
queueName, // queue binding key
nil, // exchange declare args
declareQueueArgs, // queue declare args
amqp.Table(b.GetConfig().AMQP.QueueBindingArgs), // queue binding args
)
if err != nil {
return err
}
defe... | |
c27773 | kubeAPIVersion,
RuntimeName: containerName,
RuntimeVersion: version.Version,
RuntimeApiVersion: runtimeAPIVersion,
}, nil
} | |
c27774 |
}
netNs, err := getNetNs(resolvedNsPath)
if err != nil {
return nil, err
}
if symlink {
fd, err := os.Open(nspath)
if err != nil {
return nil, err
}
netNs.symlink = fd
} else if err := netNs.SymlinkCreate(name); err != nil {
return nil, err
}
return netNs, nil
} | |
c27775 | = mountLabel
sb.metadata = metadata
sb.shmPath = shmPath
sb.cgroupParent = cgroupParent
sb.privileged = privileged
sb.runtimeHandler = runtimeHandler
sb.resolvPath = resolvPath
sb.hostname = hostname
sb.portMappings = portMappings
sb.createdAt = time.Now()
sb.hostNetwork = hostNetwork
return sb, nil
} | |
c27776 | s.containers.Add(c.Name(), c)
} | |
c27777 | *oci.Container {
return s.containers.Get(name)
} | |
c27778 | *oci.Container) {
s.containers.Delete(c.Name())
} | |
c27779 | has an infra container")
} else if infraCtr == nil {
return fmt.Errorf("must provide non-nil infra container")
}
s.infraContainer = infraCtr
return nil
} | |
c27780 | s.netns == nil {
return nil
}
return s.netns.Get()
} | |
c27781 |
return fmt.Sprintf("/proc/%v/ns/net", s.infraContainer.State().Pid)
}
return ""
}
return s.netns.Get().symlink.Name()
} | |
c27782 | return fmt.Sprintf("/proc/%v/ns/user", s.infraContainer.State().Pid)
}
return ""
} | |
c27783 | initialized")
}
netNs, err := netNs.Initialize()
if err != nil {
return err
}
if err := netNs.SymlinkCreate(s.name); err != nil {
logrus.Warnf("Could not create nentns symlink %v", err)
if err1 := netNs.Close(); err1 != nil {
return err1
}
return err
}
s.netns = netNs
return nil
} | |
c27784 |
netNS, err := s.NetNsGet(nspath, name)
if err != nil {
return err
}
s.netns = netNS
return nil
} | |
c27785 | networking namespace")
return nil
}
return s.netns.Remove()
} | |
c27786 | tr,
}
return &crioClientImpl{
client: c,
crioSocketPath: crioSocketPath,
}, nil
} | |
c27787 | != nil {
return info, err
}
defer resp.Body.Close()
err = json.NewDecoder(resp.Body).Decode(&info)
return info, err
} | |
c27788 |
}
defer resp.Body.Close()
cInfo := types.ContainerInfo{}
if err := json.NewDecoder(resp.Body).Decode(&cInfo); err != nil {
return nil, err
}
return &cInfo, nil
} | |
c27789 | select {
case <-f.opened:
return f.file.Write(b)
case <-f.closed:
return 0, errors.New("writing to a closed fifo")
}
} | |
c27790 | "os", Version: runtime.GOOS})
httpVersion = append(httpVersion, VersionInfo{Name: "arch", Version: runtime.GOARCH})
return AppendVersions("", httpVersion...)
} | |
c27791 | nil && !os.IsExist(err) {
return err
}
return ioutil.WriteFile(path, s.Data, 0700)
} | |
c27792 |
hostDir, err = resolveSymbolicLink(hostDir, "/")
if err != nil {
return nil, err
}
data, err := getHostSecretData(hostDir)
if err != nil {
return nil, errors.Wrapf(err, "getting host secret data failed")
}
for _, s := range data {
if err := s.SaveTo(ctrDirOnHost); err != nil {
return nil, e... | |
c27793 | struct{})
go func() {
redirectLogs(path, prc, w, stream, maxLen)
close(stop)
}()
return pwc, stop
} | |
c27794 | str) {
return true
}
}
return false
} | |
c27795 |
caps = append(caps, "CAP_"+strings.ToUpper(cap.String()))
}
return caps
} | |
c27796 | if ns == IpcNamespace && hostIPC {
return errors.Errorf(nsErrorFmt, sysctl, ns)
}
if ns == NetNamespace && hostNet {
return errors.Errorf(nsErrorFmt, sysctl, ns)
}
return nil
}
}
return errors.Errorf("%q not whitelisted", sysctl)
} | |
c27797 | labels[types.KubernetesPodNamespaceLabel], labels[types.KubernetesPodNameLabel], labels[types.KubernetesContainerNameLabel])
} | |
c27798 | c.Root,
GraphDriverName: c.Storage,
GraphDriverOptions: c.StorageOptions,
})
} | |
c27799 | t.fromConfig(c)
_, err = toml.Decode(string(data), t)
if err != nil {
return fmt.Errorf("unable to decode configuration %v: %v", path, err)
}
t.toConfig(c)
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.