_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27700 | SignatureFromContext | train | func SignatureFromContext(ctx context.Context) *Signature {
if ctx == nil {
return nil
}
v := ctx.Value(signatureCtx)
if v == nil {
return nil
}
signature, _ := v.(*Signature)
return signature
} | go | {
"resource": ""
} |
q27701 | NewWithSignature | train | func NewWithSignature(taskFunc interface{}, signature *Signature) (*Task, error) {
args := signature.Args
ctx := context.Background()
ctx = context.WithValue(ctx, signatureCtx, signature)
task := &Task{
TaskFunc: reflect.ValueOf(taskFunc),
Context: ctx,
}
taskFuncType := reflect.TypeOf(taskFunc)
if taskFun... | go | {
"resource": ""
} |
q27702 | New | train | func New(taskFunc interface{}, args []Arg) (*Task, error) {
task := &Task{
TaskFunc: reflect.ValueOf(taskFunc),
Context: context.Background(),
}
taskFuncType := reflect.TypeOf(taskFunc)
if taskFuncType.NumIn() > 0 {
arg0Type := taskFuncType.In(0)
if IsContextType(arg0Type) {
task.UseContext = true
}
... | go | {
"resource": ""
} |
q27703 | StartSpanFromHeaders | train | func StartSpanFromHeaders(headers tasks.Headers, operationName string) opentracing.Span {
// Try to extract the span context from the carrier.
spanContext, err := opentracing.GlobalTracer().Extract(opentracing.TextMap, headers)
// Create a new span from the span context if found or start a new trace with the functi... | go | {
"resource": ""
} |
q27704 | HeadersWithSpan | train | func HeadersWithSpan(headers tasks.Headers, span opentracing.Span) tasks.Headers {
// check if the headers aren't nil
if headers == nil {
headers = make(tasks.Headers)
}
if err := opentracing.GlobalTracer().Inject(span.Context(), opentracing.TextMap, headers); err != nil {
span.LogFields(opentracing_log.Error(... | go | {
"resource": ""
} |
q27705 | consume | train | func (b *Broker) consume(deliveries <-chan *awssqs.ReceiveMessageOutput, concurrency int, taskProcessor iface.TaskProcessor) error {
pool := make(chan struct{}, concurrency)
// initialize worker pool with maxWorkers workers
go func() {
b.initializePool(pool, concurrency)
}()
errorsChan := make(chan error)
fo... | go | {
"resource": ""
} |
q27706 | consumeOne | train | func (b *Broker) consumeOne(delivery *awssqs.ReceiveMessageOutput, taskProcessor iface.TaskProcessor) error {
if len(delivery.Messages) == 0 {
log.ERROR.Printf("received an empty message, the delivery was %v", delivery)
return errors.New("received empty message, the delivery is " + delivery.GoString())
}
sig :=... | go | {
"resource": ""
} |
q27707 | deleteOne | train | func (b *Broker) deleteOne(delivery *awssqs.ReceiveMessageOutput) error {
qURL := b.defaultQueueURL()
_, err := b.service.DeleteMessage(&awssqs.DeleteMessageInput{
QueueUrl: qURL,
ReceiptHandle: delivery.Messages[0].ReceiptHandle,
})
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q27708 | defaultQueueURL | train | func (b *Broker) defaultQueueURL() *string {
if b.queueUrl != nil {
return b.queueUrl
} else {
return aws.String(b.GetConfig().Broker + "/" + b.GetConfig().DefaultQueue)
}
} | go | {
"resource": ""
} |
q27709 | receiveMessage | train | func (b *Broker) receiveMessage(qURL *string) (*awssqs.ReceiveMessageOutput, error) {
var waitTimeSeconds int
var visibilityTimeout *int
if b.GetConfig().SQS != nil {
waitTimeSeconds = b.GetConfig().SQS.WaitTimeSeconds
visibilityTimeout = b.GetConfig().SQS.VisibilityTimeout
} else {
waitTimeSeconds = 0
}
in... | go | {
"resource": ""
} |
q27710 | initializePool | train | func (b *Broker) initializePool(pool chan struct{}, concurrency int) {
for i := 0; i < concurrency; i++ {
pool <- struct{}{}
}
} | go | {
"resource": ""
} |
q27711 | consumeDeliveries | train | func (b *Broker) consumeDeliveries(deliveries <-chan *awssqs.ReceiveMessageOutput, concurrency int, taskProcessor iface.TaskProcessor, pool chan struct{}, errorsChan chan error) (bool, error) {
select {
case err := <-errorsChan:
return false, err
case d := <-deliveries:
if concurrency > 0 {
// get worker from... | go | {
"resource": ""
} |
q27712 | continueReceivingMessages | train | func (b *Broker) continueReceivingMessages(qURL *string, deliveries chan *awssqs.ReceiveMessageOutput) (bool, error) {
select {
// A way to stop this goroutine from b.StopConsuming
case <-b.stopReceivingChan:
return false, nil
default:
output, err := b.receiveMessage(qURL)
if err != nil {
return true, err
... | go | {
"resource": ""
} |
q27713 | getQueueURL | train | func (b *Broker) getQueueURL(taskProcessor iface.TaskProcessor) *string {
queueName := b.GetConfig().DefaultQueue
if taskProcessor.CustomQueue() != "" {
queueName = taskProcessor.CustomQueue()
}
return aws.String(b.GetConfig().Broker + "/" + queueName)
} | go | {
"resource": ""
} |
q27714 | GetUUIDs | train | func (group *Group) GetUUIDs() []string {
taskUUIDs := make([]string, len(group.Tasks))
for i, signature := range group.Tasks {
taskUUIDs[i] = signature.UUID
}
return taskUUIDs
} | go | {
"resource": ""
} |
q27715 | NewChain | train | func NewChain(signatures ...*Signature) (*Chain, error) {
// Auto generate task UUIDs if needed
for _, signature := range signatures {
if signature.UUID == "" {
signatureID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", signatureID)
}
}
for i := len(signatures) - 1; i > 0; i-- {
if i > ... | go | {
"resource": ""
} |
q27716 | NewGroup | train | func NewGroup(signatures ...*Signature) (*Group, error) {
// Generate a group UUID
groupUUID := uuid.New().String()
groupID := fmt.Sprintf("group_%v", groupUUID)
// Auto generate task UUIDs if needed, group tasks by common group UUID
for _, signature := range signatures {
if signature.UUID == "" {
signatureI... | go | {
"resource": ""
} |
q27717 | GetState | train | func (b *Backend) GetState(taskUUID string) (*tasks.TaskState, error) {
declareQueueArgs := amqp.Table{
// Time in milliseconds
// after that message will expire
"x-message-ttl": int32(b.getExpiresIn()),
// Time after that the queue will be deleted.
"x-expires": int32(b.getExpiresIn()),
}
conn, channel, _,... | go | {
"resource": ""
} |
q27718 | getExpiresIn | train | func (b *Backend) getExpiresIn() int {
resultsExpireIn := b.GetConfig().ResultsExpireIn * 1000
if resultsExpireIn == 0 {
// // expire results after 1 hour by default
resultsExpireIn = config.DefaultResultsExpireIn * 1000
}
return resultsExpireIn
} | go | {
"resource": ""
} |
q27719 | NewPool | train | func (rc *RedisConnector) NewPool(socketPath, host, password string, db int, cnf *config.RedisConfig, tlsConfig *tls.Config) *redis.Pool {
if cnf == nil {
cnf = defaultConfig
}
return &redis.Pool{
MaxIdle: cnf.MaxIdle,
IdleTimeout: time.Duration(cnf.IdleTimeout) * time.Second,
MaxActive: cnf.MaxActive,... | go | {
"resource": ""
} |
q27720 | open | train | func (rc *RedisConnector) open(socketPath, host, password string, db int, cnf *config.RedisConfig, tlsConfig *tls.Config) (redis.Conn, error) {
var opts = []redis.DialOption{
redis.DialDatabase(db),
redis.DialReadTimeout(time.Duration(cnf.ReadTimeout) * time.Second),
redis.DialWriteTimeout(time.Duration(cnf.Writ... | go | {
"resource": ""
} |
q27721 | NewAsyncResult | train | func NewAsyncResult(signature *tasks.Signature, backend iface.Backend) *AsyncResult {
return &AsyncResult{
Signature: signature,
taskState: new(tasks.TaskState),
backend: backend,
}
} | go | {
"resource": ""
} |
q27722 | NewChordAsyncResult | train | func NewChordAsyncResult(groupTasks []*tasks.Signature, chordCallback *tasks.Signature, backend iface.Backend) *ChordAsyncResult {
asyncResults := make([]*AsyncResult, len(groupTasks))
for i, task := range groupTasks {
asyncResults[i] = NewAsyncResult(task, backend)
}
return &ChordAsyncResult{
groupAsyncResults... | go | {
"resource": ""
} |
q27723 | NewChainAsyncResult | train | func NewChainAsyncResult(tasks []*tasks.Signature, backend iface.Backend) *ChainAsyncResult {
asyncResults := make([]*AsyncResult, len(tasks))
for i, task := range tasks {
asyncResults[i] = NewAsyncResult(task, backend)
}
return &ChainAsyncResult{
asyncResults: asyncResults,
backend: backend,
}
} | go | {
"resource": ""
} |
q27724 | Touch | train | func (asyncResult *AsyncResult) Touch() ([]reflect.Value, error) {
if asyncResult.backend == nil {
return nil, ErrBackendNotConfigured
}
asyncResult.GetState()
// Purge state if we are using AMQP backend
if asyncResult.backend.IsAMQP() && asyncResult.taskState.IsCompleted() {
asyncResult.backend.PurgeState(a... | go | {
"resource": ""
} |
q27725 | GetState | train | func (asyncResult *AsyncResult) GetState() *tasks.TaskState {
if asyncResult.taskState.IsCompleted() {
return asyncResult.taskState
}
taskState, err := asyncResult.backend.GetState(asyncResult.Signature.UUID)
if err == nil {
asyncResult.taskState = taskState
}
return asyncResult.taskState
} | go | {
"resource": ""
} |
q27726 | ValidateTask | train | func ValidateTask(task interface{}) error {
v := reflect.ValueOf(task)
t := v.Type()
// Task must be a function
if t.Kind() != reflect.Func {
return ErrTaskMustBeFunc
}
// Task must return at least a single value
if t.NumOut() < 1 {
return ErrTaskReturnsNoValue
}
// Last return value must be error
last... | go | {
"resource": ""
} |
q27727 | New | train | func New(cnf *config.Config) iface.Backend {
backend := &Backend{Backend: common.NewBackend(cnf), cnf: cnf}
if cnf.DynamoDB != nil && cnf.DynamoDB.Client != nil {
backend.client = cnf.DynamoDB.Client
} else {
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.Share... | go | {
"resource": ""
} |
q27728 | NewFromEnvironment | train | func NewFromEnvironment(keepReloading bool) (*Config, error) {
cnf, err := fromEnvironment()
if err != nil {
return nil, err
}
log.INFO.Print("Successfully loaded config from the environment")
if keepReloading {
// Open a goroutine to watch remote changes forever
go func() {
for {
// Delay after eac... | go | {
"resource": ""
} |
q27729 | NewBroker | train | func NewBroker(cnf *config.Config) Broker {
return Broker{cnf: cnf, retry: true}
} | go | {
"resource": ""
} |
q27730 | IsTaskRegistered | train | func (b *Broker) IsTaskRegistered(name string) bool {
for _, registeredTaskName := range b.registeredTaskNames {
if registeredTaskName == name {
return true
}
}
return false
} | go | {
"resource": ""
} |
q27731 | StartConsuming | train | func (b *Broker) StartConsuming(consumerTag string, concurrency int, taskProcessor iface.TaskProcessor) {
if b.retryFunc == nil {
b.retryFunc = retry.Closure()
}
b.stopChan = make(chan int)
b.retryStopChan = make(chan int)
} | go | {
"resource": ""
} |
q27732 | StopConsuming | train | func (b *Broker) StopConsuming() {
// Do not retry from now on
b.retry = false
// Stop the retry closure earlier
select {
case b.retryStopChan <- 1:
log.WARNING.Print("Stopping retry closure.")
default:
}
// Notifying the stop channel stops consuming of messages
select {
case b.stopChan <- 1:
log.WARNING.... | go | {
"resource": ""
} |
q27733 | lockGroupMeta | train | func (b *Backend) lockGroupMeta(groupMeta *tasks.GroupMeta) error {
groupMeta.Lock = true
encoded, err := json.Marshal(groupMeta)
if err != nil {
return err
}
return b.getClient().Set(&gomemcache.Item{
Key: groupMeta.GroupUUID,
Value: encoded,
Expiration: b.getExpirationTimestamp(),
})
} | go | {
"resource": ""
} |
q27734 | getExpirationTimestamp | train | func (b *Backend) getExpirationTimestamp() int32 {
expiresIn := b.GetConfig().ResultsExpireIn
if expiresIn == 0 {
// // expire results after 1 hour by default
expiresIn = config.DefaultResultsExpireIn
}
return int32(time.Now().Unix() + int64(expiresIn))
} | go | {
"resource": ""
} |
q27735 | getClient | train | func (b *Backend) getClient() *gomemcache.Client {
if b.client == nil {
b.client = gomemcache.New(b.servers...)
}
return b.client
} | go | {
"resource": ""
} |
q27736 | New | train | func New() iface.Backend {
return &Backend{
Backend: common.NewBackend(new(config.Config)),
groups: make(map[string][]string),
tasks: make(map[string][]byte),
}
} | go | {
"resource": ""
} |
q27737 | NewFromYaml | train | func NewFromYaml(cnfPath string, keepReloading bool) (*Config, error) {
cnf, err := fromFile(cnfPath)
if err != nil {
return nil, err
}
log.INFO.Printf("Successfully loaded config from file %s", cnfPath)
if keepReloading {
// Open a goroutine to watch remote changes forever
go func() {
for {
// Dela... | go | {
"resource": ""
} |
q27738 | ReadFromFile | train | func ReadFromFile(cnfPath string) ([]byte, error) {
file, err := os.Open(cnfPath)
// Config file not found
if err != nil {
return nil, fmt.Errorf("Open file error: %s", err)
}
// Config file found, let's try to read it
data := make([]byte, 1000)
count, err := file.Read(data)
if err != nil {
return nil, fm... | go | {
"resource": ""
} |
q27739 | NewSignature | train | func NewSignature(name string, args []Arg) (*Signature, error) {
signatureID := uuid.New().String()
return &Signature{
UUID: fmt.Sprintf("task_%v", signatureID),
Name: name,
Args: args,
}, nil
} | go | {
"resource": ""
} |
q27740 | NewServer | train | func NewServer(cnf *config.Config) (*Server, error) {
broker, err := BrokerFactory(cnf)
if err != nil {
return nil, err
}
// Backend is optional so we ignore the error
backend, _ := BackendFactory(cnf)
srv := NewServerWithBrokerBackend(cnf, broker, backend)
// init for eager-mode
eager, ok := broker.(eager... | go | {
"resource": ""
} |
q27741 | NewWorker | train | func (server *Server) NewWorker(consumerTag string, concurrency int) *Worker {
return &Worker{
server: server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: "",
}
} | go | {
"resource": ""
} |
q27742 | NewCustomQueueWorker | train | func (server *Server) NewCustomQueueWorker(consumerTag string, concurrency int, queue string) *Worker {
return &Worker{
server: server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: queue,
}
} | go | {
"resource": ""
} |
q27743 | RegisterTasks | train | func (server *Server) RegisterTasks(namedTaskFuncs map[string]interface{}) error {
for _, task := range namedTaskFuncs {
if err := tasks.ValidateTask(task); err != nil {
return err
}
}
server.registeredTasks = namedTaskFuncs
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | go | {
"resource": ""
} |
q27744 | RegisterTask | train | func (server *Server) RegisterTask(name string, taskFunc interface{}) error {
if err := tasks.ValidateTask(taskFunc); err != nil {
return err
}
server.registeredTasks[name] = taskFunc
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | go | {
"resource": ""
} |
q27745 | IsTaskRegistered | train | func (server *Server) IsTaskRegistered(name string) bool {
_, ok := server.registeredTasks[name]
return ok
} | go | {
"resource": ""
} |
q27746 | GetRegisteredTask | train | func (server *Server) GetRegisteredTask(name string) (interface{}, error) {
taskFunc, ok := server.registeredTasks[name]
if !ok {
return nil, fmt.Errorf("Task not registered error: %s", name)
}
return taskFunc, nil
} | go | {
"resource": ""
} |
q27747 | SendTaskWithContext | train | func (server *Server) SendTaskWithContext(ctx context.Context, signature *tasks.Signature) (*result.AsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendTask", tracing.ProducerOption(), tracing.MachineryTag)
defer span.Finish()
// tag the span with some info about the signature
signature.Hea... | go | {
"resource": ""
} |
q27748 | SendTask | train | func (server *Server) SendTask(signature *tasks.Signature) (*result.AsyncResult, error) {
return server.SendTaskWithContext(context.Background(), signature)
} | go | {
"resource": ""
} |
q27749 | SendChainWithContext | train | func (server *Server) SendChainWithContext(ctx context.Context, chain *tasks.Chain) (*result.ChainAsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendChain", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowChainTag)
defer span.Finish()
tracing.AnnotateSpanWithChainInfo(span, ... | go | {
"resource": ""
} |
q27750 | SendChain | train | func (server *Server) SendChain(chain *tasks.Chain) (*result.ChainAsyncResult, error) {
_, err := server.SendTask(chain.Tasks[0])
if err != nil {
return nil, err
}
return result.NewChainAsyncResult(chain.Tasks, server.backend), nil
} | go | {
"resource": ""
} |
q27751 | SendGroupWithContext | train | func (server *Server) SendGroupWithContext(ctx context.Context, group *tasks.Group, sendConcurrency int) ([]*result.AsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendGroup", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowGroupTag)
defer span.Finish()
tracing.AnnotateSpanWi... | go | {
"resource": ""
} |
q27752 | SendGroup | train | func (server *Server) SendGroup(group *tasks.Group, sendConcurrency int) ([]*result.AsyncResult, error) {
return server.SendGroupWithContext(context.Background(), group, sendConcurrency)
} | go | {
"resource": ""
} |
q27753 | SendChordWithContext | train | func (server *Server) SendChordWithContext(ctx context.Context, chord *tasks.Chord, sendConcurrency int) (*result.ChordAsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendChord", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowChordTag)
defer span.Finish()
tracing.AnnotateSpa... | go | {
"resource": ""
} |
q27754 | SendChord | train | func (server *Server) SendChord(chord *tasks.Chord, sendConcurrency int) (*result.ChordAsyncResult, error) {
return server.SendChordWithContext(context.Background(), chord, sendConcurrency)
} | go | {
"resource": ""
} |
q27755 | GetRegisteredTaskNames | train | func (server *Server) GetRegisteredTaskNames() []string {
taskNames := make([]string, len(server.registeredTasks))
var i = 0
for name := range server.registeredTasks {
taskNames[i] = name
i++
}
return taskNames
} | go | {
"resource": ""
} |
q27756 | Set | train | func Set(l logging.LoggerInterface) {
DEBUG = l
INFO = l
WARNING = l
ERROR = l
FATAL = l
} | go | {
"resource": ""
} |
q27757 | GetPendingTasks | train | func (b *Broker) GetPendingTasks(queue string) ([]*tasks.Signature, error) {
conn := b.open()
defer conn.Close()
if queue == "" {
queue = b.GetConfig().DefaultQueue
}
dataBytes, err := conn.Do("LRANGE", queue, 0, -1)
if err != nil {
return nil, err
}
results, err := redis.ByteSlices(dataBytes, err)
if err... | go | {
"resource": ""
} |
q27758 | nextTask | train | func (b *Broker) nextTask(queue string) (result []byte, err error) {
conn := b.open()
defer conn.Close()
items, err := redis.ByteSlices(conn.Do("BLPOP", queue, 1000))
if err != nil {
return []byte{}, err
}
// items[0] - the name of the key where an element was popped
// items[1] - the value of the popped ele... | go | {
"resource": ""
} |
q27759 | open | train | func (b *Broker) open() redis.Conn {
b.redisOnce.Do(func() {
b.pool = b.NewPool(b.socketPath, b.host, b.password, b.db, b.GetConfig().Redis, b.GetConfig().TLSConfig)
b.redsync = redsync.New([]redsync.Pool{b.pool})
})
return b.pool.Get()
} | go | {
"resource": ""
} |
q27760 | Fibonacci | train | func Fibonacci() func() int {
a, b := 0, 1
return func() int {
a, b = b, a+b
return a
}
} | go | {
"resource": ""
} |
q27761 | FibonacciNext | train | func FibonacciNext(start int) int {
fib := Fibonacci()
num := fib()
for num <= start {
num = fib()
}
return num
} | go | {
"resource": ""
} |
q27762 | decodeResults | train | func (b *Backend) decodeResults(results []*tasks.TaskResult) []*tasks.TaskResult {
l := len(results)
jsonResults := make([]*tasks.TaskResult, l, l)
for i, result := range results {
jsonResult := new(bson.M)
resultType := reflect.TypeOf(result.Value).Kind()
if resultType == reflect.String {
err := json.NewDe... | go | {
"resource": ""
} |
q27763 | lockGroupMeta | train | func (b *Backend) lockGroupMeta(groupUUID string) error {
query := bson.M{
"_id": groupUUID,
"lock": false,
}
change := bson.M{
"$set": bson.M{
"lock": true,
},
}
_, err := b.groupMetasCollection.UpdateOne(context.Background(), query, change, options.Update().SetUpsert(true))
return err
} | go | {
"resource": ""
} |
q27764 | unlockGroupMeta | train | func (b *Backend) unlockGroupMeta(groupUUID string) error {
update := bson.M{"$set": bson.M{"lock": false}}
_, err := b.groupMetasCollection.UpdateOne(context.Background(), bson.M{"_id": groupUUID}, update, options.Update())
return err
} | go | {
"resource": ""
} |
q27765 | connect | train | func (b *Backend) connect() error {
client, err := b.dial()
if err != nil {
return err
}
b.client = client
database := "machinery"
if b.GetConfig().MongoDB != nil {
database = b.GetConfig().MongoDB.Database
}
b.tasksCollection = b.client.Database(database).Collection("tasks")
b.groupMetasCollection = b.... | go | {
"resource": ""
} |
q27766 | dial | train | func (b *Backend) dial() (*mongo.Client, error) {
if b.GetConfig().MongoDB != nil && b.GetConfig().MongoDB.Client != nil {
return b.GetConfig().MongoDB.Client, nil
}
uri := b.GetConfig().ResultBackend
if strings.HasPrefix(uri, "mongodb://") == false &&
strings.HasPrefix(uri, "mongodb+srv://") == false {
uri... | go | {
"resource": ""
} |
q27767 | createMongoIndexes | train | func (b *Backend) createMongoIndexes(database string) error {
tasksCollection := b.client.Database(database).Collection("tasks")
expireIn := int32(b.GetConfig().ResultsExpireIn)
_, err := tasksCollection.Indexes().CreateMany(context.Background(), []mongo.IndexModel{
{
Keys: bson.M{"state": 1},
Options:... | go | {
"resource": ""
} |
q27768 | NewErrCouldNotUnmarshaTaskSignature | train | func NewErrCouldNotUnmarshaTaskSignature(msg []byte, err error) ErrCouldNotUnmarshaTaskSignature {
return ErrCouldNotUnmarshaTaskSignature{msg: msg, reason: err.Error()}
} | go | {
"resource": ""
} |
q27769 | NewErrRetryTaskLater | train | func NewErrRetryTaskLater(msg string, retryIn time.Duration) ErrRetryTaskLater {
return ErrRetryTaskLater{msg: msg, retryIn: retryIn}
} | go | {
"resource": ""
} |
q27770 | setExpirationTime | train | func (b *Backend) setExpirationTime(key string) error {
expiresIn := b.GetConfig().ResultsExpireIn
if expiresIn == 0 {
// // expire results after 1 hour by default
expiresIn = config.DefaultResultsExpireIn
}
expirationTimestamp := int32(time.Now().Unix() + int64(expiresIn))
conn := b.open()
defer conn.Close(... | go | {
"resource": ""
} |
q27771 | GetOrOpenConnection | train | func (b *Broker) GetOrOpenConnection(queueName string, queueBindingKey string, exchangeDeclareArgs, queueDeclareArgs, queueBindingArgs amqp.Table) (*AMQPConnection, error) {
var err error
b.connectionsMutex.Lock()
defer b.connectionsMutex.Unlock()
conn, ok := b.connections[queueName]
if !ok {
conn = &AMQPConne... | go | {
"resource": ""
} |
q27772 | delay | train | func (b *Broker) delay(signature *tasks.Signature, delayMs int64) error {
if delayMs <= 0 {
return errors.New("Cannot delay task by 0ms")
}
message, err := json.Marshal(signature)
if err != nil {
return fmt.Errorf("JSON marshal error: %s", err)
}
// It's necessary to redeclare the queue each time (to zero i... | go | {
"resource": ""
} |
q27773 | Version | train | func (s *Server) Version(ctx context.Context, req *pb.VersionRequest) (resp *pb.VersionResponse, err error) {
const operation = "version"
defer func() {
recordOperation(operation, time.Now())
recordError(operation, err)
}()
return &pb.VersionResponse{
Version: kubeAPIVersion,
RuntimeName: c... | go | {
"resource": ""
} |
q27774 | NetNsGet | train | func (s *Sandbox) NetNsGet(nspath, name string) (*NetNs, error) {
if err := ns.IsNSorErr(nspath); err != nil {
return nil, ErrClosedNetNS
}
symlink, symlinkErr := isSymbolicLink(nspath)
if symlinkErr != nil {
return nil, symlinkErr
}
var resolvedNsPath string
if symlink {
path, err := os.Readlink(nspath)... | go | {
"resource": ""
} |
q27775 | New | train | func New(id, namespace, name, kubeName, logDir string, labels, annotations map[string]string, processLabel, mountLabel string, metadata *pb.PodSandboxMetadata, shmPath, cgroupParent string, privileged bool, runtimeHandler string, resolvPath, hostname string, portMappings []*hostport.PortMapping, hostNetwork bool) (*San... | go | {
"resource": ""
} |
q27776 | AddContainer | train | func (s *Sandbox) AddContainer(c *oci.Container) {
s.containers.Add(c.Name(), c)
} | go | {
"resource": ""
} |
q27777 | GetContainer | train | func (s *Sandbox) GetContainer(name string) *oci.Container {
return s.containers.Get(name)
} | go | {
"resource": ""
} |
q27778 | RemoveContainer | train | func (s *Sandbox) RemoveContainer(c *oci.Container) {
s.containers.Delete(c.Name())
} | go | {
"resource": ""
} |
q27779 | SetInfraContainer | train | func (s *Sandbox) SetInfraContainer(infraCtr *oci.Container) error {
if s.infraContainer != nil {
return fmt.Errorf("sandbox already has an infra container")
} else if infraCtr == nil {
return fmt.Errorf("must provide non-nil infra container")
}
s.infraContainer = infraCtr
return nil
} | go | {
"resource": ""
} |
q27780 | NetNs | train | func (s *Sandbox) NetNs() *NetNs {
if s.netns == nil {
return nil
}
return s.netns.Get()
} | go | {
"resource": ""
} |
q27781 | NetNsPath | train | func (s *Sandbox) NetNsPath() string {
if s.netns == nil || s.netns.Get() == nil ||
s.netns.Get().symlink == nil {
if s.infraContainer != nil {
return fmt.Sprintf("/proc/%v/ns/net", s.infraContainer.State().Pid)
}
return ""
}
return s.netns.Get().symlink.Name()
} | go | {
"resource": ""
} |
q27782 | UserNsPath | train | func (s *Sandbox) UserNsPath() string {
if s.infraContainer != nil {
return fmt.Sprintf("/proc/%v/ns/user", s.infraContainer.State().Pid)
}
return ""
} | go | {
"resource": ""
} |
q27783 | NetNsCreate | train | func (s *Sandbox) NetNsCreate(netNs NetNsIface) error {
// Create a new netNs if nil provided
if netNs == nil {
netNs = &NetNs{}
}
// Check if interface is already initialized
if netNs.Initialized() {
return fmt.Errorf("net NS already initialized")
}
netNs, err := netNs.Initialize()
if err != nil {
retu... | go | {
"resource": ""
} |
q27784 | NetNsJoin | train | func (s *Sandbox) NetNsJoin(nspath, name string) error {
if s.netns != nil {
return fmt.Errorf("sandbox already has a network namespace, cannot join another")
}
netNS, err := s.NetNsGet(nspath, name)
if err != nil {
return err
}
s.netns = netNS
return nil
} | go | {
"resource": ""
} |
q27785 | NetNsRemove | train | func (s *Sandbox) NetNsRemove() error {
if s.netns == nil {
logrus.Warn("no networking namespace")
return nil
}
return s.netns.Remove()
} | go | {
"resource": ""
} |
q27786 | New | train | func New(crioSocketPath string) (CrioClient, error) {
tr := new(http.Transport)
configureUnixTransport(tr, "unix", crioSocketPath)
c := &http.Client{
Transport: tr,
}
return &crioClientImpl{
client: c,
crioSocketPath: crioSocketPath,
}, nil
} | go | {
"resource": ""
} |
q27787 | DaemonInfo | train | func (c *crioClientImpl) DaemonInfo() (types.CrioInfo, error) {
info := types.CrioInfo{}
req, err := c.getRequest("/info")
if err != nil {
return info, err
}
resp, err := c.client.Do(req)
if err != nil {
return info, err
}
defer resp.Body.Close()
err = json.NewDecoder(resp.Body).Decode(&info)
return info,... | go | {
"resource": ""
} |
q27788 | ContainerInfo | train | func (c *crioClientImpl) ContainerInfo(id string) (*types.ContainerInfo, error) {
req, err := c.getRequest("/containers/" + id)
if err != nil {
return nil, err
}
resp, err := c.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
cInfo := types.ContainerInfo{}
if err := json.NewDecoder(... | go | {
"resource": ""
} |
q27789 | Write | train | func (f *fifo) Write(b []byte) (int, error) {
if f.flag&(syscall.O_WRONLY|syscall.O_RDWR) == 0 {
return 0, errors.New("writing to read-only fifo")
}
select {
case <-f.opened:
return f.file.Write(b)
default:
}
select {
case <-f.opened:
return f.file.Write(b)
case <-f.closed:
return 0, errors.New("writin... | go | {
"resource": ""
} |
q27790 | Get | train | func Get(ctx context.Context) string {
httpVersion := make([]VersionInfo, 0, 4)
httpVersion = append(httpVersion, VersionInfo{Name: "cri-o", Version: version.Version})
httpVersion = append(httpVersion, VersionInfo{Name: "go", Version: runtime.Version()})
httpVersion = append(httpVersion, VersionInfo{Name: "os", Ver... | go | {
"resource": ""
} |
q27791 | SaveTo | train | func (s SecretData) SaveTo(dir string) error {
path := filepath.Join(dir, s.Name)
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil && !os.IsExist(err) {
return err
}
return ioutil.WriteFile(path, s.Data, 0700)
} | go | {
"resource": ""
} |
q27792 | secretMounts | train | func secretMounts(defaultMountsPaths []string, mountLabel, containerWorkingDir string, runtimeMounts []rspec.Mount) ([]rspec.Mount, error) {
mounts := make([]rspec.Mount, 0, len(defaultMountsPaths))
for _, path := range defaultMountsPaths {
hostDir, ctrDir, err := getMountsMap(path)
if err != nil {
return nil,... | go | {
"resource": ""
} |
q27793 | NewCRILogger | train | func NewCRILogger(path string, w io.Writer, stream StreamType, maxLen int) (io.WriteCloser, <-chan struct{}) {
logrus.Debugf("Start writing stream %q to log file %q", stream, path)
prc, pwc := io.Pipe()
stop := make(chan struct{})
go func() {
redirectLogs(path, prc, w, stream, maxLen)
close(stop)
}()
return p... | go | {
"resource": ""
} |
q27794 | inStringSlice | train | func inStringSlice(ss []string, str string) bool {
for _, s := range ss {
if strings.EqualFold(s, str) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q27795 | getOCICapabilitiesList | train | func getOCICapabilitiesList() []string {
caps := make([]string, 0, len(capability.List()))
for _, cap := range capability.List() {
if cap > validate.LastCap() {
continue
}
caps = append(caps, "CAP_"+strings.ToUpper(cap.String()))
}
return caps
} | go | {
"resource": ""
} |
q27796 | validateSysctl | train | func validateSysctl(sysctl string, hostNet, hostIPC bool) error {
nsErrorFmt := "%q not allowed with host %s enabled"
if ns, found := namespaces[sysctl]; found {
if ns == IpcNamespace && hostIPC {
return errors.Errorf(nsErrorFmt, sysctl, ns)
}
if ns == NetNamespace && hostNet {
return errors.Errorf(nsErro... | go | {
"resource": ""
} |
q27797 | translateLabelsToDescription | train | func translateLabelsToDescription(labels map[string]string) string {
return fmt.Sprintf("%s/%s/%s", labels[types.KubernetesPodNamespaceLabel], labels[types.KubernetesPodNameLabel], labels[types.KubernetesContainerNameLabel])
} | go | {
"resource": ""
} |
q27798 | GetStore | train | func (c *Config) GetStore() (cstorage.Store, error) {
return cstorage.GetStore(cstorage.StoreOptions{
RunRoot: c.RunRoot,
GraphRoot: c.Root,
GraphDriverName: c.Storage,
GraphDriverOptions: c.StorageOptions,
})
} | go | {
"resource": ""
} |
q27799 | UpdateFromFile | train | func (c *Config) UpdateFromFile(path string) error {
data, err := ioutil.ReadFile(path)
if err != nil {
return err
}
t := new(tomlConfig)
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 ni... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.