_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q169100 | RemoveImage | validation | func (m *MockDockerClient) RemoveImage(arg0 context.Context, arg1 string, arg2 time.Duration) error {
ret := m.ctrl.Call(m, "RemoveImage", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169101 | StopContainer | validation | func (m *MockDockerClient) StopContainer(arg0 context.Context, arg1 string, arg2 time.Duration) dockerapi.DockerContainerMetadata {
ret := m.ctrl.Call(m, "StopContainer", arg0, arg1, arg2)
ret0, _ := ret[0].(dockerapi.DockerContainerMetadata)
return ret0
} | go | {
"resource": ""
} |
q169102 | WithVersion | validation | func (m *MockDockerClient) WithVersion(arg0 dockerclient.DockerVersion) dockerapi.DockerClient {
ret := m.ctrl.Call(m, "WithVersion", arg0)
ret0, _ := ret[0].(dockerapi.DockerClient)
return ret0
} | go | {
"resource": ""
} |
q169103 | NewMockCache | validation | func NewMockCache(ctrl *gomock.Controller) *MockCache {
mock := &MockCache{ctrl: ctrl}
mock.recorder = &MockCacheMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169104 | Delete | validation | func (m *MockCache) Delete(arg0 string) {
m.ctrl.Call(m, "Delete", arg0)
} | go | {
"resource": ""
} |
q169105 | Get | validation | func (m *MockCache) Get(arg0 string) (async.Value, bool) {
ret := m.ctrl.Call(m, "Get", arg0)
ret0, _ := ret[0].(async.Value)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q169106 | Set | validation | func (m *MockCache) Set(arg0 string, arg1 async.Value) {
m.ctrl.Call(m, "Set", arg0, arg1)
} | go | {
"resource": ""
} |
q169107 | Set | validation | func (mr *MockCacheMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCache)(nil).Set), arg0, arg1)
} | go | {
"resource": ""
} |
q169108 | newManagedTask | validation | func (engine *DockerTaskEngine) newManagedTask(task *apitask.Task) *managedTask {
ctx, cancel := context.WithCancel(engine.ctx)
t := &managedTask{
ctx: ctx,
cancel: cancel,
Task: task,
acsMessages: make(chan acsTransition),
dock... | go | {
"resource": ""
} |
q169109 | overseeTask | validation | func (mtask *managedTask) overseeTask() {
// Do a single updatestatus at the beginning to create the container
// `desiredstatus`es which are a construct of the engine used only here,
// not present on the backend
mtask.UpdateStatus()
// If this was a 'state restore', send all unsent statuses
mtask.emitCurrentSta... | go | {
"resource": ""
} |
q169110 | emitCurrentStatus | validation | func (mtask *managedTask) emitCurrentStatus() {
for _, container := range mtask.Containers {
mtask.emitContainerEvent(mtask.Task, container, "")
}
mtask.emitTaskEvent(mtask.Task, "")
} | go | {
"resource": ""
} |
q169111 | waitForHostResources | validation | func (mtask *managedTask) waitForHostResources() {
if mtask.StartSequenceNumber == 0 {
// This is the first transition on this host. No need to wait
return
}
if mtask.GetDesiredStatus().Terminal() {
// Task's desired status is STOPPED. No need to wait in this case either
return
}
seelog.Infof("Managed tas... | go | {
"resource": ""
} |
q169112 | waitSteady | validation | func (mtask *managedTask) waitSteady() {
seelog.Infof("Managed task [%s]: task at steady state: %s", mtask.Arn, mtask.GetKnownStatus().String())
timeoutCtx, cancel := context.WithTimeout(mtask.ctx, mtask.steadyStatePollInterval)
defer cancel()
timedOut := mtask.waitEvent(timeoutCtx.Done())
if timedOut {
seelog... | go | {
"resource": ""
} |
q169113 | steadyState | validation | func (mtask *managedTask) steadyState() bool {
select {
case <-mtask.ctx.Done():
seelog.Info("Context expired. No longer steady.")
return false
default:
taskKnownStatus := mtask.GetKnownStatus()
return taskKnownStatus == apitaskstatus.TaskRunning && taskKnownStatus >= mtask.GetDesiredStatus()
}
} | go | {
"resource": ""
} |
q169114 | cleanupCredentials | validation | func (mtask *managedTask) cleanupCredentials() {
taskCredentialsID := mtask.GetCredentialsID()
if taskCredentialsID != "" {
mtask.credentialsManager.RemoveCredentials(taskCredentialsID)
}
} | go | {
"resource": ""
} |
q169115 | waitEvent | validation | func (mtask *managedTask) waitEvent(stopWaiting <-chan struct{}) bool {
seelog.Debugf("Managed task [%s]: waiting for event for task", mtask.Arn)
select {
case acsTransition := <-mtask.acsMessages:
seelog.Debugf("Managed task [%s]: got acs event", mtask.Arn)
mtask.handleDesiredStatusChange(acsTransition.desiredS... | go | {
"resource": ""
} |
q169116 | handleResourceStateChange | validation | func (mtask *managedTask) handleResourceStateChange(resChange resourceStateChange) {
// locate the resource
res := resChange.resource
if !mtask.isResourceFound(res) {
seelog.Criticalf("Managed task [%s]: state error; invoked with another task's resource [%s]",
mtask.Arn, res.GetName())
return
}
status := r... | go | {
"resource": ""
} |
q169117 | emitContainerEvent | validation | func (mtask *managedTask) emitContainerEvent(task *apitask.Task, cont *apicontainer.Container, reason string) {
event, err := api.NewContainerStateChangeEvent(task, cont, reason)
if err != nil {
seelog.Debugf("Managed task [%s]: unable to create state change event for container [%s]: %v",
task.Arn, cont.Name, er... | go | {
"resource": ""
} |
q169118 | releaseIPInIPAM | validation | func (mtask *managedTask) releaseIPInIPAM() {
if mtask.ENI == nil {
return
}
seelog.Infof("Managed task [%s]: IPAM releasing ip for task eni", mtask.Arn)
cfg, err := mtask.BuildCNIConfig()
if err != nil {
seelog.Warnf("Managed task [%s]: failed to release ip; unable to build cni configuration: %v",
mtask.A... | go | {
"resource": ""
} |
q169119 | handleStoppedToRunningContainerTransition | validation | func (mtask *managedTask) handleStoppedToRunningContainerTransition(status apicontainerstatus.ContainerStatus, container *apicontainer.Container) {
containerKnownStatus := container.GetKnownStatus()
if status > containerKnownStatus {
// Event status is greater than container's known status.
// This is not a backw... | go | {
"resource": ""
} |
q169120 | handleEventError | validation | func (mtask *managedTask) handleEventError(containerChange dockerContainerChange, currentKnownStatus apicontainerstatus.ContainerStatus) bool {
container := containerChange.container
event := containerChange.event
if container.ApplyingError == nil {
container.ApplyingError = apierrors.NewNamedError(event.Error)
}... | go | {
"resource": ""
} |
q169121 | handleContainerStoppedTransitionError | validation | func (mtask *managedTask) handleContainerStoppedTransitionError(event dockerapi.DockerContainerChangeEvent,
container *apicontainer.Container,
currentKnownStatus apicontainerstatus.ContainerStatus) bool {
// If we were trying to transition to stopped and had a timeout error
// from docker, reset the known status to... | go | {
"resource": ""
} |
q169122 | progressTask | validation | func (mtask *managedTask) progressTask() {
seelog.Debugf("Managed task [%s]: progressing containers and resources in task", mtask.Arn)
// max number of transitions length to ensure writes will never block on
// these and if we exit early transitions can exit the goroutine and it'll
// get GC'd eventually
resources... | go | {
"resource": ""
} |
q169123 | isWaitingForACSExecutionCredentials | validation | func (mtask *managedTask) isWaitingForACSExecutionCredentials(reasons []error) bool {
for _, reason := range reasons {
if reason == dependencygraph.CredentialsNotResolvedErr {
seelog.Debugf("Managed task [%s]: waiting for credentials to pull from ECR", mtask.Arn)
timeoutCtx, timeoutCancel := context.WithTimeo... | go | {
"resource": ""
} |
q169124 | startContainerTransitions | validation | func (mtask *managedTask) startContainerTransitions(transitionFunc containerTransitionFunc) (bool, map[string]apicontainer.DependsOn, map[string]apicontainerstatus.ContainerStatus, []error) {
anyCanTransition := false
var reasons []error
blocked := make(map[string]apicontainer.DependsOn)
transitions := make(map[str... | go | {
"resource": ""
} |
q169125 | startResourceTransitions | validation | func (mtask *managedTask) startResourceTransitions(transitionFunc resourceTransitionFunc) (bool, map[string]string) {
anyCanTransition := false
transitions := make(map[string]string)
for _, res := range mtask.GetResources() {
knownStatus := res.GetKnownStatus()
desiredStatus := res.GetDesiredStatus()
if knownS... | go | {
"resource": ""
} |
q169126 | transitionResource | validation | func (mtask *managedTask) transitionResource(resource taskresource.TaskResource,
to resourcestatus.ResourceStatus) {
err := mtask.applyResourceState(resource, to)
if mtask.engine.isTaskManaged(mtask.Arn) {
mtask.emitResourceChange(resourceStateChange{
resource: resource,
nextState: to,
err: err,
... | go | {
"resource": ""
} |
q169127 | applyResourceState | validation | func (mtask *managedTask) applyResourceState(resource taskresource.TaskResource,
nextState resourcestatus.ResourceStatus) error {
resName := resource.GetName()
resStatus := resource.StatusString(nextState)
err := resource.ApplyTransition(nextState)
if err != nil {
seelog.Infof("Managed task [%s]: error transitio... | go | {
"resource": ""
} |
q169128 | waitForStopReported | validation | func (mtask *managedTask) waitForStopReported() bool {
stoppedSentBool := make(chan struct{})
taskStopped := false
go func() {
for i := 0; i < _maxStoppedWaitTimes; i++ {
// ensure that we block until apitaskstatus.TaskStopped is actually sent
sentStatus := mtask.GetSentStatus()
if sentStatus >= apitaskst... | go | {
"resource": ""
} |
q169129 | NewFactory | validation | func NewFactory(ctx context.Context, endpoint string) Factory {
return &factory{
endpoint: endpoint,
clients: findDockerVersions(ctx, endpoint),
}
} | go | {
"resource": ""
} |
q169130 | FindClientAPIVersion | validation | func (f *factory) FindClientAPIVersion(client sdkclient.Client) dockerclient.DockerVersion {
return dockerclient.DockerVersion(client.ClientVersion())
} | go | {
"resource": ""
} |
q169131 | getClient | validation | func (f *factory) getClient(version dockerclient.DockerVersion) (sdkclient.Client, error) {
client, ok := f.clients[version]
if !ok {
return nil, errors.New("docker client factory: client not found for docker version: " + string(version))
}
return client, nil
} | go | {
"resource": ""
} |
q169132 | findDockerVersions | validation | func findDockerVersions(ctx context.Context, endpoint string) map[dockerclient.DockerVersion]sdkclient.Client {
// if the client version returns a MinAPIVersion, use it to return all the
// Docker clients between MinAPIVersion and APIVersion, else try pinging
// the clients in getKnownAPIVersions
var minAPIVersion,... | go | {
"resource": ""
} |
q169133 | runAgent | validation | func (h *handler) runAgent(ctx context.Context) uint32 {
agentCtx, cancel := context.WithCancel(ctx)
indicator := newTermHandlerIndicator()
terminationHandler := func(saver statemanager.Saver, taskEngine engine.TaskEngine) {
// We're using a custom indicator to record that the handler is scheduled to be executed ... | go | {
"resource": ""
} |
q169134 | sleepCtx | validation | func sleepCtx(ctx context.Context, duration time.Duration) {
derivedCtx, _ := context.WithDeadline(ctx, time.Now().Add(duration))
<-derivedCtx.Done()
} | go | {
"resource": ""
} |
q169135 | TaskMetadataHandler | validation | func TaskMetadataHandler(state dockerstate.TaskEngineState, ecsClient api.ECSClient, cluster, az, containerInstanceArn string, propagateTags bool) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
taskARN, err := getTaskARNByRequest(r, state)
if err != nil {
respon... | go | {
"resource": ""
} |
q169136 | Subscribe | validation | func (eventStream *EventStream) Subscribe(name string, handler eventHandler) error {
eventStream.handlersLock.Lock()
defer eventStream.handlersLock.Unlock()
if _, ok := eventStream.handlers[name]; ok {
return fmt.Errorf("handler %s already exists", name)
}
eventStream.handlers[name] = handler
return nil
} | go | {
"resource": ""
} |
q169137 | broadcast | validation | func (eventStream *EventStream) broadcast(event interface{}) {
eventStream.handlersLock.RLock()
defer eventStream.handlersLock.RUnlock()
seelog.Debugf("Event stream %s received events, broadcasting to listeners...", eventStream.name)
for _, handlerFunc := range eventStream.handlers {
go handlerFunc(event)
}
} | go | {
"resource": ""
} |
q169138 | Unsubscribe | validation | func (eventStream *EventStream) Unsubscribe(name string) {
eventStream.handlersLock.Lock()
defer eventStream.handlersLock.Unlock()
for handler := range eventStream.handlers {
if handler == name {
seelog.Debugf("Unsubscribing event handler %s from event stream %s", handler, eventStream.name)
delete(eventStre... | go | {
"resource": ""
} |
q169139 | WriteToEventStream | validation | func (eventStream *EventStream) WriteToEventStream(event interface{}) error {
eventStream.statusLock.RLock()
defer eventStream.statusLock.RUnlock()
if !eventStream.open {
return fmt.Errorf("Event stream is closed")
}
eventStream.event <- event
return nil
} | go | {
"resource": ""
} |
q169140 | listen | validation | func (eventStream *EventStream) listen() {
seelog.Infof("Event stream %s start listening...", eventStream.name)
for {
select {
case event := <-eventStream.event:
eventStream.broadcast(event)
case <-eventStream.ctx.Done():
seelog.Infof("Event stream %s stopped listening...", eventStream.name)
eventStre... | go | {
"resource": ""
} |
q169141 | StartListening | validation | func (eventStream *EventStream) StartListening() {
eventStream.statusLock.Lock()
defer eventStream.statusLock.Unlock()
eventStream.open = true
go eventStream.listen()
} | go | {
"resource": ""
} |
q169142 | SetLevel | validation | func SetLevel(logLevel string) {
parsedLevel, ok := levels[strings.ToLower(logLevel)]
if ok {
levelLock.Lock()
defer levelLock.Unlock()
level = parsedLevel
reloadConfig()
}
} | go | {
"resource": ""
} |
q169143 | ForModule | validation | func ForModule(module string) OldLogger {
once.Do(initLogger)
return logger.New("module", module)
} | go | {
"resource": ""
} |
q169144 | NewMockWebsocketConn | validation | func NewMockWebsocketConn(ctrl *gomock.Controller) *MockWebsocketConn {
mock := &MockWebsocketConn{ctrl: ctrl}
mock.recorder = &MockWebsocketConnMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169145 | ReadMessage | validation | func (m *MockWebsocketConn) ReadMessage() (int, []byte, error) {
ret := m.ctrl.Call(m, "ReadMessage")
ret0, _ := ret[0].(int)
ret1, _ := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | go | {
"resource": ""
} |
q169146 | SetWriteDeadline | validation | func (mr *MockWebsocketConnMockRecorder) SetWriteDeadline(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockWebsocketConn)(nil).SetWriteDeadline), arg0)
} | go | {
"resource": ""
} |
q169147 | Get | validation | func (mr *MockClientMockRecorder) Get(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0)
} | go | {
"resource": ""
} |
q169148 | NewSSMSecretResource | validation | func NewSSMSecretResource(taskARN string,
ssmSecrets map[string][]apicontainer.Secret,
executionCredentialsID string,
credentialsManager credentials.Manager,
ssmClientCreator factory.SSMClientCreator) *SSMSecretResource {
s := &SSMSecretResource{
taskARN: taskARN,
requiredSecrets: ssmSec... | go | {
"resource": ""
} |
q169149 | Create | validation | func (secret *SSMSecretResource) Create() error {
// To fail fast, check execution role first
executionCredentials, ok := secret.credentialsManager.GetTaskCredentials(secret.getExecutionCredentialsID())
if !ok {
// No need to log here. managedTask.applyResourceState already does that
err := errors.New("ssm secr... | go | {
"resource": ""
} |
q169150 | getGoRoutineMaxNum | validation | func (secret *SSMSecretResource) getGoRoutineMaxNum() int {
total := 0
for _, secrets := range secret.requiredSecrets {
total += len(secrets)/MaxBatchNum + 1
}
return total
} | go | {
"resource": ""
} |
q169151 | retrieveSSMSecretValuesByRegion | validation | func (secret *SSMSecretResource) retrieveSSMSecretValuesByRegion(region string, secrets []apicontainer.Secret, iamCredentials credentials.IAMRoleCredentials, wg *sync.WaitGroup, errorEvents chan error) {
seelog.Infof("ssm secret resource: retrieving secrets for region %s in task: [%s]", region, secret.taskARN)
defer ... | go | {
"resource": ""
} |
q169152 | retrieveSSMSecretValues | validation | func (secret *SSMSecretResource) retrieveSSMSecretValues(region string, names []string, iamCredentials credentials.IAMRoleCredentials, wg *sync.WaitGroup, errorEvents chan error) {
defer wg.Done()
ssmClient := secret.ssmClientCreator.NewSSMClient(region, iamCredentials)
seelog.Infof("ssm secret resource: retrieving... | go | {
"resource": ""
} |
q169153 | clearSSMSecretValue | validation | func (secret *SSMSecretResource) clearSSMSecretValue() {
secret.lock.Lock()
defer secret.lock.Unlock()
for key := range secret.secretData {
delete(secret.secretData, key)
}
} | go | {
"resource": ""
} |
q169154 | GetCachedSecretValue | validation | func (secret *SSMSecretResource) GetCachedSecretValue(secretKey string) (string, bool) {
secret.lock.RLock()
defer secret.lock.RUnlock()
s, ok := secret.secretData[secretKey]
return s, ok
} | go | {
"resource": ""
} |
q169155 | SetCachedSecretValue | validation | func (secret *SSMSecretResource) SetCachedSecretValue(secretKey string, secretValue string) {
secret.lock.Lock()
defer secret.lock.Unlock()
if secret.secretData == nil {
secret.secretData = make(map[string]string)
}
secret.secretData[secretKey] = secretValue
} | go | {
"resource": ""
} |
q169156 | Clean | validation | func (m *MockManager) Clean(arg0 string) error {
ret := m.ctrl.Call(m, "Clean", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169157 | SetAvailabilityZone | validation | func (m *MockManager) SetAvailabilityZone(arg0 string) {
m.ctrl.Call(m, "SetAvailabilityZone", arg0)
} | go | {
"resource": ""
} |
q169158 | SetContainerInstanceARN | validation | func (m *MockManager) SetContainerInstanceARN(arg0 string) {
m.ctrl.Call(m, "SetContainerInstanceARN", arg0)
} | go | {
"resource": ""
} |
q169159 | SetHostPublicIPv4Address | validation | func (m *MockManager) SetHostPublicIPv4Address(arg0 string) {
m.ctrl.Call(m, "SetHostPublicIPv4Address", arg0)
} | go | {
"resource": ""
} |
q169160 | NewMockDockerMetadataClient | validation | func NewMockDockerMetadataClient(ctrl *gomock.Controller) *MockDockerMetadataClient {
mock := &MockDockerMetadataClient{ctrl: ctrl}
mock.recorder = &MockDockerMetadataClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169161 | InspectContainer | validation | func (mr *MockDockerMetadataClientMockRecorder) InspectContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockDockerMetadataClient)(nil).InspectContainer), arg0, arg1, arg2)
} | go | {
"resource": ""
} |
q169162 | JsonKeys | validation | func JsonKeys(b []byte) ([]string, error) {
var keyMap map[string]interface{}
err := json.Unmarshal(b, &keyMap)
if err != nil {
return []string{}, err
}
keys := make([]string, len(keyMap))
ndx := 0
for k := range keyMap {
keys[ndx] = k
ndx++
}
return keys, nil
} | go | {
"resource": ""
} |
q169163 | TaskContainerMetadataHandler | validation | func TaskContainerMetadataHandler(state dockerstate.TaskEngineState, ecsClient api.ECSClient, cluster, az, containerInstanceArn string, propagateTags bool) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
taskARN, err := getTaskARNByRequest(r, state)
if err != nil {
... | go | {
"resource": ""
} |
q169164 | WriteContainerMetadataResponse | validation | func WriteContainerMetadataResponse(w http.ResponseWriter, containerID string, state dockerstate.TaskEngineState) {
containerResponse, err := NewContainerResponse(containerID, state)
if err != nil {
errResponseJSON, _ := json.Marshal("Unable to generate metadata for container '" + containerID + "'")
utils.WriteJS... | go | {
"resource": ""
} |
q169165 | WriteTaskMetadataResponse | validation | func WriteTaskMetadataResponse(w http.ResponseWriter, taskARN string, cluster string, state dockerstate.TaskEngineState, ecsClient api.ECSClient, az, containerInstanceArn string, propagateTags bool) {
// Generate a response for the task
taskResponse, err := NewTaskResponse(taskARN, state, ecsClient, cluster, az, cont... | go | {
"resource": ""
} |
q169166 | Init | validation | func (c *control) Init() error {
seelog.Infof("Creating root ecs cgroup: %s", config.DefaultTaskCgroupPrefix)
// Build cgroup spec
cgroupSpec := &Spec{
Root: config.DefaultTaskCgroupPrefix,
Specs: &specs.LinuxResources{},
}
_, err := c.Create(cgroupSpec)
return err
} | go | {
"resource": ""
} |
q169167 | Error | validation | func (err *WSError) Error() string {
val := reflect.ValueOf(err.ErrObj)
if val.Kind() == reflect.Ptr {
val = val.Elem()
}
var typeStr = "Unknown type"
if val.IsValid() {
typeStr = val.Type().Name()
msg := val.FieldByName("Message_")
if msg.IsValid() && msg.CanInterface() {
str, ok := msg.Interface().(*s... | go | {
"resource": ""
} |
q169168 | Retry | validation | func (err *WSError) Retry() bool {
for _, unretriable := range err.Get() {
if reflect.TypeOf(err.ErrObj) == reflect.TypeOf(unretriable) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q169169 | NewMockDockerStateResolver | validation | func NewMockDockerStateResolver(ctrl *gomock.Controller) *MockDockerStateResolver {
mock := &MockDockerStateResolver{ctrl: ctrl}
mock.recorder = &MockDockerStateResolverMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169170 | State | validation | func (mr *MockDockerStateResolverMockRecorder) State() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "State", reflect.TypeOf((*MockDockerStateResolver)(nil).State))
} | go | {
"resource": ""
} |
q169171 | printLicense | validation | func printLicense() int {
license := utils.NewLicenseProvider()
text, err := license.GetText()
if err != nil {
fmt.Fprintln(os.Stderr, err)
return exitcodes.ExitError
}
fmt.Println(text)
return exitcodes.ExitSuccess
} | go | {
"resource": ""
} |
q169172 | Load | validation | func (c *GlobalCgroupFactory) Load(hierarchy cgroups.Hierarchy, path cgroups.Path) (cgroups.Cgroup, error) {
return cgroups.Load(hierarchy, path)
} | go | {
"resource": ""
} |
q169173 | New | validation | func (c *GlobalCgroupFactory) New(hierarchy cgroups.Hierarchy, path cgroups.Path, specs *specs.LinuxResources) (cgroups.Cgroup, error) {
return cgroups.New(hierarchy, path, specs)
} | go | {
"resource": ""
} |
q169174 | timeoutAndMoveOn | validation | func timeoutAndMoveOn(fp loiterFunc, timeout time.Duration) {
ch := time.After(timeout)
for {
select {
case <-ch:
return
default:
fp()
}
}
} | go | {
"resource": ""
} |
q169175 | UnmarshalJSON | validation | func (engine *DockerTaskEngine) UnmarshalJSON(data []byte) error {
return engine.state.UnmarshalJSON(data)
} | go | {
"resource": ""
} |
q169176 | Init | validation | func (engine *DockerTaskEngine) Init(ctx context.Context) error {
// TODO, pass in a a context from main from background so that other things can stop us, not just the tests
derivedCtx, cancel := context.WithCancel(ctx)
engine.stopEngine = cancel
engine.ctx = derivedCtx
// Open the event stream before we sync st... | go | {
"resource": ""
} |
q169177 | MustInit | validation | func (engine *DockerTaskEngine) MustInit(ctx context.Context) {
if engine.initialized {
return
}
engine.mustInitLock.Lock()
defer engine.mustInitLock.Unlock()
errorOnce := sync.Once{}
taskEngineConnectBackoff := retry.NewExponentialBackoff(minEngineConnectRetryDelay, maxEngineConnectRetryDelay,
engineConnect... | go | {
"resource": ""
} |
q169178 | isTaskManaged | validation | func (engine *DockerTaskEngine) isTaskManaged(arn string) bool {
engine.tasksLock.RLock()
defer engine.tasksLock.RUnlock()
_, ok := engine.managedTasks[arn]
return ok
} | go | {
"resource": ""
} |
q169179 | synchronizeState | validation | func (engine *DockerTaskEngine) synchronizeState() {
engine.tasksLock.Lock()
defer engine.tasksLock.Unlock()
imageStates := engine.state.AllImageStates()
if len(imageStates) != 0 {
engine.imageManager.AddAllImageStates(imageStates)
}
tasks := engine.state.AllTasks()
tasksToStart := engine.filterTasksToStartUn... | go | {
"resource": ""
} |
q169180 | filterTasksToStartUnsafe | validation | func (engine *DockerTaskEngine) filterTasksToStartUnsafe(tasks []*apitask.Task) []*apitask.Task {
var tasksToStart []*apitask.Task
for _, task := range tasks {
conts, ok := engine.state.ContainerMapByArn(task.Arn)
if !ok {
// task hasn't started processing, no need to check container status
tasksToStart = a... | go | {
"resource": ""
} |
q169181 | updateContainerMetadata | validation | func updateContainerMetadata(metadata *dockerapi.DockerContainerMetadata, container *apicontainer.Container, task *apitask.Task) {
container.SetCreatedAt(metadata.CreatedAt)
container.SetStartedAt(metadata.StartedAt)
container.SetFinishedAt(metadata.FinishedAt)
// Set the labels if it's not set
if len(metadata.La... | go | {
"resource": ""
} |
q169182 | synchronizeContainerStatus | validation | func (engine *DockerTaskEngine) synchronizeContainerStatus(container *apicontainer.DockerContainer, task *apitask.Task) {
if container.DockerID == "" {
seelog.Debugf("Task engine [%s]: found container potentially created while we were down: %s",
task.Arn, container.DockerName)
// Figure out the dockerid
descr... | go | {
"resource": ""
} |
q169183 | checkTaskState | validation | func (engine *DockerTaskEngine) checkTaskState(task *apitask.Task) {
defer metrics.MetricsEngineGlobal.RecordTaskEngineMetric("CHECK_TASK_STATE")()
taskContainers, ok := engine.state.ContainerMapByArn(task.Arn)
if !ok {
seelog.Warnf("Task engine [%s]: could not check task state; no task in state", task.Arn)
retu... | go | {
"resource": ""
} |
q169184 | sweepTask | validation | func (engine *DockerTaskEngine) sweepTask(task *apitask.Task) {
for _, cont := range task.Containers {
err := engine.removeContainer(task, cont)
if err != nil {
seelog.Debugf("Task engine [%s]: unable to remove old container [%s]: %v",
task.Arn, cont.Name, err)
}
// Internal container(created by ecs-age... | go | {
"resource": ""
} |
q169185 | startTask | validation | func (engine *DockerTaskEngine) startTask(task *apitask.Task) {
// Create a channel that may be used to communicate with this task, survey
// what tasks need to be waited for for this one to start, and then spin off
// a goroutine to oversee this task
thisTask := engine.newManagedTask(task)
thisTask._time = engin... | go | {
"resource": ""
} |
q169186 | openEventstream | validation | func (engine *DockerTaskEngine) openEventstream(ctx context.Context) error {
events, err := engine.client.ContainerEvents(ctx)
if err != nil {
return err
}
engine.events = events
return nil
} | go | {
"resource": ""
} |
q169187 | handleDockerEvents | validation | func (engine *DockerTaskEngine) handleDockerEvents(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
case event := <-engine.events:
engine.handleDockerEvent(event)
}
}
} | go | {
"resource": ""
} |
q169188 | handleDockerEvent | validation | func (engine *DockerTaskEngine) handleDockerEvent(event dockerapi.DockerContainerChangeEvent) {
seelog.Debugf("Task engine: handling a docker event: %s", event.String())
task, ok := engine.state.TaskByID(event.DockerID)
if !ok {
seelog.Debugf("Task engine: event for container [%s] not managed, unable to map conta... | go | {
"resource": ""
} |
q169189 | AddTask | validation | func (engine *DockerTaskEngine) AddTask(task *apitask.Task) {
defer metrics.MetricsEngineGlobal.RecordTaskEngineMetric("ADD_TASK")()
err := task.PostUnmarshalTask(engine.cfg, engine.credentialsManager,
engine.resourceFields, engine.client, engine.ctx)
if err != nil {
seelog.Errorf("Task engine [%s]: unable to ad... | go | {
"resource": ""
} |
q169190 | ListTasks | validation | func (engine *DockerTaskEngine) ListTasks() ([]*apitask.Task, error) {
return engine.state.AllTasks(), nil
} | go | {
"resource": ""
} |
q169191 | GetTaskByArn | validation | func (engine *DockerTaskEngine) GetTaskByArn(arn string) (*apitask.Task, bool) {
return engine.state.TaskByArn(arn)
} | go | {
"resource": ""
} |
q169192 | imagePullRequired | validation | func (engine *DockerTaskEngine) imagePullRequired(imagePullBehavior config.ImagePullBehaviorType,
container *apicontainer.Container,
taskArn string) bool {
switch imagePullBehavior {
case config.ImagePullOnceBehavior:
// If this image has been pulled successfully before, don't pull the image,
// otherwise pull ... | go | {
"resource": ""
} |
q169193 | cleanupPauseContainerNetwork | validation | func (engine *DockerTaskEngine) cleanupPauseContainerNetwork(task *apitask.Task, container *apicontainer.Container) error {
seelog.Infof("Task engine [%s]: cleaning up the network namespace", task.Arn)
cniConfig, err := engine.buildCNIConfigFromTaskContainer(task, container)
if err != nil {
return errors.Wrapf(er... | go | {
"resource": ""
} |
q169194 | updateTaskUnsafe | validation | func (engine *DockerTaskEngine) updateTaskUnsafe(task *apitask.Task, update *apitask.Task) {
managedTask, ok := engine.managedTasks[task.Arn]
if !ok {
seelog.Criticalf("Task engine [%s]: ACS message for a task we thought we managed, but don't! Aborting.",
task.Arn)
return
}
// Keep the lock because sequence... | go | {
"resource": ""
} |
q169195 | transitionContainer | validation | func (engine *DockerTaskEngine) transitionContainer(task *apitask.Task, container *apicontainer.Container, to apicontainerstatus.ContainerStatus) {
// Let docker events operate async so that we can continue to handle ACS / other requests
// This is safe because 'applyContainerState' will not mutate the task
metadata... | go | {
"resource": ""
} |
q169196 | applyContainerState | validation | func (engine *DockerTaskEngine) applyContainerState(task *apitask.Task, container *apicontainer.Container, nextState apicontainerstatus.ContainerStatus) dockerapi.DockerContainerMetadata {
transitionFunction, ok := engine.transitionFunctionMap()[nextState]
if !ok {
seelog.Criticalf("Task engine [%s]: unsupported de... | go | {
"resource": ""
} |
q169197 | Version | validation | func (engine *DockerTaskEngine) Version() (string, error) {
return engine.client.Version(engine.ctx, dockerclient.VersionTimeout)
} | go | {
"resource": ""
} |
q169198 | NewMockSSMClient | validation | func NewMockSSMClient(ctrl *gomock.Controller) *MockSSMClient {
mock := &MockSSMClient{ctrl: ctrl}
mock.recorder = &MockSSMClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169199 | GetParameters | validation | func (m *MockSSMClient) GetParameters(arg0 *ssm.GetParametersInput) (*ssm.GetParametersOutput, error) {
ret := m.ctrl.Call(m, "GetParameters", arg0)
ret0, _ := ret[0].(*ssm.GetParametersOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.