id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c169100 | error {
ret := m.ctrl.Call(m, "RemoveImage", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | |
c169101 | {
ret := m.ctrl.Call(m, "StopContainer", arg0, arg1, arg2)
ret0, _ := ret[0].(dockerapi.DockerContainerMetadata)
return ret0
} | |
c169102 | m.ctrl.Call(m, "WithVersion", arg0)
ret0, _ := ret[0].(dockerapi.DockerClient)
return ret0
} | |
c169103 | mock.recorder = &MockCacheMockRecorder{mock}
return mock
} | |
c169104 | string) {
m.ctrl.Call(m, "Delete", arg0)
} | |
c169105 | _ := ret[0].(async.Value)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c169106 | async.Value) {
m.ctrl.Call(m, "Set", arg0, arg1)
} | |
c169107 | "Set", reflect.TypeOf((*MockCache)(nil).Set), arg0, arg1)
} | |
c169108 | saver: engine.saver,
credentialsManager: engine.credentialsManager,
cniClient: engine.cniClient,
taskStopWG: engine.taskStopGroup,
steadyStatePollInterval: engine.taskSteadyStatePollInterval,
}
engine.managedTasks[task.Arn] = t
return t
} | |
c169109 | able to move some containers along.
seelog.Debugf("Managed task [%s]: task not steady state or terminal; progressing it",
mtask.Arn)
mtask.progressTask()
}
// If we reach this point, we've changed the task in some way.
// Conversely, for it to spin in steady state it will have to have been
// loaded in steady state or progressed through here, so saving here should
// be sufficient to capture state changes.
err := mtask.saver.Save()
if err != nil {
seelog.Warnf("Managed task [%s]: unable to checkpoint task's states to disk: %v",
mtask.Arn, err)
}
if mtask.GetKnownStatus().Terminal() {
break
}
}
// We only break out of the above if this task is known to be stopped. Do
// onetime cleanup here, including removing the task after a timeout
seelog.Debugf("Managed task [%s]: task has reached stopped. Waiting for container cleanup", mtask.Arn)
mtask.cleanupCredentials()
if mtask.StopSequenceNumber != 0 {
seelog.Debugf("Managed task [%s]: marking done for this sequence: %d",
mtask.Arn, mtask.StopSequenceNumber)
mtask.taskStopWG.Done(mtask.StopSequenceNumber)
}
// TODO: make this idempotent on agent restart
go mtask.releaseIPInIPAM()
mtask.cleanupTask(mtask.cfg.TaskCleanupWaitDuration)
} | |
c169110 | container, "")
}
mtask.emitTaskEvent(mtask.Task, "")
} | |
c169111 | // If we end up here, that means we received a start then stop for this
// task before a task that was expected to stop before it could
// actually stop
break
}
}
seelog.Infof("Managed task [%s]: wait over; ready to move towards status: %s",
mtask.Arn, mtask.GetDesiredStatus().String())
} | |
c169112 |
defer cancel()
timedOut := mtask.waitEvent(timeoutCtx.Done())
if timedOut {
seelog.Debugf("Managed task [%s]: checking to make sure it's still at steadystate", mtask.Arn)
go mtask.engine.checkTaskState(mtask.Task)
}
} | |
c169113 |
return false
default:
taskKnownStatus := mtask.GetKnownStatus()
return taskKnownStatus == apitaskstatus.TaskRunning && taskKnownStatus >= mtask.GetDesiredStatus()
}
} | |
c169114 |
if taskCredentialsID != "" {
mtask.credentialsManager.RemoveCredentials(taskCredentialsID)
}
} | |
c169115 | seelog.Debugf("Managed task [%s]: got container [%s] event: [%s]",
mtask.Arn, dockerChange.container.Name, dockerChange.event.Status.String())
mtask.handleContainerChange(dockerChange)
return false
case resChange := <-mtask.resourceStateChangeEvent:
res := resChange.resource
seelog.Debugf("Managed task [%s]: got resource [%s] event: [%s]",
mtask.Arn, res.GetName(), res.StatusString(resChange.nextState))
mtask.handleResourceStateChange(resChange)
return false
case <-stopWaiting:
seelog.Debugf("Managed task [%s]: no longer waiting", mtask.Arn)
return true
}
} | |
c169116 | return
}
seelog.Debugf("Managed task [%s]: error while transitioning resource %s to %s: %v",
mtask.Arn, res.GetName(), res.StatusString(status), err)
if status == res.SteadyState() {
seelog.Errorf("Managed task [%s]: error while creating resource %s, setting the task's desired status to STOPPED",
mtask.Arn, res.GetName())
mtask.SetDesiredStatus(apitaskstatus.TaskStopped)
mtask.Task.SetTerminalReason(res.GetTerminalReason())
mtask.engine.saver.Save()
}
} | |
c169117 | change event for container [%s]: %v",
task.Arn, cont.Name, err)
return
}
seelog.Infof("Managed task [%s]: sending container change event [%s]: %s",
mtask.Arn, cont.Name, event.String())
mtask.stateChangeEvents <- event
seelog.Infof("Managed task [%s]: sent container change event [%s]: %s",
mtask.Arn, cont.Name, event.String())
} | |
c169118 | mtask.Arn, err)
return
}
err = mtask.cniClient.ReleaseIPResource(cfg)
if err != nil {
seelog.Warnf("Managed task [%s]: failed to release ip; IPAM error: %v",
mtask.Arn, err)
return
}
} | |
c169119 | that it will be driven back to stopped
mtask.unexpectedStart.Do(func() {
seelog.Warnf("Managed task [%s]: stopped container [%s] came back; re-stopping it once",
mtask.Arn, container.Name)
go mtask.engine.transitionContainer(mtask.Task, container, apicontainerstatus.ContainerStopped)
// This will not proceed afterwards because status <= knownstatus below
})
} | |
c169120 | container.SetDesiredStatus(apicontainerstatus.ContainerStopped)
return false
default:
// If this is a * -> RUNNING / RESOURCES_PROVISIONED transition, we need to stop
// the container.
seelog.Warnf("Managed task [%s]: error starting/provisioning container[%s]; marking its desired status as STOPPED: %v",
mtask.Arn, container.Name, event.Error)
container.SetKnownStatus(currentKnownStatus)
container.SetDesiredStatus(apicontainerstatus.ContainerStopped)
errorName := event.Error.ErrorName()
if errorName == dockerapi.DockerTimeoutErrorName || errorName == dockerapi.CannotInspectContainerErrorName {
// If there's an error with inspecting the container or in case of timeout error,
// we'll also assume that the container has transitioned to RUNNING and issue
// a stop. See #1043 for details
seelog.Warnf("Managed task [%s]: forcing container [%s] to stop",
mtask.Arn, container.Name)
go mtask.engine.transitionContainer(mtask.Task, container, apicontainerstatus.ContainerStopped)
}
// Container known status not changed, no need for further processing
return false
}
} | |
c169121 | return false
}
// If we were trying to transition to stopped and had an error, we
// clearly can't just continue trying to transition it to stopped
// again and again. In this case, assume it's stopped (or close
// enough) and get on with it
// This can happen in cases where the container we tried to stop
// was already stopped or did not exist at all.
seelog.Warnf("Managed task [%s]: 'docker stop' for container [%s] returned %s: %s",
mtask.Arn, container.Name, event.Error.ErrorName(), event.Error.Error())
container.SetKnownStatus(apicontainerstatus.ContainerStopped)
container.SetDesiredStatus(apicontainerstatus.ContainerStopped)
return true
} | |
c169122 | conditions "HEALTHY" and "SUCCESS" to succeed.
if !atLeastOneTransitionStarted && blockedByOrderingDependencies {
go mtask.engine.checkTaskState(mtask.Task)
ctx, cancel := context.WithTimeout(context.Background(), transitionPollTime)
defer cancel()
for timeout := mtask.waitEvent(ctx.Done()); !timeout; {
timeout = mtask.waitEvent(ctx.Done())
}
return
}
// combine the resource and container transitions
transitions := make(map[string]string)
for k, v := range resTransitions {
transitions[k] = v
}
for k, v := range contTransitions {
transitions[k] = v.String()
}
// We've kicked off one or more transitions, wait for them to
// complete, but keep reading events as we do. in fact, we have to for
// transitions to complete
mtask.waitForTransition(transitions, transitionChange, transitionChangeEntity)
// update the task status
changed := mtask.UpdateStatus()
if changed {
seelog.Debugf("Managed task [%s]: container or resource change also resulted in task change", mtask.Arn)
// If knownStatus changed, let it be known
var taskStateChangeReason string
if mtask.GetKnownStatus().Terminal() {
taskStateChangeReason = mtask.Task.GetTerminalReason()
}
mtask.emitTaskEvent(mtask.Task, taskStateChangeReason)
}
} | |
c169123 | timeoutCancel()
timedOut := mtask.waitEvent(timeoutCtx.Done())
if timedOut {
seelog.Debugf("Managed task [%s]: timed out waiting for acs credentials message", mtask.Arn)
}
return true
}
}
return false
} | |
c169124 | calling any docker API, send in
// a goroutine so that it won't block here before the waitForContainerTransition
// was called after this function. And all the events sent to mtask.dockerMessages
// will be handled by handleContainerChange.
go func(cont *apicontainer.Container, status apicontainerstatus.ContainerStatus) {
mtask.dockerMessages <- dockerContainerChange{
container: cont,
event: dockerapi.DockerContainerChangeEvent{
Status: status,
},
}
}(cont, transition.nextState)
continue
}
transitions[cont.Name] = transition.nextState
go transitionFunc(cont, transition.nextState)
}
return anyCanTransition, blocked, transitions, reasons
} | |
c169125 | required for the transition, just set the known status without
// calling any transition function
go mtask.emitResourceChange(resourceStateChange{
resource: res,
nextState: transition.nextState,
err: nil,
})
continue
}
// At least one resource is able to be move forwards, so we're not deadlocked
transitions[res.GetName()] = transition.status
go transitionFunc(res, transition.nextState)
}
return anyCanTransition, transitions
} | |
c169126 | to)
if mtask.engine.isTaskManaged(mtask.Arn) {
mtask.emitResourceChange(resourceStateChange{
resource: resource,
nextState: to,
err: err,
})
}
} | |
c169127 | [%s]: %v",
mtask.Arn, resName, resStatus, err)
return err
}
seelog.Debugf("Managed task [%s]: transitioned resource [%s] to [%s]",
mtask.Arn, resName, resStatus)
return nil
} | |
c169128 | mtask.Arn, sentStatus.String(), i+1, _maxStoppedWaitTimes)
mtask._time.Sleep(_stoppedSentWaitInterval)
}
stoppedSentBool <- struct{}{}
close(stoppedSentBool)
}()
// wait for apitaskstatus.TaskStopped to be sent
for !mtask.waitEvent(stoppedSentBool) {
}
return taskStopped
} | |
c169129 | clients: findDockerVersions(ctx, endpoint),
}
} | |
c169130 | dockerclient.DockerVersion(client.ClientVersion())
} | |
c169131 | errors.New("docker client factory: client not found for docker version: " + string(version))
}
return client, nil
} | |
c169132 | defer cancel()
serverVersion, err := client.ServerVersion(derivedCtx)
if err == nil {
apiVersion = serverVersion.APIVersion
// check if the docker.Version has MinAPIVersion value
if serverVersion.MinAPIVersion != "" {
minAPIVersion = serverVersion.MinAPIVersion
}
}
}
clients := make(map[dockerclient.DockerVersion]sdkclient.Client)
for _, version := range dockerclient.GetKnownAPIVersions() {
dockerClient, err := getDockerClientForVersion(endpoint, string(version), minAPIVersion, apiVersion, ctx)
if err != nil {
log.Infof("Unable to get Docker client for version %s: %v", version, err)
continue
}
clients[version] = dockerClient
}
return clients
} | |
c169133 | received from agent. Windows SCM will not restart the AmazonECS service.")
// We override the exit code to 0 here so that Windows does not treat this as a restartable failure even
// when "sc.exe failureflag" is set.
exitCode = 0
}
indicator.agentStopped(exitCode)
}()
sleepCtx(agentCtx, time.Minute) // give the agent a minute to start and invoke terminationHandler
// wait for the termination handler to run. Once the termination handler runs, we can safely exit. If the agent
// exits by itself, the termination handler doesn't need to do anything and skips. If the agent exits before the
// termination handler is invoked, we can exit immediately.
return indicator.wait()
} | |
c169134 | time.Now().Add(duration))
<-derivedCtx.Done()
} | |
c169135 |
for _, containerResponse := range taskResponse.Containers {
networks, err := GetContainerNetworkMetadata(containerResponse.ID, state)
if err != nil {
errResponseJSON, _ := json.Marshal(err.Error())
utils.WriteJSONToResponse(w, http.StatusBadRequest, errResponseJSON, utils.RequestTypeContainerMetadata)
return
}
containerResponse.Networks = networks
responses = append(responses, containerResponse)
}
taskResponse.Containers = responses
}
responseJSON, _ := json.Marshal(taskResponse)
utils.WriteJSONToResponse(w, http.StatusOK, responseJSON, utils.RequestTypeTaskMetadata)
}
} | |
c169136 |
return fmt.Errorf("handler %s already exists", name)
}
eventStream.handlers[name] = handler
return nil
} | |
c169137 | listeners...", eventStream.name)
for _, handlerFunc := range eventStream.handlers {
go handlerFunc(event)
}
} | |
c169138 | from event stream %s", handler, eventStream.name)
delete(eventStream.handlers, handler)
return
}
}
} | |
c169139 | return fmt.Errorf("Event stream is closed")
}
eventStream.event <- event
return nil
} | |
c169140 | case <-eventStream.ctx.Done():
seelog.Infof("Event stream %s stopped listening...", eventStream.name)
eventStream.statusLock.Lock()
eventStream.open = false
close(eventStream.event)
eventStream.statusLock.Unlock()
return
}
}
} | |
c169141 | eventStream.open = true
go eventStream.listen()
} | |
c169142 | defer levelLock.Unlock()
level = parsedLevel
reloadConfig()
}
} | |
c169143 | logger.New("module", module)
} | |
c169144 |
mock.recorder = &MockWebsocketConnMockRecorder{mock}
return mock
} | |
c169145 | := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | |
c169146 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockWebsocketConn)(nil).SetWriteDeadline), arg0)
} | |
c169147 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0)
} | |
c169148 | ssmSecrets,
credentialsManager: credentialsManager,
executionCredentialsID: executionCredentialsID,
ssmClientCreator: ssmClientCreator,
}
s.initStatusToTransition()
return s
} | |
c169149 | for containers in task: [%s]", secret.taskARN)
secret.secretData = make(map[string]string)
for region, secrets := range secret.getRequiredSecrets() {
wg.Add(1)
// Spin up goroutine each region to speed up processing time
go secret.retrieveSSMSecretValuesByRegion(region, secrets, iamCredentials, &wg, errorEvents)
}
wg.Wait()
// Get the first error returned and set as terminal reason
select {
case err := <-errorEvents:
secret.setTerminalReason(err.Error())
return err
default:
return nil
}
} | |
c169150 | total += len(secrets)/MaxBatchNum + 1
}
return total
} | |
c169151 | secretNamesTmp := make([]string, MaxBatchNum)
copy(secretNamesTmp, secretNames)
wgPerRegion.Add(1)
go secret.retrieveSSMSecretValues(region, secretNamesTmp, iamCredentials, &wgPerRegion, errorEvents)
secretNames = []string{}
}
}
if len(secretNames) > 0 {
wgPerRegion.Add(1)
go secret.retrieveSSMSecretValues(region, secretNames, iamCredentials, &wgPerRegion, errorEvents)
}
wgPerRegion.Wait()
} | |
c169152 | %s: %v", region, err)
return
}
secret.lock.Lock()
defer secret.lock.Unlock()
// put secret value in secretData
for secretName, secretValue := range secValueMap {
secretKey := secretName + "_" + region
secret.secretData[secretKey] = secretValue
}
} | |
c169153 | secret.secretData {
delete(secret.secretData, key)
}
} | |
c169154 |
defer secret.lock.RUnlock()
s, ok := secret.secretData[secretKey]
return s, ok
} | |
c169155 | {
secret.secretData = make(map[string]string)
}
secret.secretData[secretKey] = secretValue
} | |
c169156 |
ret0, _ := ret[0].(error)
return ret0
} | |
c169157 | "SetAvailabilityZone", arg0)
} | |
c169158 | "SetContainerInstanceARN", arg0)
} | |
c169159 | "SetHostPublicIPv4Address", arg0)
} | |
c169160 | {
mock := &MockDockerMetadataClient{ctrl: ctrl}
mock.recorder = &MockDockerMetadataClientMockRecorder{mock}
return mock
} | |
c169161 | reflect.TypeOf((*MockDockerMetadataClient)(nil).InspectContainer), arg0, arg1, arg2)
} | |
c169162 | len(keyMap))
ndx := 0
for k := range keyMap {
keys[ndx] = k
ndx++
}
return keys, nil
} | |
c169163 | container '%s'", containerID)
WriteContainerMetadataResponse(w, containerID, state)
return
}
seelog.Infof("V2 task/container metadata handler: writing response for task '%s'", taskARN)
WriteTaskMetadataResponse(w, taskARN, cluster, state, ecsClient, az, containerInstanceArn, propagateTags)
}
} | |
c169164 | generate metadata for container '" + containerID + "'")
utils.WriteJSONToResponse(w, http.StatusBadRequest, errResponseJSON, utils.RequestTypeContainerMetadata)
return
}
responseJSON, _ := json.Marshal(containerResponse)
utils.WriteJSONToResponse(w, http.StatusOK, responseJSON, utils.RequestTypeContainerMetadata)
} | |
c169165 | generate metadata for task: '" + taskARN + "'")
utils.WriteJSONToResponse(w, http.StatusBadRequest, errResponseJSON, utils.RequestTypeTaskMetadata)
return
}
responseJSON, _ := json.Marshal(taskResponse)
utils.WriteJSONToResponse(w, http.StatusOK, responseJSON, utils.RequestTypeTaskMetadata)
} | |
c169166 |
Root: config.DefaultTaskCgroupPrefix,
Specs: &specs.LinuxResources{},
}
_, err := c.Create(cgroupSpec)
return err
} | |
c169167 | + ": null"
}
return typeStr + ": " + *str
}
}
}
if asErr, ok := err.ErrObj.(error); ok {
return err.Type + ": " + asErr.Error()
}
return err.Type + ": Unknown error (" + typeStr + ")"
} | |
c169168 | reflect.TypeOf(err.ErrObj) == reflect.TypeOf(unretriable) {
return false
}
}
return true
} | |
c169169 | {
mock := &MockDockerStateResolver{ctrl: ctrl}
mock.recorder = &MockDockerStateResolverMockRecorder{mock}
return mock
} | |
c169170 | reflect.TypeOf((*MockDockerStateResolver)(nil).State))
} | |
c169171 | err)
return exitcodes.ExitError
}
fmt.Println(text)
return exitcodes.ExitSuccess
} | |
c169172 | path cgroups.Path) (cgroups.Cgroup, error) {
return cgroups.Load(hierarchy, path)
} | |
c169173 | specs *specs.LinuxResources) (cgroups.Cgroup, error) {
return cgroups.New(hierarchy, path, specs)
} | |
c169174 | {
case <-ch:
return
default:
fp()
}
}
} | |
c169175 | return engine.state.UnmarshalJSON(data)
} | |
c169176 | we can be up to date.
err := engine.openEventstream(derivedCtx)
if err != nil {
return err
}
engine.synchronizeState()
// Now catch up and start processing new events per normal
go engine.handleDockerEvents(derivedCtx)
engine.initialized = true
return nil
} | |
c169177 | {
if engine.initialized {
return nil
}
err := engine.Init(ctx)
if err != nil {
errorOnce.Do(func() {
seelog.Errorf("Task engine: could not connect to docker daemon: %v", err)
})
}
return err
})
} | |
c169178 | engine.tasksLock.RUnlock()
_, ok := engine.managedTasks[arn]
return ok
} | |
c169179 | }
tasks := engine.state.AllTasks()
tasksToStart := engine.filterTasksToStartUnsafe(tasks)
for _, task := range tasks {
task.InitializeResources(engine.resourceFields)
}
for _, task := range tasksToStart {
engine.startTask(task)
}
engine.saver.Save()
} | |
c169180 | = append(tasksToStart, task)
// Put tasks that are stopped by acs but hasn't been stopped in wait group
if task.GetDesiredStatus().Terminal() && task.GetStopSequenceNumber() != 0 {
engine.taskStopGroup.Add(task.GetStopSequenceNumber(), 1)
}
}
return tasksToStart
} | |
c169181 |
if metadata.ExitCode != nil {
container.SetKnownExitCode(metadata.ExitCode)
}
// Set port mappings
if len(metadata.PortBindings) != 0 && len(container.GetKnownPortBindings()) == 0 {
container.SetKnownPortBindings(metadata.PortBindings)
}
// update the container health information
if container.HealthStatusShouldBeReported() {
container.SetHealthStatus(metadata.Health)
}
container.SetNetworkMode(metadata.NetworkMode)
container.SetNetworkSettings(metadata.NetworkSettings)
} | |
c169182 | {
container.Container.ApplyingError = apierrors.NewNamedError(&ContainerVanishedError{})
engine.imageManager.RemoveContainerReferenceFromImageState(container.Container)
}
} else {
// If this is a container state error
updateContainerMetadata(&metadata, container.Container, task)
container.Container.ApplyingError = apierrors.NewNamedError(metadata.Error)
}
} else {
// update the container metadata in case the container status/metadata changed during agent restart
updateContainerMetadata(&metadata, container.Container, task)
engine.imageManager.RecordContainerReference(container.Container)
if engine.cfg.ContainerMetadataEnabled && !container.Container.IsMetadataFileUpdated() {
go engine.updateMetadataFile(task, container)
}
}
if currentState > container.Container.GetKnownStatus() {
// update the container known status
container.Container.SetKnownStatus(currentState)
}
// Update task ExecutionStoppedAt timestamp
task.RecordExecutionStoppedAt(container.Container)
} | |
c169183 | engine.tasksLock.RUnlock()
if ok {
managedTask.emitDockerContainerChange(dockerContainerChange{
container: container,
event: dockerapi.DockerContainerChangeEvent{
Status: status,
DockerContainerMetadata: metadata,
},
})
}
}
} | |
c169184 | %v",
task.Arn, cont.Name, err)
}
}
// Clean metadata directory for task
if engine.cfg.ContainerMetadataEnabled {
err := engine.metadataManager.Clean(task.Arn)
if err != nil {
seelog.Warnf("Task engine [%s]: clean task metadata failed: %v", task.Arn, err)
}
}
engine.saver.Save()
} | |
c169185 | a goroutine to oversee this task
thisTask := engine.newManagedTask(task)
thisTask._time = engine.time()
go thisTask.overseeTask()
} | |
c169186 | err := engine.client.ContainerEvents(ctx)
if err != nil {
return err
}
engine.events = events
return nil
} | |
c169187 | select {
case <-ctx.Done():
return
case event := <-engine.events:
engine.handleDockerEvent(event)
}
}
} | |
c169188 | event.Type == apicontainer.ContainerHealthEvent {
if cont.Container.HealthStatusShouldBeReported() {
seelog.Debugf("Task engine: updating container [%s(%s)] health status: %v",
cont.Container.Name, cont.DockerID, event.DockerContainerMetadata.Health)
cont.Container.SetHealthStatus(event.DockerContainerMetadata.Health)
}
return
}
engine.tasksLock.RLock()
managedTask, ok := engine.managedTasks[task.Arn]
// hold the lock until the message is sent so we don't send on a closed channel
defer engine.tasksLock.RUnlock()
if !ok {
seelog.Criticalf("Task engine: could not find managed task [%s] corresponding to a docker event: %s",
task.Arn, event.String())
return
}
seelog.Debugf("Task engine [%s]: writing docker event to the task: %s",
task.Arn, event.String())
managedTask.emitDockerContainerChange(dockerContainerChange{container: cont.Container, event: event})
seelog.Debugf("Task engine [%s]: wrote docker event to the task: %s",
task.Arn, event.String())
} | |
c169189 |
engine.state.AddTask(task)
if dependencygraph.ValidDependencies(task) {
engine.startTask(task)
} else {
seelog.Errorf("Task engine [%s]: unable to progress task with circular dependencies", task.Arn)
task.SetKnownStatus(apitaskstatus.TaskStopped)
task.SetDesiredStatus(apitaskstatus.TaskStopped)
err := TaskDependencyError{task.Arn}
engine.emitTaskEvent(task, err.Error())
}
return
}
// Update task
engine.updateTaskUnsafe(existingTask, task)
} | |
c169190 | return engine.state.AllTasks(), nil
} | |
c169191 |
return engine.state.TaskByArn(arn)
} | |
c169192 | && imageState.GetPullSucceeded() {
seelog.Infof("Task engine [%s]: image %s for container %s has been pulled once, not pulling it again",
taskArn, container.Image, container.Name)
return false
}
return true
case config.ImagePullPreferCachedBehavior:
// If the behavior is prefer cached, don't pull if we found cached image
// by inspecting the image.
_, err := engine.client.InspectImage(container.Image)
if err != nil {
return true
}
seelog.Infof("Task engine [%s]: found cached image %s, use it directly for container %s",
taskArn, container.Image, container.Name)
return false
default:
// Need to pull the image for always and default agent pull behavior
return true
}
} | |
c169193 |
"engine: failed cleanup task network namespace, task: %s", task.String())
}
return engine.cniClient.CleanupNS(engine.ctx, cniConfig, cniCleanupTimeout)
} | |
c169194 | [%s] with seqnum [%d]",
task.Arn, updateDesiredStatus.String(), update.StopSequenceNumber)
managedTask.emitACSTransition(acsTransition{
desiredStatus: updateDesiredStatus,
seqnum: update.StopSequenceNumber,
})
seelog.Debugf("Task engine [%s]: update taken off the acs channel: [%s] with seqnum [%d]",
task.Arn, updateDesiredStatus.String(), update.StopSequenceNumber)
} | |
c169195 | engine.managedTasks[task.Arn]
engine.tasksLock.RUnlock()
if ok {
managedTask.emitDockerContainerChange(dockerContainerChange{
container: container,
event: dockerapi.DockerContainerChangeEvent{
Status: to,
DockerContainerMetadata: metadata,
},
})
}
} | |
c169196 |
if metadata.Error != nil {
seelog.Infof("Task engine [%s]: error transitioning container [%s] to [%s]: %v",
task.Arn, container.Name, nextState.String(), metadata.Error)
} else {
seelog.Debugf("Task engine [%s]: transitioned container [%s] to [%s]",
task.Arn, container.Name, nextState.String())
engine.saver.Save()
}
return metadata
} | |
c169197 | {
return engine.client.Version(engine.ctx, dockerclient.VersionTimeout)
} | |
c169198 | mock.recorder = &MockSSMClientMockRecorder{mock}
return mock
} | |
c169199 | _ := ret[0].(*ssm.GetParametersOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.