id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168700 |
taskEngine := NewDockerTaskEngine(cfg, client, credentialsManager,
containerChangeEventStream, imageManager,
state, metadataManager, resourceFields)
return taskEngine
} | |
c168701 |
mock.recorder = &MockStateManagerMockRecorder{mock}
return mock
} | |
c168702 | := m.ctrl.Call(m, "NewStateManager", varargs...)
ret0, _ := ret[0].(statemanager.StateManager)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168703 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStateManager", reflect.TypeOf((*MockStateManager)(nil).NewStateManager), varargs...)
} | |
c168704 | ctrl}
mock.recorder = &MockSaveableOptionMockRecorder{mock}
return mock
} | |
c168705 | m.ctrl.Call(m, "AddSaveable", arg0, arg1)
ret0, _ := ret[0].(statemanager.Option)
return ret0
} | |
c168706 | reflect.TypeOf((*MockSaveableOption)(nil).AddSaveable), arg0, arg1)
} | |
c168707 | := async.NewLRUCache(pollEndpointCacheSize, pollEndpointCacheTTL)
return &APIECSClient{
credentialProvider: credentialProvider,
config: config,
standardClient: standardClient,
submitStateChangeClient: submitStateChangeClient,
ec2metadata: ec2MetadataClient,
pollE... | |
c168708 |
if err != nil {
seelog.Criticalf("Could not create cluster: %v", err)
return "", err
}
seelog.Infof("Created a cluster named: %s", clusterName)
return *resp.Cluster.ClusterName, nil
} | |
c168709 | registrationToken, platformDevices)
if err == nil {
return containerInstanceArn, availabilityzone, nil
}
// If trying to register fails because the default cluster doesn't exist, try to create the cluster before calling
// register again
if apierrors.IsClusterNotFoundError(err) {
clusterRef, err = cli... | |
c168710 | dockerHost.Scheme = ""
os.Setenv("NO_PROXY", fmt.Sprintf("%s,%s", defaultNoProxyIP, dockerHost.String()))
seelog.Info("NO_PROXY set:", os.Getenv("NO_PROXY"))
} else {
seelog.Errorf("NO_PROXY unable to be set: the configured Docker endpoint is invalid.")
}
}
dialer := websocket.Dialer{
ReadBufferSiz... | |
c168711 | cs.writeLock.RUnlock()
return cs.conn != nil
} | |
c168712 | // Try asynchronously closing the connection. We don't want to be blocked on stale connections
// taking too long to close. The flip side is that we might start accumulating stale connections.
// But, that still seems more desirable than waiting for ever for the connection to close
cs.forceCloseConnection()
return... | |
c168713 | an internal flushFrame() call in gorilla
// as the close frame needs to be sent to the server. Set the deadline
// for that as well.
if err := cs.conn.SetWriteDeadline(time.Now().Add(cs.RWTimeout)); err != nil {
seelog.Warnf("Unable to set write deadline for websocket connection: %v for %s", err, cs.URL)
}
retu... | |
c168714 |
// https://github.com/gorilla/websocket/blob/4201258b820c74ac8e6922fc9e6b52f71fe46f8d/conn.go#L761
if err := cs.conn.SetWriteDeadline(time.Now().Add(cs.RWTimeout)); err != nil {
seelog.Warnf("Unable to set write deadline for websocket connection: %v for %s", err, cs.URL)
}
return cs.conn.WriteMessage(websocket.... | |
c168715 | a valid reason: %s", err)
return io.EOF
default:
// Unexpected error occurred
seelog.Errorf("Error getting message from ws backend: error: [%v], messageType: [%v] ",
err, messageType)
return err
}
}
} | |
c168716 | if handler, ok := cs.RequestHandlers[typeStr]; ok {
reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(typedMessage)})
} else {
seelog.Infof("No handler for message type: %s", typeStr)
}
} | |
c168717 | defer state.lock.RUnlock()
return state.allTasksUnsafe()
} | |
c168718 | defer state.lock.RUnlock()
return state.allImageStatesUnsafe()
} | |
c168719 | defer state.lock.RUnlock()
return state.allENIAttachmentsUnsafe()
} | |
c168720 |
defer state.lock.RUnlock()
eni, ok := state.eniAttachments[mac]
return eni, ok
} | |
c168721 | state.eniAttachments[eniAttachment.MACAddress] = eniAttachment
} else {
seelog.Debugf("Duplicate eni attachment information: %v", eniAttachment)
}
} | |
c168722 | {
delete(state.eniAttachments, mac)
} else {
seelog.Debugf("Delete non-existed eni attachment: %v", mac)
}
} | |
c168723 | for id := range state.idToTask {
ids = append(ids, id)
}
return ids
} | |
c168724 |
defer state.lock.RUnlock()
c, ok := state.idToContainer[id]
return c, ok
} | |
c168725 | ok {
mc := make(map[string]*apicontainer.DockerContainer)
for k, v := range ret {
mc[k] = v
}
return mc, ok
}
return ret, ok
} | |
c168726 | if task, ok := state.TaskByID(id); ok {
tasks = append(tasks, task)
}
}
}
return tasks, len(tasks) > 0
} | |
c168727 |
defer state.lock.RUnlock()
arn, found := state.idToTask[cid]
if !found {
return nil, false
}
return state.taskByArn(arn)
} | |
c168728 |
defer state.lock.RUnlock()
return state.taskByArn(arn)
} | |
c168729 | defer state.lock.Unlock()
state.tasks[task.Arn] = task
} | |
c168730 | {
state.storeV3EndpointIDToTaskUnsafe(v3EndpointID, task.Arn)
state.storeV3EndpointIDToDockerIDUnsafe(v3EndpointID, dockerID)
}
existingMap, exists := state.taskToID[task.Arn]
if !exists {
existingMap = make(map[string]*apicontainer.DockerContainer, len(task.Containers))
state.taskToID[task.Arn] = existing... | |
c168731 | image id")
return
}
state.lock.Lock()
defer state.lock.Unlock()
state.imageStates[imageState.Image.ImageID] = imageState
} | |
c168732 | }
delete(state.taskToID, task.Arn)
for _, dockerContainer := range containerMap {
state.removeIDToContainerTaskUnsafe(dockerContainer)
// remove v3 endpoint mappings
state.removeV3EndpointIDToTaskContainerUnsafe(dockerContainer.Container.V3EndpointID)
}
} | |
c168733 |
if arn == taskARN {
return ip, true
}
}
return "", false
} | |
c168734 | delete(state.v3EndpointIDToTask, v3EndpointID)
delete(state.v3EndpointIDToDockerID, v3EndpointID)
}
} | |
c168735 | log.Debug("Image State is not found. Cannot be removed")
return
}
delete(state.imageStates, imageState.Image.ImageID)
} | |
c168736 | taskARN string) {
state.lock.Lock()
defer state.lock.Unlock()
state.ipToTask[addr] = taskARN
} | |
c168737 | taskARN, ok := state.ipToTask[addr]
return taskARN, ok
} | |
c168738 | state.v3EndpointIDToTask[v3EndpointID] = taskARN
} | |
c168739 | state.v3EndpointIDToDockerID[v3EndpointID] = dockerID
} | |
c168740 | ok := state.v3EndpointIDToDockerID[v3EndpointID]
return dockerID, ok
} | |
c168741 | ok := state.v3EndpointIDToTask[v3EndpointID]
return taskArn, ok
} | |
c168742 | v1.AgentMetadataHandler(containerInstanceArn, cfg))
serverMux.HandleFunc(v1.TaskContainerMetadataPath, v1.TaskContainerMetadataHandler(taskEngine))
serverMux.HandleFunc(v1.LicensePath, v1.LicenseHandler)
} | |
c168743 | %s", dc.DockerID, dc.DockerName, dc.Container.String())
} | |
c168744 | *Container {
steadyStateStatus := steadyState
return &Container{
SteadyStateStatusUnsafe: &steadyStateStatus,
}
} | |
c168745 | defer c.lock.RUnlock()
return c.KnownStatusUnsafe
} | |
c168746 | {
c.lock.Lock()
defer c.lock.Unlock()
c.KnownStatusUnsafe = status
c.updateAppliedStatusUnsafe(status)
} | |
c168747 | defer c.lock.RUnlock()
return c.DesiredStatusUnsafe
} | |
c168748 | defer c.lock.Unlock()
c.DesiredStatusUnsafe = status
} | |
c168749 | defer c.lock.RUnlock()
return c.SentStatusUnsafe
} | |
c168750 | defer c.lock.Unlock()
c.SentStatusUnsafe = status
} | |
c168751 | c.lock.Unlock()
c.KnownExitCodeUnsafe = i
} | |
c168752 | c.lock.RUnlock()
return c.KnownExitCodeUnsafe
} | |
c168753 | {
c.lock.Lock()
defer c.lock.Unlock()
c.RegistryAuthentication.ECRAuthData.SetPullCredentials(credential)
} | |
c168754 |
c.RegistryAuthentication.ECRAuthData != nil &&
c.RegistryAuthentication.ECRAuthData.UseExecutionRole
} | |
c168755 | if c.SteadyStateStatusUnsafe == nil {
return defaultContainerSteadyStateStatus
}
return *c.SteadyStateStatusUnsafe
} | |
c168756 | knownStatus == c.GetSteadyStateStatus()
} | |
c168757 | c.lock.RUnlock()
return c.MetadataFileUpdated
} | |
c168758 | c.lock.Unlock()
c.MetadataFileUpdated = true
} | |
c168759 | c.lock.RLock()
defer c.lock.RUnlock()
return c.Essential
} | |
c168760 | defer c.lock.Unlock()
c.createdAt = createdAt
} | |
c168761 |
defer c.lock.Unlock()
c.startedAt = startedAt
} | |
c168762 |
defer c.lock.Unlock()
c.finishedAt = finishedAt
} | |
c168763 | defer c.lock.RUnlock()
return c.createdAt
} | |
c168764 | defer c.lock.RUnlock()
return c.startedAt
} | |
c168765 | defer c.lock.RUnlock()
return c.finishedAt
} | |
c168766 | defer c.lock.Unlock()
c.labels = labels
} | |
c168767 | defer c.lock.RUnlock()
return c.labels
} | |
c168768 | defer c.lock.Unlock()
c.KnownPortBindingsUnsafe = ports
} | |
c168769 | defer c.lock.RUnlock()
return c.KnownPortBindingsUnsafe
} | |
c168770 | defer c.lock.Unlock()
c.VolumesUnsafe = volumes
} | |
c168771 | defer c.lock.RUnlock()
return c.VolumesUnsafe
} | |
c168772 | defer c.lock.Unlock()
c.NetworkSettingsUnsafe = networks
} | |
c168773 | defer c.lock.RUnlock()
return c.NetworkSettingsUnsafe
} | |
c168774 | defer c.lock.Unlock()
c.NetworkModeUnsafe = networkMode
} | |
c168775 | c.lock.RLock()
defer c.lock.RUnlock()
return c.NetworkModeUnsafe
} | |
c168776 | if the health check failed
if c.Health.Status == apicontainerstatus.ContainerUnhealthy {
c.Health.ExitCode = health.ExitCode
}
} | |
c168777 | avoid race condition
copyHealth := c.Health
if c.Health.Since != nil {
copyHealth.Since = aws.Time(aws.TimeValue(c.Health.Since))
}
return copyHealth
} | |
c168778 |
deps := c.TransitionDependenciesMap[dependentStatus]
deps.ContainerDependencies = append(deps.ContainerDependencies, contDep)
c.TransitionDependenciesMap[dependentStatus] = deps
} | |
c168779 | if c.AppliedStatus <= knownStatus {
c.AppliedStatus = apicontainerstatus.ContainerStatusNone
}
} | |
c168780 | // return false to indicate the set operation failed
return false
}
c.AppliedStatus = status
return true
} | |
c168781 | defer c.lock.RUnlock()
return c.AppliedStatus
} | |
c168782 | return c.RegistryAuthentication != nil &&
c.RegistryAuthentication.Type == AuthTypeASM &&
c.RegistryAuthentication.ASMAuthData != nil
} | |
c168783 | c.RegistryAuthentication.ASMAuthData.SetDockerAuthConfig(dac)
} | |
c168784 | defer c.lock.Unlock()
c.V3EndpointID = v3EndpointID
} | |
c168785 | defer c.lock.RUnlock()
return c.V3EndpointID
} | |
c168786 |
c.Environment[MetadataURIEnvironmentVariableName] =
fmt.Sprintf(MetadataURIFormat, c.V3EndpointID)
} | |
c168787 |
for _, secret := range c.Secrets {
if secret.Provider == SecretProviderSSM {
return true
}
}
return false
} | |
c168788 |
for _, secret := range c.Secrets {
if secret.Provider == SecretProviderASM {
return true
}
}
return false
} | |
c168789 | path of task %s container %s: %v", taskARN, containerName, err)
}
return filepath.Join(dataDir, metadataJoinSuffix, taskID, containerName), nil
} | |
c168790 | "", fmt.Errorf("get task metadata directory: %v", err)
}
return filepath.Join(dataDir, metadataJoinSuffix, taskID), err
} | |
c168791 | return json.Marshal(false)
default:
return json.Marshal(nil)
}
} | |
c168792 | "" || jsonString == "null" {
*b = DefaultEnabled
} else if jsonBool {
*b = ExplicitlyEnabled
} else {
*b = ExplicitlyDisabled
}
return nil
} | |
c168793 |
credentialsManager: credentialsManager,
executionCredentialsID: executionCredentialsID,
asmClientCreator: asmClientCreator,
}
s.initStatusToTransition()
return s
} | |
c168794 |
for _, asmsecret := range secret.getRequiredSecrets() {
wg.Add(1)
// Spin up goroutine per secret to speed up processing time
go secret.retrieveASMSecretValue(asmsecret, iamCredentials, &wg, errorEvents)
}
wg.Wait()
close(errorEvents)
if len(errorEvents) > 0 {
var terminalReasons []string
for err := r... | |
c168795 | data from AWS Secrets Manager in region %s: %v", apiSecret.Region, err)
return
}
secret.lock.Lock()
defer secret.lock.Unlock()
// put secret value in secretData
secretKey := apiSecret.GetSecretResourceCacheKey()
secret.secretData[secretKey] = secretValue
} | |
c168796 | defer secret.lock.RUnlock()
return secret.requiredSecrets
} | |
c168797 | secret.secretData {
delete(secret.secretData, key)
}
} | |
c168798 | := secret.GetKnownStatus()
s := ASMSecretStatus(knownState)
return &s
}(),
RequiredSecrets: secret.getRequiredSecrets(),
ExecutionCredentialsID: secret.getExecutionCredentialsID(),
})
} | |
c168799 | && !temp.CreatedAt.IsZero() {
secret.SetCreatedAt(*temp.CreatedAt)
}
if temp.RequiredSecrets != nil {
secret.requiredSecrets = temp.RequiredSecrets
}
secret.taskARN = temp.TaskARN
secret.executionCredentialsID = temp.ExecutionCredentialsID
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.