id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168400 | nil {
return 0, errors.Wrap(err, "parseInt")
}
return result, nil
} | |
c168401 | if err := json.Unmarshal([]byte(s), &data); err != nil {
return nil, err
}
return data, nil
} | |
c168402 | nil {
return 0, errors.Wrap(err, "parseUint")
}
return result, nil
} | |
c168403 | {
return "", fmt.Errorf("exec %q: %s\n\nstdout:\n\n%s\n\nstderr:\n\n%s",
name, err, stdout.Bytes(), stderr.Bytes())
}
done := make(chan error, 1)
go func() {
done <- cmd.Wait()
}()
select {
case <-time.After(30 * time.Second):
if cmd.Process != nil {
if err := cmd.Process.Kill(); err != nil {
r... | |
c168404 | strings.Replace(s, f, t, -1), nil
} | |
c168405 | return "", err
}
return compiled.ReplaceAllString(s, pl), nil
} | |
c168406 | false, err
}
return compiled.MatchString(s), nil
} | |
c168407 | []string{}, nil
}
return strings.Split(s, sep), nil
} | |
c168408 |
return "", fmt.Errorf("timestamp: wrong number of arguments, expected 0 or 1"+
", but got %d", len(s))
}
} | |
c168409 | "", errors.Wrap(err, "toJSON")
}
return string(bytes.TrimSpace(result)), err
} | |
c168410 | {
return "", errors.Wrap(err, "toJSONPretty")
}
return string(bytes.TrimSpace(result)), err
} | |
c168411 | "", errors.Wrap(err, "toYAML")
}
return string(bytes.TrimSpace(result)), nil
} | |
c168412 | if err != nil {
return "", errors.Wrap(err, "toTOML")
}
return string(bytes.TrimSpace(result)), nil
} | |
c168413 | reflect.Float32, reflect.Float64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Float() + float64(bv.Int()), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Float() + float64(bv.Uint()), nil
case r... | |
c168414 |
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return int64(av.Uint()) % bv.Int(), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return av.Uint() % bv.Uint(), nil
default:
return nil, fmt.Errorf("modulo: unknown type for %q (%T)", bv,... | |
c168415 |
return time.Now().UnixNano() > item.Expiration
} | |
c168416 | c.Set(k, x, DefaultExpiration)
} | |
c168417 |
return fmt.Errorf("Item %s already exists", k)
}
c.set(k, x, d)
c.mu.Unlock()
return nil
} | |
c168418 | if time.Now().UnixNano() > item.Expiration {
c.mu.RUnlock()
return nil, false
}
}
c.mu.RUnlock()
return item.Object, true
} | |
c168419 | c.mu.Unlock()
return 0, fmt.Errorf("The value for %s is not an int", k)
}
nv := rv + n
v.Object = nv
c.items[k] = v
c.mu.Unlock()
return nv, nil
} | |
c168420 | c.mu.Unlock()
if evicted {
c.onEvicted(k, v)
}
} | |
c168421 |
if evicted {
evictedItems = append(evictedItems, keyAndValue{k, ov})
}
}
}
c.mu.Unlock()
for _, v := range evictedItems {
c.onEvicted(v.key, v.value)
}
} | |
c168422 | if v.Expiration > 0 {
if now > v.Expiration {
continue
}
}
m[k] = v
}
return m
} | |
c168423 |
n := len(c.items)
c.mu.RUnlock()
return n
} | |
c168424 |
c.items = map[string]Item{}
c.mu.Unlock()
} | |
c168425 | {
case 1:
case 2:
d = (d * 33) ^ uint32(k[i])
case 3:
d = (d * 33) ^ uint32(k[i])
d = (d * 33) ^ uint32(k[i+1])
case 4:
d = (d * 33) ^ uint32(k[i])
d = (d * 33) ^ uint32(k[i+1])
d = (d * 33) ^ uint32(k[i+2])
}
return d ^ (d >> 16)
} | |
c168426 | return netlink.LinkByName(name)
} | |
c168427 | mock.recorder = &MockTaskEngineMockRecorder{mock}
return mock
} | |
c168428 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTask", reflect.TypeOf((*MockTaskEngine)(nil).AddTask), arg0)
} | |
c168429 | m.ctrl.Call(m, "GetTaskByArn", arg0)
ret0, _ := ret[0].(*task.Task)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c168430 | := ret[0].([]*task.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168431 | := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168432 | context.Context) {
m.ctrl.Call(m, "MustInit", arg0)
} | |
c168433 |
ret := m.ctrl.Call(m, "StateChangeEvents")
ret0, _ := ret[0].(chan statechange.Event)
return ret0
} | |
c168434 | "Version", reflect.TypeOf((*MockTaskEngine)(nil).Version))
} | |
c168435 |
mock.recorder = &MockImageManagerMockRecorder{mock}
return mock
} | |
c168436 | []*image.ImageState) {
m.ctrl.Call(m, "AddAllImageStates", arg0)
} | |
c168437 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAllImageStates", reflect.TypeOf((*MockImageManager)(nil).AddAllImageStates), arg0)
} | |
c168438 | ret[0].(*image.ImageState)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c168439 | := m.ctrl.Call(m, "RecordContainerReference", arg0)
ret0, _ := ret[0].(error)
return ret0
} | |
c168440 | context.Context) {
m.ctrl.Call(m, "StartImageCleanupProcess", arg0)
} | |
c168441 | session.New(), aws.NewConfig().WithMaxRetries(metadataRetries)),
}
} else {
return &ec2MetadataClientImpl{client: client}
}
} | |
c168442 | securityCredentialList[0]
defaultCredentialStr, err := c.client.GetMetadata(SecurityCrednetialsResource + defaultCredentialName)
if err != nil {
return nil, err
}
var credential RoleCredentials
err = json.Unmarshal([]byte(defaultCredentialStr), &credential)
if err != nil {
return nil, err
}
return &creden... | |
c168443 |
return c.client.GetDynamicData(path)
} | |
c168444 |
return c.client.GetMetadata(path)
} | |
c168445 | c.client.GetMetadata(fmt.Sprintf(VPCIDResourceFormat, mac))
} | |
c168446 | c.client.GetMetadata(fmt.Sprintf(SubnetIDResourceFormat, mac))
} | |
c168447 | derivedContext,
cancel: cancel,
cluster: aws.String(cluster),
containerInstance: aws.String(containerInstanceArn),
acsClient: acsClient,
credentialsManager: credentialsManager,
taskEngine: taskEngine,
}
} | |
c168448 | buffer
return func(message *ecsacs.IAMRoleCredentialsMessage) {
refreshHandler.messageBuffer <- message
}
} | |
c168449 | if err != nil {
seelog.Warnf("Error 'ack'ing request with messageID: %s, error: %v", aws.StringValue(ack.MessageId), err)
}
seelog.Debugf("Acking credentials message: %s", ack.String())
} | |
c168450 | refreshHandler.handleSingleMessage(message)
case <-refreshHandler.ctx.Done():
return
}
}
} | |
c168451 | seelog.Errorf("Unable to update credentials for task, err: %v messageId: %s", err, messageId)
return fmt.Errorf("unable to update credentials %v", err)
}
if roleType == credentials.ApplicationRoleType {
task.SetCredentialsID(aws.StringValue(message.RoleCredentials.CredentialsId))
}
if roleType == crede... | |
c168452 |
case credentials.ExecutionRoleType:
return true
default:
return false
}
} | |
c168453 | saver,
taskHandler: taskHandler,
ctx: derivedContext,
cancel: cancel,
cluster: cluster,
containerInstanceArn: containerInstanceArn,
acsClient: acsClient,
refreshHandler: refreshHandler,
credentialsManager: credentialsManag... | |
c168454 | buffer
return func(payload *ecsacs.PayloadMessage) {
payloadHandler.messageBuffer <- payload
}
} | |
c168455 |
MessageId: aws.String(messageID),
})
if err != nil {
seelog.Warnf("Error 'ack'ing request with messageID: %s, error: %v", messageID, err)
}
} | |
c168456 | payloadHandler.handleSingleMessage(payload)
case <-payloadHandler.ctx.Done():
return
}
}
} | |
c168457 | can save it in the future.
return fmt.Errorf("error saving state for payload message, with messageId: %s", aws.StringValue(payload.MessageId))
}
if !allTasksHandled {
return fmt.Errorf("did not handle all tasks")
}
go func() {
// Throw the ack in async; it doesn't really matter all that much and this is blo... | |
c168458 |
// task executionCredentials id.
taskExecutionIAMRoleCredentials := credentials.IAMRoleCredentialsFromACS(task.ExecutionRoleCredentials, credentials.ExecutionRoleType)
err = payloadHandler.credentialsManager.SetTaskCredentials(
&(credentials.TaskIAMRoleCredentials{
ARN: aws.StringValue... | |
c168459 | associated with an IAM role or the execution role
taskCredentialsID := task.GetCredentialsID()
if taskCredentialsID != "" {
ackCredentials(taskCredentialsID, "task iam role")
}
taskExecutionCredentialsID := task.GetExecutionCredentialsID()
if taskExecutionCredentialsID != "" {
ackCredentials(taskExecu... | |
c168460 | Reason: UnrecognizedTaskError{err}.Error(),
// The real task cannot be extracted from payload message, so we send an empty task.
// This is necessary because the task handler will not send an event whose
// Task is nil.
Task: &apitask.Task{},
}
payloadHandler.taskHandler.AddStateChangeEvent(taskEvent, pay... | |
c168461 | availabilityZone, containerInstanceArn, false))
muxRouter.HandleFunc(v2.TaskWithTagsMetadataPathWithSlash, v2.TaskContainerMetadataHandler(state, ecsClient, cluster, availabilityZone, containerInstanceArn, true))
muxRouter.HandleFunc(v2.ContainerStatsPath, v2.TaskContainerStatsHandler(state, statsEngine))
muxRouter... | |
c168462 |
muxRouter.HandleFunc(v3.TaskWithTagsMetadataPath, v3.TaskMetadataHandler(state, ecsClient, cluster, availabilityZone, containerInstanceArn, true))
muxRouter.HandleFunc(v3.ContainerStatsPath, v3.ContainerStatsHandler(state, statsEngine))
muxRouter.HandleFunc(v3.TaskStatsPath, v3.TaskStatsHandler(state, statsEngine))... | |
c168463 | mock.recorder = &MockProviderMockRecorder{mock}
return mock
} | |
c168464 | m.ctrl.Call(m, "IsExpired")
ret0, _ := ret[0].(bool)
return ret0
} | |
c168465 | "IsExpired", reflect.TypeOf((*MockProvider)(nil).IsExpired))
} | |
c168466 | := ret[0].(credentials.Value)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168467 | {
mock := &MockContainerMetadataResolver{ctrl: ctrl}
mock.recorder = &MockContainerMetadataResolverMockRecorder{mock}
return mock
} | |
c168468 | _ := ret[0].(*container.DockerContainer)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168469 | reflect.TypeOf((*MockContainerMetadataResolver)(nil).ResolveContainer), arg0)
} | |
c168470 | _ := ret[0].(*task.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168471 | task.GetExecutionStoppedAt(); !timestamp.IsZero() {
resp.ExecutionStoppedAt = aws.Time(timestamp.UTC())
}
containerNameToDockerContainer, ok := state.ContainerMapByArn(task.Arn)
if !ok {
seelog.Warnf("V2 task response: unable to get container name mapping for task '%s'",
task.Arn)
return resp, nil
}
eni... | |
c168472 |
return nil, errors.Errorf(
"v2 container response: unable to find task for container '%s'", containerID)
}
resp := newContainerResponse(dockerContainer, task.GetTaskENI(), state)
return &resp, nil
} | |
c168473 | flagset.Bool(ecsAttributesFlagName, false, ecsAttributesUsage),
WindowsService: flagset.Bool(windowsServiceFlagName, false, windowsServiceUsage),
}
err := flagset.Parse(arguments)
if err != nil {
return nil, err
}
return args, nil
} | |
c168474 | DefaultImageCleanupTimeInterval,
NumImagesToDeletePerCycle: DefaultNumImagesToDeletePerCycle,
NumNonECSContainersToDeletePerCycle: DefaultNumNonECSContainersToDeletePerCycle,
ContainerMetadataEnabled: false,
TaskCPUMemLimit: ExplicitlyDisabled,
PlatformVariable... | |
c168475 | Dial: (&net.Dialer{
Timeout: defaultDialTimeout,
KeepAlive: defaultDialKeepalive,
}).Dial,
TLSHandshakeTimeout: 10 * time.Second,
}
transport.TLSClientConfig = &tls.Config{}
cipher.WithSupportedCipherSuites(transport.TLSClientConfig)
transport.TLSClientConfig.InsecureSkipVerify = insecureSkipVerify
... | |
c168476 | return arr
}
return append(arr[0:ndx], arr[ndx+1:]...)
} | |
c168477 |
platformFields := PlatformFields{
CpuUnbounded: cfg.PlatformVariables.CPUUnbounded,
}
task.PlatformFields = platformFields
} | |
c168478 | all, and CPU unbounded
// tasks are allowed for windows, let CPU percent be zero.
// this is a workaround to allow CPU unbounded tasks(https://github.com/aws/amazon-ecs-agent/issues/1127)
hostConfig.CPUPercent = minimumCPUPercent
}
hostConfig.CPUShares = 0
return nil
} | |
c168479 | := range eniAttachmentStatusMap {
if v == *eni {
return k
}
}
return "NONE"
} | |
c168480 | "./api/api-2.json"
var err error
if typesOnly {
err = genTypesOnlyAPI(apiFile)
} else {
err = genFull(apiFile)
}
if err != nil {
fmt.Println(err)
return 1
}
return 0
} | |
c168481 | int(math.Pow(2, float64(r.RetryCount))) * (rand.Intn(30) + 30)
return time.Duration(delay) * time.Millisecond
}
return 5 * time.Minute
} | |
c168482 | mock.recorder = &MockTimeMockRecorder{mock}
return mock
} | |
c168483 | {
ret := m.ctrl.Call(m, "After", arg0)
ret0, _ := ret[0].(<-chan time.Time)
return ret0
} | |
c168484 | {
ret := m.ctrl.Call(m, "AfterFunc", arg0, arg1)
ret0, _ := ret[0].(ttime.Timer)
return ret0
} | |
c168485 | _ := ret[0].(time.Time)
return ret0
} | |
c168486 | "Now", reflect.TypeOf((*MockTime)(nil).Now))
} | |
c168487 | m.ctrl.Call(m, "Sleep", arg0)
} | |
c168488 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sleep", reflect.TypeOf((*MockTime)(nil).Sleep), arg0)
} | |
c168489 | mock.recorder = &MockTimerMockRecorder{mock}
return mock
} | |
c168490 |
ret := m.ctrl.Call(m, "Reset", arg0)
ret0, _ := ret[0].(bool)
return ret0
} | |
c168491 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTimer)(nil).Reset), arg0)
} | |
c168492 | := ret[0].(bool)
return ret0
} | |
c168493 | "Stop", reflect.TypeOf((*MockTimer)(nil).Stop))
} | |
c168494 | cs,
config: cfg,
fs: os.Default,
httpclient: httpclient.New(updateDownloadTimeout, false),
}
cs.AddRequestHandler(singleUpdater.stageUpdateHandler())
cs.AddRequestHandler(singleUpdater.performUpdateHandler(saver, taskEngine))
} | |
c168495 | return dg.sdkClientFactory.GetDefaultClient()
}
return dg.sdkClientFactory.GetClient(dg.version)
} | |
c168496 | to zero time instant
startTime, _ := time.Parse(time.RFC3339, state.StartedAt)
if startTime.IsZero() && state.Error == "" {
return apicontainerstatus.ContainerCreated
}
return apicontainerstatus.ContainerStopped
} | |
c168497 | metadata.NetworkMode = string(dockerContainer.HostConfig.NetworkMode)
}
if dockerContainer.Config != nil {
metadata.Labels = dockerContainer.Config.Labels
}
if dockerContainer.State == nil {
return metadata
}
if !dockerContainer.State.Running && !finishedTime.IsZero() {
// Only record an exitcode if it ... | |
c168498 | to reopen channel to continue listening
seelog.Errorf("DockerGoClient: error while listening to Docker Events : %v", err)
nextCtx, nextCancel := context.WithCancel(ctx)
dockerEvents, eventErr = client.Events(nextCtx, types.EventsOptions{})
// Cache the event from docker client.
go buffer.Start... | |
c168499 | it has timed out,
// send back the DockerTimeoutError
err := ctx.Err()
if err == context.DeadlineExceeded {
return ListContainersResponse{Error: &DockerTimeoutError{timeout, "listing"}}
}
return ListContainersResponse{Error: &CannotListContainersError{err}}
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.