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
// loade... | |
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... | |
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, ... | |
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, con... | |
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... | |
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",
mt... | |
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
// w... | |
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; {
ti... | |
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.Co... | |
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 no... | |
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[docker... | |
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) ... | |
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.RequestTypeContainerMetad... | |
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, errorEven... | |
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.retrieveSSMSe... | |
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.RequestTypeContainerMetada... | |
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.HealthStatusS... | |
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.Contain... | |
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.DockerContainerMeta... | |
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)
er... | |
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 w... | |
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]",
... | |
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.sa... | |
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.