_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168700 | NewTaskEngine | validation | func NewTaskEngine(cfg *config.Config, client dockerapi.DockerClient,
credentialsManager credentials.Manager,
containerChangeEventStream *eventstream.EventStream,
imageManager ImageManager, state dockerstate.TaskEngineState,
metadataManager containermetadata.Manager,
resourceFields *taskresource.ResourceFields) Ta... | go | {
"resource": ""
} |
q168701 | NewMockStateManager | validation | func NewMockStateManager(ctrl *gomock.Controller) *MockStateManager {
mock := &MockStateManager{ctrl: ctrl}
mock.recorder = &MockStateManagerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168702 | NewStateManager | validation | func (m *MockStateManager) NewStateManager(arg0 *config.Config, arg1 ...statemanager.Option) (statemanager.StateManager, error) {
varargs := []interface{}{arg0}
for _, a := range arg1 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "NewStateManager", varargs...)
ret0, _ := ret[0].(statemanager.StateManage... | go | {
"resource": ""
} |
q168703 | NewStateManager | validation | func (mr *MockStateManagerMockRecorder) NewStateManager(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
varargs := append([]interface{}{arg0}, arg1...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStateManager", reflect.TypeOf((*MockStateManager)(nil).NewStateManager), varargs...)
} | go | {
"resource": ""
} |
q168704 | NewMockSaveableOption | validation | func NewMockSaveableOption(ctrl *gomock.Controller) *MockSaveableOption {
mock := &MockSaveableOption{ctrl: ctrl}
mock.recorder = &MockSaveableOptionMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168705 | AddSaveable | validation | func (m *MockSaveableOption) AddSaveable(arg0 string, arg1 statemanager.Saveable) statemanager.Option {
ret := m.ctrl.Call(m, "AddSaveable", arg0, arg1)
ret0, _ := ret[0].(statemanager.Option)
return ret0
} | go | {
"resource": ""
} |
q168706 | AddSaveable | validation | func (mr *MockSaveableOptionMockRecorder) AddSaveable(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSaveable", reflect.TypeOf((*MockSaveableOption)(nil).AddSaveable), arg0, arg1)
} | go | {
"resource": ""
} |
q168707 | NewECSClient | validation | func NewECSClient(
credentialProvider *credentials.Credentials,
config *config.Config,
ec2MetadataClient ec2.EC2MetadataClient) api.ECSClient {
var ecsConfig aws.Config
ecsConfig.Credentials = credentialProvider
ecsConfig.Region = &config.AWSRegion
ecsConfig.HTTPClient = httpclient.New(roundtripTimeout, config.... | go | {
"resource": ""
} |
q168708 | CreateCluster | validation | func (client *APIECSClient) CreateCluster(clusterName string) (string, error) {
resp, err := client.standardClient.CreateCluster(&ecs.CreateClusterInput{ClusterName: &clusterName})
if err != nil {
seelog.Criticalf("Could not create cluster: %v", err)
return "", err
}
seelog.Infof("Created a cluster named: %s", ... | go | {
"resource": ""
} |
q168709 | RegisterContainerInstance | validation | func (client *APIECSClient) RegisterContainerInstance(containerInstanceArn string,
attributes []*ecs.Attribute, tags []*ecs.Tag, registrationToken string, platformDevices []*ecs.PlatformDevice) (string, string, error) {
clusterRef := client.config.Cluster
// If our clusterRef is empty, we should try to create the de... | go | {
"resource": ""
} |
q168710 | Connect | validation | func (cs *ClientServerImpl) Connect() error {
seelog.Infof("Establishing a Websocket connection to %s", cs.URL)
parsedURL, err := url.Parse(cs.URL)
if err != nil {
return err
}
wsScheme, err := websocketScheme(parsedURL.Scheme)
if err != nil {
return err
}
parsedURL.Scheme = wsScheme
// NewRequest never ... | go | {
"resource": ""
} |
q168711 | IsReady | validation | func (cs *ClientServerImpl) IsReady() bool {
cs.writeLock.RLock()
defer cs.writeLock.RUnlock()
return cs.conn != nil
} | go | {
"resource": ""
} |
q168712 | SetReadDeadline | validation | func (cs *ClientServerImpl) SetReadDeadline(t time.Time) error {
err := cs.conn.SetReadDeadline(t)
if err == nil {
return nil
}
seelog.Warnf("Unable to set read deadline for websocket connection: %v for %s", err, cs.URL)
// If we get connection closed error from SetReadDeadline, break out of the for loop and
//... | go | {
"resource": ""
} |
q168713 | Disconnect | validation | func (cs *ClientServerImpl) Disconnect(...interface{}) error {
cs.writeLock.Lock()
defer cs.writeLock.Unlock()
if cs.conn == nil {
return fmt.Errorf("websocker client: no connection to close")
}
// Close() in turn results in a an internal flushFrame() call in gorilla
// as the close frame needs to be sent to ... | go | {
"resource": ""
} |
q168714 | WriteMessage | validation | func (cs *ClientServerImpl) WriteMessage(send []byte) error {
cs.writeLock.Lock()
defer cs.writeLock.Unlock()
// This is just future proofing. Ignore the error as the gorilla websocket
// library returns 'nil' anyway for SetWriteDeadline
// https://github.com/gorilla/websocket/blob/4201258b820c74ac8e6922fc9e6b52f... | go | {
"resource": ""
} |
q168715 | ConsumeMessages | validation | func (cs *ClientServerImpl) ConsumeMessages() error {
for {
if err := cs.SetReadDeadline(time.Now().Add(cs.RWTimeout)); err != nil {
return err
}
messageType, message, err := cs.conn.ReadMessage()
switch {
case err == nil:
if messageType != websocket.TextMessage {
// maybe not fatal though, we'll ... | go | {
"resource": ""
} |
q168716 | handleMessage | validation | func (cs *ClientServerImpl) handleMessage(data []byte) {
typedMessage, typeStr, err := DecodeData(data, cs.TypeDecoder)
if err != nil {
seelog.Warnf("Unable to handle message from backend: %v", err)
return
}
seelog.Debugf("Received message of type: %s", typeStr)
if cs.AnyRequestHandler != nil {
reflect.Val... | go | {
"resource": ""
} |
q168717 | AllTasks | validation | func (state *DockerTaskEngineState) AllTasks() []*apitask.Task {
state.lock.RLock()
defer state.lock.RUnlock()
return state.allTasksUnsafe()
} | go | {
"resource": ""
} |
q168718 | AllImageStates | validation | func (state *DockerTaskEngineState) AllImageStates() []*image.ImageState {
state.lock.RLock()
defer state.lock.RUnlock()
return state.allImageStatesUnsafe()
} | go | {
"resource": ""
} |
q168719 | AllENIAttachments | validation | func (state *DockerTaskEngineState) AllENIAttachments() []*apieni.ENIAttachment {
state.lock.RLock()
defer state.lock.RUnlock()
return state.allENIAttachmentsUnsafe()
} | go | {
"resource": ""
} |
q168720 | ENIByMac | validation | func (state *DockerTaskEngineState) ENIByMac(mac string) (*apieni.ENIAttachment, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
eni, ok := state.eniAttachments[mac]
return eni, ok
} | go | {
"resource": ""
} |
q168721 | AddENIAttachment | validation | func (state *DockerTaskEngineState) AddENIAttachment(eniAttachment *apieni.ENIAttachment) {
if eniAttachment == nil {
log.Debug("Cannot add empty eni attachment information")
return
}
state.lock.Lock()
defer state.lock.Unlock()
if _, ok := state.eniAttachments[eniAttachment.MACAddress]; !ok {
state.eniAtta... | go | {
"resource": ""
} |
q168722 | RemoveENIAttachment | validation | func (state *DockerTaskEngineState) RemoveENIAttachment(mac string) {
if mac == "" {
log.Debug("Cannot remove empty eni attachment information")
return
}
state.lock.Lock()
defer state.lock.Unlock()
if _, ok := state.eniAttachments[mac]; ok {
delete(state.eniAttachments, mac)
} else {
seelog.Debugf("Delet... | go | {
"resource": ""
} |
q168723 | GetAllContainerIDs | validation | func (state *DockerTaskEngineState) GetAllContainerIDs() []string {
state.lock.RLock()
defer state.lock.RUnlock()
var ids []string
for id := range state.idToTask {
ids = append(ids, id)
}
return ids
} | go | {
"resource": ""
} |
q168724 | ContainerByID | validation | func (state *DockerTaskEngineState) ContainerByID(id string) (*apicontainer.DockerContainer, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
c, ok := state.idToContainer[id]
return c, ok
} | go | {
"resource": ""
} |
q168725 | ContainerMapByArn | validation | func (state *DockerTaskEngineState) ContainerMapByArn(arn string) (map[string]*apicontainer.DockerContainer, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
ret, ok := state.taskToID[arn]
// Copy the map to avoid data race
if ok {
mc := make(map[string]*apicontainer.DockerContainer)
for k, v := range r... | go | {
"resource": ""
} |
q168726 | TaskByShortID | validation | func (state *DockerTaskEngineState) TaskByShortID(cid string) ([]*apitask.Task, bool) {
containerIDs := state.GetAllContainerIDs()
var tasks []*apitask.Task
for _, id := range containerIDs {
if strings.HasPrefix(id, cid) {
if task, ok := state.TaskByID(id); ok {
tasks = append(tasks, task)
}
}
}
retu... | go | {
"resource": ""
} |
q168727 | TaskByID | validation | func (state *DockerTaskEngineState) TaskByID(cid string) (*apitask.Task, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
arn, found := state.idToTask[cid]
if !found {
return nil, false
}
return state.taskByArn(arn)
} | go | {
"resource": ""
} |
q168728 | TaskByArn | validation | func (state *DockerTaskEngineState) TaskByArn(arn string) (*apitask.Task, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
return state.taskByArn(arn)
} | go | {
"resource": ""
} |
q168729 | AddTask | validation | func (state *DockerTaskEngineState) AddTask(task *apitask.Task) {
state.lock.Lock()
defer state.lock.Unlock()
state.tasks[task.Arn] = task
} | go | {
"resource": ""
} |
q168730 | AddContainer | validation | func (state *DockerTaskEngineState) AddContainer(container *apicontainer.DockerContainer, task *apitask.Task) {
state.lock.Lock()
defer state.lock.Unlock()
if task == nil || container == nil {
log.Crit("Addcontainer called with nil task/container")
return
}
_, exists := state.tasks[task.Arn]
if !exists {
l... | go | {
"resource": ""
} |
q168731 | AddImageState | validation | func (state *DockerTaskEngineState) AddImageState(imageState *image.ImageState) {
if imageState == nil {
log.Debug("Cannot add empty image state")
return
}
if imageState.Image.ImageID == "" {
log.Debug("Cannot add image state with empty image id")
return
}
state.lock.Lock()
defer state.lock.Unlock()
sta... | go | {
"resource": ""
} |
q168732 | RemoveTask | validation | func (state *DockerTaskEngineState) RemoveTask(task *apitask.Task) {
state.lock.Lock()
defer state.lock.Unlock()
task, ok := state.tasks[task.Arn]
if !ok {
seelog.Warnf("Failed to locate task %s for removal from state", task.Arn)
return
}
delete(state.tasks, task.Arn)
if ip, ok := state.taskToIPUnsafe(task.... | go | {
"resource": ""
} |
q168733 | taskToIPUnsafe | validation | func (state *DockerTaskEngineState) taskToIPUnsafe(arn string) (string, bool) {
for ip, taskARN := range state.ipToTask {
if arn == taskARN {
return ip, true
}
}
return "", false
} | go | {
"resource": ""
} |
q168734 | removeV3EndpointIDToTaskContainerUnsafe | validation | func (state *DockerTaskEngineState) removeV3EndpointIDToTaskContainerUnsafe(v3EndpointID string) {
if v3EndpointID != "" {
delete(state.v3EndpointIDToTask, v3EndpointID)
delete(state.v3EndpointIDToDockerID, v3EndpointID)
}
} | go | {
"resource": ""
} |
q168735 | RemoveImageState | validation | func (state *DockerTaskEngineState) RemoveImageState(imageState *image.ImageState) {
if imageState == nil {
log.Debug("Cannot remove empty image state")
return
}
state.lock.Lock()
defer state.lock.Unlock()
imageState, ok := state.imageStates[imageState.Image.ImageID]
if !ok {
log.Debug("Image State is not ... | go | {
"resource": ""
} |
q168736 | AddTaskIPAddress | validation | func (state *DockerTaskEngineState) AddTaskIPAddress(addr string, taskARN string) {
state.lock.Lock()
defer state.lock.Unlock()
state.ipToTask[addr] = taskARN
} | go | {
"resource": ""
} |
q168737 | GetTaskByIPAddress | validation | func (state *DockerTaskEngineState) GetTaskByIPAddress(addr string) (string, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
taskARN, ok := state.ipToTask[addr]
return taskARN, ok
} | go | {
"resource": ""
} |
q168738 | storeV3EndpointIDToTaskUnsafe | validation | func (state *DockerTaskEngineState) storeV3EndpointIDToTaskUnsafe(v3EndpointID, taskARN string) {
state.v3EndpointIDToTask[v3EndpointID] = taskARN
} | go | {
"resource": ""
} |
q168739 | storeV3EndpointIDToDockerIDUnsafe | validation | func (state *DockerTaskEngineState) storeV3EndpointIDToDockerIDUnsafe(v3EndpointID, dockerID string) {
state.v3EndpointIDToDockerID[v3EndpointID] = dockerID
} | go | {
"resource": ""
} |
q168740 | DockerIDByV3EndpointID | validation | func (state *DockerTaskEngineState) DockerIDByV3EndpointID(v3EndpointID string) (string, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
dockerID, ok := state.v3EndpointIDToDockerID[v3EndpointID]
return dockerID, ok
} | go | {
"resource": ""
} |
q168741 | TaskARNByV3EndpointID | validation | func (state *DockerTaskEngineState) TaskARNByV3EndpointID(v3EndpointID string) (string, bool) {
state.lock.RLock()
defer state.lock.RUnlock()
taskArn, ok := state.v3EndpointIDToTask[v3EndpointID]
return taskArn, ok
} | go | {
"resource": ""
} |
q168742 | v1HandlersSetup | validation | func v1HandlersSetup(serverMux *http.ServeMux,
containerInstanceArn *string,
taskEngine handlersutils.DockerStateResolver,
cfg *config.Config) {
serverMux.HandleFunc(v1.AgentMetadataPath, v1.AgentMetadataHandler(containerInstanceArn, cfg))
serverMux.HandleFunc(v1.TaskContainerMetadataPath, v1.TaskContainerMetadata... | go | {
"resource": ""
} |
q168743 | String | validation | func (dc *DockerContainer) String() string {
if dc == nil {
return "nil"
}
return fmt.Sprintf("Id: %s, Name: %s, Container: %s", dc.DockerID, dc.DockerName, dc.Container.String())
} | go | {
"resource": ""
} |
q168744 | NewContainerWithSteadyState | validation | func NewContainerWithSteadyState(steadyState apicontainerstatus.ContainerStatus) *Container {
steadyStateStatus := steadyState
return &Container{
SteadyStateStatusUnsafe: &steadyStateStatus,
}
} | go | {
"resource": ""
} |
q168745 | GetKnownStatus | validation | func (c *Container) GetKnownStatus() apicontainerstatus.ContainerStatus {
c.lock.RLock()
defer c.lock.RUnlock()
return c.KnownStatusUnsafe
} | go | {
"resource": ""
} |
q168746 | SetKnownStatus | validation | func (c *Container) SetKnownStatus(status apicontainerstatus.ContainerStatus) {
c.lock.Lock()
defer c.lock.Unlock()
c.KnownStatusUnsafe = status
c.updateAppliedStatusUnsafe(status)
} | go | {
"resource": ""
} |
q168747 | GetDesiredStatus | validation | func (c *Container) GetDesiredStatus() apicontainerstatus.ContainerStatus {
c.lock.RLock()
defer c.lock.RUnlock()
return c.DesiredStatusUnsafe
} | go | {
"resource": ""
} |
q168748 | SetDesiredStatus | validation | func (c *Container) SetDesiredStatus(status apicontainerstatus.ContainerStatus) {
c.lock.Lock()
defer c.lock.Unlock()
c.DesiredStatusUnsafe = status
} | go | {
"resource": ""
} |
q168749 | GetSentStatus | validation | func (c *Container) GetSentStatus() apicontainerstatus.ContainerStatus {
c.lock.RLock()
defer c.lock.RUnlock()
return c.SentStatusUnsafe
} | go | {
"resource": ""
} |
q168750 | SetSentStatus | validation | func (c *Container) SetSentStatus(status apicontainerstatus.ContainerStatus) {
c.lock.Lock()
defer c.lock.Unlock()
c.SentStatusUnsafe = status
} | go | {
"resource": ""
} |
q168751 | SetKnownExitCode | validation | func (c *Container) SetKnownExitCode(i *int) {
c.lock.Lock()
defer c.lock.Unlock()
c.KnownExitCodeUnsafe = i
} | go | {
"resource": ""
} |
q168752 | GetKnownExitCode | validation | func (c *Container) GetKnownExitCode() *int {
c.lock.RLock()
defer c.lock.RUnlock()
return c.KnownExitCodeUnsafe
} | go | {
"resource": ""
} |
q168753 | SetRegistryAuthCredentials | validation | func (c *Container) SetRegistryAuthCredentials(credential credentials.IAMRoleCredentials) {
c.lock.Lock()
defer c.lock.Unlock()
c.RegistryAuthentication.ECRAuthData.SetPullCredentials(credential)
} | go | {
"resource": ""
} |
q168754 | ShouldPullWithExecutionRole | validation | func (c *Container) ShouldPullWithExecutionRole() bool {
c.lock.RLock()
defer c.lock.RUnlock()
return c.RegistryAuthentication != nil &&
c.RegistryAuthentication.Type == AuthTypeECR &&
c.RegistryAuthentication.ECRAuthData != nil &&
c.RegistryAuthentication.ECRAuthData.UseExecutionRole
} | go | {
"resource": ""
} |
q168755 | GetSteadyStateStatus | validation | func (c *Container) GetSteadyStateStatus() apicontainerstatus.ContainerStatus {
if c.SteadyStateStatusUnsafe == nil {
return defaultContainerSteadyStateStatus
}
return *c.SteadyStateStatusUnsafe
} | go | {
"resource": ""
} |
q168756 | IsKnownSteadyState | validation | func (c *Container) IsKnownSteadyState() bool {
knownStatus := c.GetKnownStatus()
return knownStatus == c.GetSteadyStateStatus()
} | go | {
"resource": ""
} |
q168757 | IsMetadataFileUpdated | validation | func (c *Container) IsMetadataFileUpdated() bool {
c.lock.RLock()
defer c.lock.RUnlock()
return c.MetadataFileUpdated
} | go | {
"resource": ""
} |
q168758 | SetMetadataFileUpdated | validation | func (c *Container) SetMetadataFileUpdated() {
c.lock.Lock()
defer c.lock.Unlock()
c.MetadataFileUpdated = true
} | go | {
"resource": ""
} |
q168759 | IsEssential | validation | func (c *Container) IsEssential() bool {
c.lock.RLock()
defer c.lock.RUnlock()
return c.Essential
} | go | {
"resource": ""
} |
q168760 | SetCreatedAt | validation | func (c *Container) SetCreatedAt(createdAt time.Time) {
if createdAt.IsZero() {
return
}
c.lock.Lock()
defer c.lock.Unlock()
c.createdAt = createdAt
} | go | {
"resource": ""
} |
q168761 | SetStartedAt | validation | func (c *Container) SetStartedAt(startedAt time.Time) {
if startedAt.IsZero() {
return
}
c.lock.Lock()
defer c.lock.Unlock()
c.startedAt = startedAt
} | go | {
"resource": ""
} |
q168762 | SetFinishedAt | validation | func (c *Container) SetFinishedAt(finishedAt time.Time) {
if finishedAt.IsZero() {
return
}
c.lock.Lock()
defer c.lock.Unlock()
c.finishedAt = finishedAt
} | go | {
"resource": ""
} |
q168763 | GetCreatedAt | validation | func (c *Container) GetCreatedAt() time.Time {
c.lock.RLock()
defer c.lock.RUnlock()
return c.createdAt
} | go | {
"resource": ""
} |
q168764 | GetStartedAt | validation | func (c *Container) GetStartedAt() time.Time {
c.lock.RLock()
defer c.lock.RUnlock()
return c.startedAt
} | go | {
"resource": ""
} |
q168765 | GetFinishedAt | validation | func (c *Container) GetFinishedAt() time.Time {
c.lock.RLock()
defer c.lock.RUnlock()
return c.finishedAt
} | go | {
"resource": ""
} |
q168766 | SetLabels | validation | func (c *Container) SetLabels(labels map[string]string) {
c.lock.Lock()
defer c.lock.Unlock()
c.labels = labels
} | go | {
"resource": ""
} |
q168767 | GetLabels | validation | func (c *Container) GetLabels() map[string]string {
c.lock.RLock()
defer c.lock.RUnlock()
return c.labels
} | go | {
"resource": ""
} |
q168768 | SetKnownPortBindings | validation | func (c *Container) SetKnownPortBindings(ports []PortBinding) {
c.lock.Lock()
defer c.lock.Unlock()
c.KnownPortBindingsUnsafe = ports
} | go | {
"resource": ""
} |
q168769 | GetKnownPortBindings | validation | func (c *Container) GetKnownPortBindings() []PortBinding {
c.lock.RLock()
defer c.lock.RUnlock()
return c.KnownPortBindingsUnsafe
} | go | {
"resource": ""
} |
q168770 | SetVolumes | validation | func (c *Container) SetVolumes(volumes []types.MountPoint) {
c.lock.Lock()
defer c.lock.Unlock()
c.VolumesUnsafe = volumes
} | go | {
"resource": ""
} |
q168771 | GetVolumes | validation | func (c *Container) GetVolumes() []types.MountPoint {
c.lock.RLock()
defer c.lock.RUnlock()
return c.VolumesUnsafe
} | go | {
"resource": ""
} |
q168772 | SetNetworkSettings | validation | func (c *Container) SetNetworkSettings(networks *types.NetworkSettings) {
c.lock.Lock()
defer c.lock.Unlock()
c.NetworkSettingsUnsafe = networks
} | go | {
"resource": ""
} |
q168773 | GetNetworkSettings | validation | func (c *Container) GetNetworkSettings() *types.NetworkSettings {
c.lock.RLock()
defer c.lock.RUnlock()
return c.NetworkSettingsUnsafe
} | go | {
"resource": ""
} |
q168774 | SetNetworkMode | validation | func (c *Container) SetNetworkMode(networkMode string) {
c.lock.Lock()
defer c.lock.Unlock()
c.NetworkModeUnsafe = networkMode
} | go | {
"resource": ""
} |
q168775 | GetNetworkMode | validation | func (c *Container) GetNetworkMode() string {
c.lock.RLock()
defer c.lock.RUnlock()
return c.NetworkModeUnsafe
} | go | {
"resource": ""
} |
q168776 | SetHealthStatus | validation | func (c *Container) SetHealthStatus(health HealthStatus) {
c.lock.Lock()
defer c.lock.Unlock()
if c.Health.Status == health.Status {
return
}
c.Health.Status = health.Status
c.Health.Since = aws.Time(time.Now())
c.Health.Output = health.Output
// Set the health exit code if the health check failed
if c.He... | go | {
"resource": ""
} |
q168777 | GetHealthStatus | validation | func (c *Container) GetHealthStatus() HealthStatus {
c.lock.RLock()
defer c.lock.RUnlock()
// Copy the pointer to avoid race condition
copyHealth := c.Health
if c.Health.Since != nil {
copyHealth.Since = aws.Time(aws.TimeValue(c.Health.Since))
}
return copyHealth
} | go | {
"resource": ""
} |
q168778 | BuildContainerDependency | validation | func (c *Container) BuildContainerDependency(contName string,
satisfiedStatus apicontainerstatus.ContainerStatus,
dependentStatus apicontainerstatus.ContainerStatus) {
contDep := ContainerDependency{
ContainerName: contName,
SatisfiedStatus: satisfiedStatus,
}
if _, ok := c.TransitionDependenciesMap[dependen... | go | {
"resource": ""
} |
q168779 | updateAppliedStatusUnsafe | validation | func (c *Container) updateAppliedStatusUnsafe(knownStatus apicontainerstatus.ContainerStatus) {
if c.AppliedStatus == apicontainerstatus.ContainerStatusNone {
return
}
// Check if the container transition has already finished
if c.AppliedStatus <= knownStatus {
c.AppliedStatus = apicontainerstatus.ContainerSta... | go | {
"resource": ""
} |
q168780 | SetAppliedStatus | validation | func (c *Container) SetAppliedStatus(status apicontainerstatus.ContainerStatus) bool {
c.lock.Lock()
defer c.lock.Unlock()
if c.AppliedStatus != apicontainerstatus.ContainerStatusNone {
// return false to indicate the set operation failed
return false
}
c.AppliedStatus = status
return true
} | go | {
"resource": ""
} |
q168781 | GetAppliedStatus | validation | func (c *Container) GetAppliedStatus() apicontainerstatus.ContainerStatus {
c.lock.RLock()
defer c.lock.RUnlock()
return c.AppliedStatus
} | go | {
"resource": ""
} |
q168782 | ShouldPullWithASMAuth | validation | func (c *Container) ShouldPullWithASMAuth() bool {
c.lock.RLock()
defer c.lock.RUnlock()
return c.RegistryAuthentication != nil &&
c.RegistryAuthentication.Type == AuthTypeASM &&
c.RegistryAuthentication.ASMAuthData != nil
} | go | {
"resource": ""
} |
q168783 | SetASMDockerAuthConfig | validation | func (c *Container) SetASMDockerAuthConfig(dac types.AuthConfig) {
c.RegistryAuthentication.ASMAuthData.SetDockerAuthConfig(dac)
} | go | {
"resource": ""
} |
q168784 | SetV3EndpointID | validation | func (c *Container) SetV3EndpointID(v3EndpointID string) {
c.lock.Lock()
defer c.lock.Unlock()
c.V3EndpointID = v3EndpointID
} | go | {
"resource": ""
} |
q168785 | GetV3EndpointID | validation | func (c *Container) GetV3EndpointID() string {
c.lock.RLock()
defer c.lock.RUnlock()
return c.V3EndpointID
} | go | {
"resource": ""
} |
q168786 | InjectV3MetadataEndpoint | validation | func (c *Container) InjectV3MetadataEndpoint() {
c.lock.Lock()
defer c.lock.Unlock()
// don't assume that the environment variable map has been initialized by others
if c.Environment == nil {
c.Environment = make(map[string]string)
}
c.Environment[MetadataURIEnvironmentVariableName] =
fmt.Sprintf(MetadataUR... | go | {
"resource": ""
} |
q168787 | ShouldCreateWithSSMSecret | validation | func (c *Container) ShouldCreateWithSSMSecret() bool {
c.lock.RLock()
defer c.lock.RUnlock()
// Secrets field will be nil if there is no secrets for container
if c.Secrets == nil {
return false
}
for _, secret := range c.Secrets {
if secret.Provider == SecretProviderSSM {
return true
}
}
return false... | go | {
"resource": ""
} |
q168788 | ShouldCreateWithASMSecret | validation | func (c *Container) ShouldCreateWithASMSecret() bool {
c.lock.RLock()
defer c.lock.RUnlock()
// Secrets field will be nil if there is no secrets for container
if c.Secrets == nil {
return false
}
for _, secret := range c.Secrets {
if secret.Provider == SecretProviderASM {
return true
}
}
return false... | go | {
"resource": ""
} |
q168789 | getMetadataFilePath | validation | func getMetadataFilePath(taskARN string, containerName string, dataDir string) (string, error) {
taskID, err := getTaskIDfromARN(taskARN)
// Empty task ID indicates malformed ARN (Should not happen)
if err != nil {
return "", fmt.Errorf("get metdata file path of task %s container %s: %v", taskARN, containerName, e... | go | {
"resource": ""
} |
q168790 | getTaskMetadataDir | validation | func getTaskMetadataDir(taskARN string, dataDir string) (string, error) {
taskID, err := getTaskIDfromARN(taskARN)
if err != nil {
return "", fmt.Errorf("get task metadata directory: %v", err)
}
return filepath.Join(dataDir, metadataJoinSuffix, taskID), err
} | go | {
"resource": ""
} |
q168791 | MarshalJSON | validation | func (b Conditional) MarshalJSON() ([]byte, error) {
switch b {
case ExplicitlyEnabled:
return json.Marshal(true)
case ExplicitlyDisabled:
return json.Marshal(false)
default:
return json.Marshal(nil)
}
} | go | {
"resource": ""
} |
q168792 | UnmarshalJSON | validation | func (b *Conditional) UnmarshalJSON(jsonData []byte) error {
jsonString := string(jsonData)
jsonBool, err := strconv.ParseBool(jsonString)
if err != nil && jsonString != "null" {
return err
}
if jsonString == "" || jsonString == "null" {
*b = DefaultEnabled
} else if jsonBool {
*b = ExplicitlyEnabled
} el... | go | {
"resource": ""
} |
q168793 | NewASMSecretResource | validation | func NewASMSecretResource(taskARN string,
asmSecrets map[string]apicontainer.Secret,
executionCredentialsID string,
credentialsManager credentials.Manager,
asmClientCreator factory.ClientCreator) *ASMSecretResource {
s := &ASMSecretResource{
taskARN: taskARN,
requiredSecrets: asmSecrets,... | go | {
"resource": ""
} |
q168794 | Create | validation | func (secret *ASMSecretResource) 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("ASM secr... | go | {
"resource": ""
} |
q168795 | retrieveASMSecretValue | validation | func (secret *ASMSecretResource) retrieveASMSecretValue(apiSecret apicontainer.Secret, iamCredentials credentials.IAMRoleCredentials, wg *sync.WaitGroup, errorEvents chan error) {
defer wg.Done()
asmClient := secret.asmClientCreator.NewASMClient(apiSecret.Region, iamCredentials)
seelog.Infof("ASM secret resource: r... | go | {
"resource": ""
} |
q168796 | getRequiredSecrets | validation | func (secret *ASMSecretResource) getRequiredSecrets() map[string]apicontainer.Secret {
secret.lock.RLock()
defer secret.lock.RUnlock()
return secret.requiredSecrets
} | go | {
"resource": ""
} |
q168797 | clearASMSecretValue | validation | func (secret *ASMSecretResource) clearASMSecretValue() {
secret.lock.Lock()
defer secret.lock.Unlock()
for key := range secret.secretData {
delete(secret.secretData, key)
}
} | go | {
"resource": ""
} |
q168798 | MarshalJSON | validation | func (secret *ASMSecretResource) MarshalJSON() ([]byte, error) {
if secret == nil {
return nil, errors.New("asmsecret resource is nil")
}
createdAt := secret.GetCreatedAt()
return json.Marshal(ASMSecretResourceJSON{
TaskARN: secret.taskARN,
CreatedAt: &createdAt,
DesiredStatus: func() *ASMSecretStatus {
... | go | {
"resource": ""
} |
q168799 | UnmarshalJSON | validation | func (secret *ASMSecretResource) UnmarshalJSON(b []byte) error {
temp := ASMSecretResourceJSON{}
if err := json.Unmarshal(b, &temp); err != nil {
return err
}
if temp.DesiredStatus != nil {
secret.SetDesiredStatus(resourcestatus.ResourceStatus(*temp.DesiredStatus))
}
if temp.KnownStatus != nil {
secret.Se... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.