_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q169000 | initializeASMAuthResource | validation | func (task *Task) initializeASMAuthResource(credentialsManager credentials.Manager,
resourceFields *taskresource.ResourceFields) {
asmAuthResource := asmauth.NewASMAuthResource(task.Arn, task.getAllASMAuthDataRequirements(),
task.ExecutionCredentialsID, credentialsManager, resourceFields.ASMClientCreator)
task.Add... | go | {
"resource": ""
} |
q169001 | requiresSSMSecret | validation | func (task *Task) requiresSSMSecret() bool {
for _, container := range task.Containers {
if container.ShouldCreateWithSSMSecret() {
return true
}
}
return false
} | go | {
"resource": ""
} |
q169002 | initializeSSMSecretResource | validation | func (task *Task) initializeSSMSecretResource(credentialsManager credentials.Manager,
resourceFields *taskresource.ResourceFields) {
ssmSecretResource := ssmsecret.NewSSMSecretResource(task.Arn, task.getAllSSMSecretRequirements(),
task.ExecutionCredentialsID, credentialsManager, resourceFields.SSMClientCreator)
ta... | go | {
"resource": ""
} |
q169003 | getAllSSMSecretRequirements | validation | func (task *Task) getAllSSMSecretRequirements() map[string][]apicontainer.Secret {
reqs := make(map[string][]apicontainer.Secret)
for _, container := range task.Containers {
for _, secret := range container.Secrets {
if secret.Provider == apicontainer.SecretProviderSSM {
if _, ok := reqs[secret.Region]; !ok... | go | {
"resource": ""
} |
q169004 | requiresASMSecret | validation | func (task *Task) requiresASMSecret() bool {
for _, container := range task.Containers {
if container.ShouldCreateWithASMSecret() {
return true
}
}
return false
} | go | {
"resource": ""
} |
q169005 | initializeASMSecretResource | validation | func (task *Task) initializeASMSecretResource(credentialsManager credentials.Manager,
resourceFields *taskresource.ResourceFields) {
asmSecretResource := asmsecret.NewASMSecretResource(task.Arn, task.getAllASMSecretRequirements(),
task.ExecutionCredentialsID, credentialsManager, resourceFields.ASMClientCreator)
ta... | go | {
"resource": ""
} |
q169006 | getAllASMSecretRequirements | validation | func (task *Task) getAllASMSecretRequirements() map[string]apicontainer.Secret {
reqs := make(map[string]apicontainer.Secret)
for _, container := range task.Containers {
for _, secret := range container.Secrets {
if secret.Provider == apicontainer.SecretProviderASM {
secretKey := secret.GetSecretResourceCac... | go | {
"resource": ""
} |
q169007 | BuildCNIConfig | validation | func (task *Task) BuildCNIConfig() (*ecscni.Config, error) {
if !task.isNetworkModeVPC() {
return nil, errors.New("task config: task has no ENIs associated with it, unable to generate cni config")
}
cfg := &ecscni.Config{}
convertENIToCNIConfig(task.GetTaskENI(), cfg)
if task.GetAppMesh() != nil {
convertAppM... | go | {
"resource": ""
} |
q169008 | convertENIToCNIConfig | validation | func convertENIToCNIConfig(eni *apieni.ENI, cfg *ecscni.Config) {
cfg.ENIID = eni.ID
cfg.ID = eni.MacAddress
cfg.ENIMACAddress = eni.MacAddress
cfg.SubnetGatewayIPV4Address = eni.GetSubnetGatewayIPV4Address()
for _, ipv4 := range eni.IPV4Addresses {
if ipv4.Primary {
cfg.ENIIPV4Address = ipv4.Address
break... | go | {
"resource": ""
} |
q169009 | convertAppMeshToCNIConfig | validation | func convertAppMeshToCNIConfig(appMesh *apiappmesh.AppMesh, cfg *ecscni.Config) {
cfg.AppMeshCNIEnabled = true
cfg.IgnoredUID = appMesh.IgnoredUID
cfg.IgnoredGID = appMesh.IgnoredGID
cfg.ProxyIngressPort = appMesh.ProxyIngressPort
cfg.ProxyEgressPort = appMesh.ProxyEgressPort
cfg.AppPorts = appMesh.AppPorts
cfg.... | go | {
"resource": ""
} |
q169010 | HostVolumeByName | validation | func (task *Task) HostVolumeByName(name string) (taskresourcevolume.Volume, bool) {
for _, v := range task.Volumes {
if v.Name == name {
return v.Volume, true
}
}
return nil, false
} | go | {
"resource": ""
} |
q169011 | UpdateMountPoints | validation | func (task *Task) UpdateMountPoints(cont *apicontainer.Container, vols []types.MountPoint) {
for _, mountPoint := range cont.MountPoints {
containerPath := getCanonicalPath(mountPoint.ContainerPath)
for _, vol := range vols {
if strings.Compare(vol.Destination, containerPath) == 0 ||
// /path/ -> /path or \... | go | {
"resource": ""
} |
q169012 | DockerConfig | validation | func (task *Task) DockerConfig(container *apicontainer.Container, apiVersion dockerclient.DockerVersion) (*dockercontainer.Config, *apierrors.DockerClientConfigError) {
return task.dockerConfig(container, apiVersion)
} | go | {
"resource": ""
} |
q169013 | DockerHostConfig | validation | func (task *Task) DockerHostConfig(container *apicontainer.Container, dockerContainerMap map[string]*apicontainer.DockerContainer, apiVersion dockerclient.DockerVersion) (*dockercontainer.HostConfig, *apierrors.HostConfigError) {
return task.dockerHostConfig(container, dockerContainerMap, apiVersion)
} | go | {
"resource": ""
} |
q169014 | ApplyExecutionRoleLogsAuth | validation | func (task *Task) ApplyExecutionRoleLogsAuth(hostConfig *dockercontainer.HostConfig, credentialsManager credentials.Manager) *apierrors.HostConfigError {
id := task.GetExecutionCredentialsID()
if id == "" {
// No execution credentials set for the task. Do not inject the endpoint environment variable.
return &apie... | go | {
"resource": ""
} |
q169015 | shouldOverrideNetworkMode | validation | func (task *Task) shouldOverrideNetworkMode(container *apicontainer.Container, dockerContainerMap map[string]*apicontainer.DockerContainer) (bool, string) {
// TODO. We can do an early return here by determining which kind of task it is
// Example: Does this task have ENIs in its payload, what is its networking mode ... | go | {
"resource": ""
} |
q169016 | applyENIHostname | validation | func (task *Task) applyENIHostname(dockerConfig *dockercontainer.Config) *dockercontainer.Config {
eni := task.GetTaskENI()
if eni == nil {
return dockerConfig
}
hostname := eni.GetHostname()
if hostname == "" {
return dockerConfig
}
dockerConfig.Hostname = hostname
return dockerConfig
} | go | {
"resource": ""
} |
q169017 | shouldOverridePIDMode | validation | func (task *Task) shouldOverridePIDMode(container *apicontainer.Container, dockerContainerMap map[string]*apicontainer.DockerContainer) (bool, string) {
// If the container is an internal container (ContainerEmptyHostVolume,
// ContainerCNIPause, or ContainerNamespacePause), then PID namespace for
// the container i... | go | {
"resource": ""
} |
q169018 | shouldOverrideIPCMode | validation | func (task *Task) shouldOverrideIPCMode(container *apicontainer.Container, dockerContainerMap map[string]*apicontainer.DockerContainer) (bool, string) {
// All internal containers do not need the same IPCMode. The NamespaceContainerPause
// needs to be "shareable" if ipcMode is "task". All other internal containers s... | go | {
"resource": ""
} |
q169019 | UpdateStatus | validation | func (task *Task) UpdateStatus() bool {
change := task.updateTaskKnownStatus()
// DesiredStatus can change based on a new known status
task.UpdateDesiredStatus()
return change != apitaskstatus.TaskStatusNone
} | go | {
"resource": ""
} |
q169020 | UpdateDesiredStatus | validation | func (task *Task) UpdateDesiredStatus() {
task.lock.Lock()
defer task.lock.Unlock()
task.updateTaskDesiredStatusUnsafe()
task.updateContainerDesiredStatusUnsafe(task.DesiredStatusUnsafe)
task.updateResourceDesiredStatusUnsafe(task.DesiredStatusUnsafe)
} | go | {
"resource": ""
} |
q169021 | SetKnownStatus | validation | func (task *Task) SetKnownStatus(status apitaskstatus.TaskStatus) {
task.setKnownStatus(status)
task.updateKnownStatusTime()
} | go | {
"resource": ""
} |
q169022 | GetKnownStatus | validation | func (task *Task) GetKnownStatus() apitaskstatus.TaskStatus {
task.lock.RLock()
defer task.lock.RUnlock()
return task.KnownStatusUnsafe
} | go | {
"resource": ""
} |
q169023 | GetKnownStatusTime | validation | func (task *Task) GetKnownStatusTime() time.Time {
task.lock.RLock()
defer task.lock.RUnlock()
return task.KnownStatusTimeUnsafe
} | go | {
"resource": ""
} |
q169024 | SetCredentialsID | validation | func (task *Task) SetCredentialsID(id string) {
task.lock.Lock()
defer task.lock.Unlock()
task.credentialsID = id
} | go | {
"resource": ""
} |
q169025 | GetCredentialsID | validation | func (task *Task) GetCredentialsID() string {
task.lock.RLock()
defer task.lock.RUnlock()
return task.credentialsID
} | go | {
"resource": ""
} |
q169026 | SetExecutionRoleCredentialsID | validation | func (task *Task) SetExecutionRoleCredentialsID(id string) {
task.lock.Lock()
defer task.lock.Unlock()
task.ExecutionCredentialsID = id
} | go | {
"resource": ""
} |
q169027 | GetExecutionCredentialsID | validation | func (task *Task) GetExecutionCredentialsID() string {
task.lock.RLock()
defer task.lock.RUnlock()
return task.ExecutionCredentialsID
} | go | {
"resource": ""
} |
q169028 | GetDesiredStatus | validation | func (task *Task) GetDesiredStatus() apitaskstatus.TaskStatus {
task.lock.RLock()
defer task.lock.RUnlock()
return task.DesiredStatusUnsafe
} | go | {
"resource": ""
} |
q169029 | SetDesiredStatus | validation | func (task *Task) SetDesiredStatus(status apitaskstatus.TaskStatus) {
task.lock.Lock()
defer task.lock.Unlock()
task.DesiredStatusUnsafe = status
} | go | {
"resource": ""
} |
q169030 | GetSentStatus | validation | func (task *Task) GetSentStatus() apitaskstatus.TaskStatus {
task.lock.RLock()
defer task.lock.RUnlock()
return task.SentStatusUnsafe
} | go | {
"resource": ""
} |
q169031 | SetSentStatus | validation | func (task *Task) SetSentStatus(status apitaskstatus.TaskStatus) {
task.lock.Lock()
defer task.lock.Unlock()
task.SentStatusUnsafe = status
} | go | {
"resource": ""
} |
q169032 | SetTaskENI | validation | func (task *Task) SetTaskENI(eni *apieni.ENI) {
task.lock.Lock()
defer task.lock.Unlock()
task.ENI = eni
} | go | {
"resource": ""
} |
q169033 | GetTaskENI | validation | func (task *Task) GetTaskENI() *apieni.ENI {
task.lock.RLock()
defer task.lock.RUnlock()
return task.ENI
} | go | {
"resource": ""
} |
q169034 | SetAppMesh | validation | func (task *Task) SetAppMesh(appMesh *apiappmesh.AppMesh) {
task.lock.Lock()
defer task.lock.Unlock()
task.AppMesh = appMesh
} | go | {
"resource": ""
} |
q169035 | GetAppMesh | validation | func (task *Task) GetAppMesh() *apiappmesh.AppMesh {
task.lock.RLock()
defer task.lock.RUnlock()
return task.AppMesh
} | go | {
"resource": ""
} |
q169036 | GetStopSequenceNumber | validation | func (task *Task) GetStopSequenceNumber() int64 {
task.lock.RLock()
defer task.lock.RUnlock()
return task.StopSequenceNumber
} | go | {
"resource": ""
} |
q169037 | SetStopSequenceNumber | validation | func (task *Task) SetStopSequenceNumber(seqnum int64) {
task.lock.Lock()
defer task.lock.Unlock()
task.StopSequenceNumber = seqnum
} | go | {
"resource": ""
} |
q169038 | SetPullStartedAt | validation | func (task *Task) SetPullStartedAt(timestamp time.Time) bool {
task.lock.Lock()
defer task.lock.Unlock()
// Only set this field if it is not set
if task.PullStartedAtUnsafe.IsZero() {
task.PullStartedAtUnsafe = timestamp
return true
}
return false
} | go | {
"resource": ""
} |
q169039 | GetPullStartedAt | validation | func (task *Task) GetPullStartedAt() time.Time {
task.lock.RLock()
defer task.lock.RUnlock()
return task.PullStartedAtUnsafe
} | go | {
"resource": ""
} |
q169040 | SetPullStoppedAt | validation | func (task *Task) SetPullStoppedAt(timestamp time.Time) {
task.lock.Lock()
defer task.lock.Unlock()
task.PullStoppedAtUnsafe = timestamp
} | go | {
"resource": ""
} |
q169041 | GetPullStoppedAt | validation | func (task *Task) GetPullStoppedAt() time.Time {
task.lock.RLock()
defer task.lock.RUnlock()
return task.PullStoppedAtUnsafe
} | go | {
"resource": ""
} |
q169042 | SetExecutionStoppedAt | validation | func (task *Task) SetExecutionStoppedAt(timestamp time.Time) bool {
task.lock.Lock()
defer task.lock.Unlock()
if task.ExecutionStoppedAtUnsafe.IsZero() {
task.ExecutionStoppedAtUnsafe = timestamp
return true
}
return false
} | go | {
"resource": ""
} |
q169043 | GetExecutionStoppedAt | validation | func (task *Task) GetExecutionStoppedAt() time.Time {
task.lock.RLock()
defer task.lock.RUnlock()
return task.ExecutionStoppedAtUnsafe
} | go | {
"resource": ""
} |
q169044 | stringUnsafe | validation | func (task *Task) stringUnsafe() string {
res := fmt.Sprintf("%s:%s %s, TaskStatus: (%s->%s)",
task.Family, task.Version, task.Arn,
task.KnownStatusUnsafe.String(), task.DesiredStatusUnsafe.String())
res += " Containers: ["
for _, container := range task.Containers {
res += fmt.Sprintf("%s (%s->%s),", containe... | go | {
"resource": ""
} |
q169045 | RecordExecutionStoppedAt | validation | func (task *Task) RecordExecutionStoppedAt(container *apicontainer.Container) {
if !container.Essential {
return
}
if container.GetKnownStatus() != apicontainerstatus.ContainerStopped {
return
}
// If the essential container is stopped, set the ExecutionStoppedAt timestamp
now := time.Now()
ok := task.SetExe... | go | {
"resource": ""
} |
q169046 | GetResources | validation | func (task *Task) GetResources() []taskresource.TaskResource {
task.lock.RLock()
defer task.lock.RUnlock()
return task.getResourcesUnsafe()
} | go | {
"resource": ""
} |
q169047 | getResourcesUnsafe | validation | func (task *Task) getResourcesUnsafe() []taskresource.TaskResource {
var resourceList []taskresource.TaskResource
for _, resources := range task.ResourcesMapUnsafe {
resourceList = append(resourceList, resources...)
}
return resourceList
} | go | {
"resource": ""
} |
q169048 | AddResource | validation | func (task *Task) AddResource(resourceType string, resource taskresource.TaskResource) {
task.lock.Lock()
defer task.lock.Unlock()
task.ResourcesMapUnsafe[resourceType] = append(task.ResourcesMapUnsafe[resourceType], resource)
} | go | {
"resource": ""
} |
q169049 | SetTerminalReason | validation | func (task *Task) SetTerminalReason(reason string) {
seelog.Infof("Task [%s]: attempting to set terminal reason for task [%s]", task.Arn, reason)
task.terminalReasonOnce.Do(func() {
seelog.Infof("Task [%s]: setting terminal reason for task [%s]", task.Arn, reason)
// Converts the first letter of terminal reason ... | go | {
"resource": ""
} |
q169050 | GetTerminalReason | validation | func (task *Task) GetTerminalReason() string {
task.lock.RLock()
defer task.lock.RUnlock()
return task.terminalReason
} | go | {
"resource": ""
} |
q169051 | PopulateASMAuthData | validation | func (task *Task) PopulateASMAuthData(container *apicontainer.Container) error {
secretID := container.RegistryAuthentication.ASMAuthData.CredentialsParameter
resource, ok := task.getASMAuthResource()
if !ok {
return errors.New("task auth data: unable to fetch ASM resource")
}
// This will cause a panic if the r... | go | {
"resource": ""
} |
q169052 | getSSMSecretsResource | validation | func (task *Task) getSSMSecretsResource() ([]taskresource.TaskResource, bool) {
task.lock.RLock()
defer task.lock.RUnlock()
res, ok := task.ResourcesMapUnsafe[ssmsecret.ResourceName]
return res, ok
} | go | {
"resource": ""
} |
q169053 | PopulateSecrets | validation | func (task *Task) PopulateSecrets(hostConfig *dockercontainer.HostConfig, container *apicontainer.Container) *apierrors.DockerClientConfigError {
var ssmRes *ssmsecret.SSMSecretResource
var asmRes *asmsecret.ASMSecretResource
if container.ShouldCreateWithSSMSecret() {
resource, ok := task.getSSMSecretsResource()
... | go | {
"resource": ""
} |
q169054 | getASMSecretsResource | validation | func (task *Task) getASMSecretsResource() ([]taskresource.TaskResource, bool) {
task.lock.RLock()
defer task.lock.RUnlock()
res, ok := task.ResourcesMapUnsafe[asmsecret.ResourceName]
return res, ok
} | go | {
"resource": ""
} |
q169055 | getPIDMode | validation | func (task *Task) getPIDMode() string {
task.lock.RLock()
defer task.lock.RUnlock()
return task.PIDMode
} | go | {
"resource": ""
} |
q169056 | getIPCMode | validation | func (task *Task) getIPCMode() string {
task.lock.RLock()
defer task.lock.RUnlock()
return task.IPCMode
} | go | {
"resource": ""
} |
q169057 | AssociationsByTypeAndContainer | validation | func (task *Task) AssociationsByTypeAndContainer(associationType, containerName string) []string {
task.lock.RLock()
defer task.lock.RUnlock()
var associationNames []string
for _, association := range task.Associations {
if association.Type == associationType {
for _, associatedContainerName := range associat... | go | {
"resource": ""
} |
q169058 | AssociationByTypeAndName | validation | func (task *Task) AssociationByTypeAndName(associationType, associationName string) (*Association, bool) {
task.lock.RLock()
defer task.lock.RUnlock()
for _, association := range task.Associations {
if association.Type == associationType && association.Name == associationName {
return &association, true
}
}... | go | {
"resource": ""
} |
q169059 | newAttachENIHandler | validation | func newAttachENIHandler(ctx context.Context,
cluster string,
containerInstanceArn string,
acsClient wsclient.ClientServer,
taskEngineState dockerstate.TaskEngineState,
saver statemanager.Saver) attachENIHandler {
// Create a cancelable context from the parent context
derivedContext, cancel := context.WithCance... | go | {
"resource": ""
} |
q169060 | handlerFunc | validation | func (attachENIHandler *attachENIHandler) handlerFunc() func(message *ecsacs.AttachTaskNetworkInterfacesMessage) {
return func(message *ecsacs.AttachTaskNetworkInterfacesMessage) {
attachENIHandler.messageBuffer <- message
}
} | go | {
"resource": ""
} |
q169061 | handleMessages | validation | func (attachENIHandler *attachENIHandler) handleMessages() {
for {
select {
case message := <-attachENIHandler.messageBuffer:
if err := attachENIHandler.handleSingleMessage(message); err != nil {
seelog.Warnf("Unable to handle ENI Attachment message [%s]: %v", message.String(), err)
}
case <-attachENIH... | go | {
"resource": ""
} |
q169062 | handleSingleMessage | validation | func (handler *attachENIHandler) handleSingleMessage(message *ecsacs.AttachTaskNetworkInterfacesMessage) error {
receivedAt := time.Now()
// Validate fields in the message
if err := validateAttachTaskNetworkInterfacesMessage(message); err != nil {
return errors.Wrapf(err,
"attach eni message handler: error vali... | go | {
"resource": ""
} |
q169063 | addENIAttachmentToState | validation | func (handler *attachENIHandler) addENIAttachmentToState(message *ecsacs.AttachTaskNetworkInterfacesMessage, receivedAt time.Time) error {
attachmentARN := aws.StringValue(message.ElasticNetworkInterfaces[0].AttachmentArn)
mac := aws.StringValue(message.ElasticNetworkInterfaces[0].MacAddress)
taskARN := aws.StringVa... | go | {
"resource": ""
} |
q169064 | validateAttachTaskNetworkInterfacesMessage | validation | func validateAttachTaskNetworkInterfacesMessage(message *ecsacs.AttachTaskNetworkInterfacesMessage) error {
if message == nil {
return errors.Errorf("attach eni handler validation: empty AttachTaskNetworkInterface message received from ECS")
}
messageId := aws.StringValue(message.MessageId)
if messageId == "" {
... | go | {
"resource": ""
} |
q169065 | ForceSave | validation | func (m *MockStateManager) ForceSave() error {
ret := m.ctrl.Call(m, "ForceSave")
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169066 | ForceSave | validation | func (mr *MockStateManagerMockRecorder) ForceSave() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceSave", reflect.TypeOf((*MockStateManager)(nil).ForceSave))
} | go | {
"resource": ""
} |
q169067 | NewMockClientServer | validation | func NewMockClientServer(ctrl *gomock.Controller) *MockClientServer {
mock := &MockClientServer{ctrl: ctrl}
mock.recorder = &MockClientServerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169068 | AddRequestHandler | validation | func (m *MockClientServer) AddRequestHandler(arg0 wsclient.RequestHandler) {
m.ctrl.Call(m, "AddRequestHandler", arg0)
} | go | {
"resource": ""
} |
q169069 | AddRequestHandler | validation | func (mr *MockClientServerMockRecorder) AddRequestHandler(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRequestHandler", reflect.TypeOf((*MockClientServer)(nil).AddRequestHandler), arg0)
} | go | {
"resource": ""
} |
q169070 | Connect | validation | func (mr *MockClientServerMockRecorder) Connect() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockClientServer)(nil).Connect))
} | go | {
"resource": ""
} |
q169071 | Disconnect | validation | func (m *MockClientServer) Disconnect(arg0 ...interface{}) error {
varargs := []interface{}{}
for _, a := range arg0 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Disconnect", varargs...)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169072 | IsConnected | validation | func (m *MockClientServer) IsConnected() bool {
ret := m.ctrl.Call(m, "IsConnected")
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q169073 | MakeRequest | validation | func (m *MockClientServer) MakeRequest(arg0 interface{}) error {
ret := m.ctrl.Call(m, "MakeRequest", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169074 | SetAnyRequestHandler | validation | func (m *MockClientServer) SetAnyRequestHandler(arg0 wsclient.RequestHandler) {
m.ctrl.Call(m, "SetAnyRequestHandler", arg0)
} | go | {
"resource": ""
} |
q169075 | SetConnection | validation | func (m *MockClientServer) SetConnection(arg0 wsconn.WebsocketConn) {
m.ctrl.Call(m, "SetConnection", arg0)
} | go | {
"resource": ""
} |
q169076 | SetReadDeadline | validation | func (m *MockClientServer) SetReadDeadline(arg0 time.Time) error {
ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169077 | ShouldReportToBackend | validation | func (cs *ContainerStatus) ShouldReportToBackend(steadyStateStatus ContainerStatus) bool {
return *cs == steadyStateStatus || *cs == ContainerStopped
} | go | {
"resource": ""
} |
q169078 | BackendStatus | validation | func (cs *ContainerStatus) BackendStatus(steadyStateStatus ContainerStatus) ContainerStatus {
if *cs == steadyStateStatus {
return ContainerRunning
}
if *cs == ContainerStopped {
return ContainerStopped
}
return ContainerStatusNone
} | go | {
"resource": ""
} |
q169079 | UnmarshalJSON | validation | func (cs *ContainerStatus) UnmarshalJSON(b []byte) error {
if strings.ToLower(string(b)) == "null" {
*cs = ContainerStatusNone
return nil
}
if b[0] != '"' || b[len(b)-1] != '"' {
*cs = ContainerStatusNone
return errors.New("container status unmarshal: status must be a string or null; Got " + string(b))
}
s... | go | {
"resource": ""
} |
q169080 | MarshalJSON | validation | func (cs *ContainerStatus) MarshalJSON() ([]byte, error) {
if cs == nil {
return nil, nil
}
return []byte(`"` + cs.String() + `"`), nil
} | go | {
"resource": ""
} |
q169081 | UnmarshalJSON | validation | func (healthStatus *ContainerHealthStatus) UnmarshalJSON(b []byte) error {
*healthStatus = ContainerHealthUnknown
if strings.ToLower(string(b)) == "null" {
return nil
}
if b[0] != '"' || b[len(b)-1] != '"' {
return errors.New("container health status unmarshal: status must be a string or null; Got " + string(b... | go | {
"resource": ""
} |
q169082 | MarshalJSON | validation | func (healthStatus *ContainerHealthStatus) MarshalJSON() ([]byte, error) {
if healthStatus == nil {
return nil, nil
}
return []byte(`"` + healthStatus.String() + `"`), nil
} | go | {
"resource": ""
} |
q169083 | publishMetrics | validation | func (engine *MetricsEngine) publishMetrics() {
go func() {
// Because we are using the DefaultRegisterer in Prometheus, we can use
// the promhttp.Handler() function. In future cases for custom registers,
// we can use promhttp.HandlerFor(customRegisterer, promhttp.HandlerOpts{})
http.Handle("/metrics", promh... | go | {
"resource": ""
} |
q169084 | NewMockDockerClient | validation | func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient {
mock := &MockDockerClient{ctrl: ctrl}
mock.recorder = &MockDockerClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169085 | APIVersion | validation | func (m *MockDockerClient) APIVersion() (dockerclient.DockerVersion, error) {
ret := m.ctrl.Call(m, "APIVersion")
ret0, _ := ret[0].(dockerclient.DockerVersion)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169086 | ContainerEvents | validation | func (m *MockDockerClient) ContainerEvents(arg0 context.Context) (<-chan dockerapi.DockerContainerChangeEvent, error) {
ret := m.ctrl.Call(m, "ContainerEvents", arg0)
ret0, _ := ret[0].(<-chan dockerapi.DockerContainerChangeEvent)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169087 | ContainerEvents | validation | func (mr *MockDockerClientMockRecorder) ContainerEvents(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerEvents", reflect.TypeOf((*MockDockerClient)(nil).ContainerEvents), arg0)
} | go | {
"resource": ""
} |
q169088 | CreateContainer | validation | func (m *MockDockerClient) CreateContainer(arg0 context.Context, arg1 *container0.Config, arg2 *container0.HostConfig, arg3 string, arg4 time.Duration) dockerapi.DockerContainerMetadata {
ret := m.ctrl.Call(m, "CreateContainer", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(dockerapi.DockerContainerMetadata)
retu... | go | {
"resource": ""
} |
q169089 | CreateVolume | validation | func (m *MockDockerClient) CreateVolume(arg0 context.Context, arg1, arg2 string, arg3, arg4 map[string]string, arg5 time.Duration) dockerapi.SDKVolumeResponse {
ret := m.ctrl.Call(m, "CreateVolume", arg0, arg1, arg2, arg3, arg4, arg5)
ret0, _ := ret[0].(dockerapi.SDKVolumeResponse)
return ret0
} | go | {
"resource": ""
} |
q169090 | DescribeContainer | validation | func (m *MockDockerClient) DescribeContainer(arg0 context.Context, arg1 string) (status.ContainerStatus, dockerapi.DockerContainerMetadata) {
ret := m.ctrl.Call(m, "DescribeContainer", arg0, arg1)
ret0, _ := ret[0].(status.ContainerStatus)
ret1, _ := ret[1].(dockerapi.DockerContainerMetadata)
return ret0, ret1
} | go | {
"resource": ""
} |
q169091 | InspectContainer | validation | func (m *MockDockerClient) InspectContainer(arg0 context.Context, arg1 string, arg2 time.Duration) (*types.ContainerJSON, error) {
ret := m.ctrl.Call(m, "InspectContainer", arg0, arg1, arg2)
ret0, _ := ret[0].(*types.ContainerJSON)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169092 | InspectImage | validation | func (m *MockDockerClient) InspectImage(arg0 string) (*types.ImageInspect, error) {
ret := m.ctrl.Call(m, "InspectImage", arg0)
ret0, _ := ret[0].(*types.ImageInspect)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169093 | KnownVersions | validation | func (m *MockDockerClient) KnownVersions() []dockerclient.DockerVersion {
ret := m.ctrl.Call(m, "KnownVersions")
ret0, _ := ret[0].([]dockerclient.DockerVersion)
return ret0
} | go | {
"resource": ""
} |
q169094 | KnownVersions | validation | func (mr *MockDockerClientMockRecorder) KnownVersions() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnownVersions", reflect.TypeOf((*MockDockerClient)(nil).KnownVersions))
} | go | {
"resource": ""
} |
q169095 | ListContainers | validation | func (m *MockDockerClient) ListContainers(arg0 context.Context, arg1 bool, arg2 time.Duration) dockerapi.ListContainersResponse {
ret := m.ctrl.Call(m, "ListContainers", arg0, arg1, arg2)
ret0, _ := ret[0].(dockerapi.ListContainersResponse)
return ret0
} | go | {
"resource": ""
} |
q169096 | ListImages | validation | func (m *MockDockerClient) ListImages(arg0 context.Context, arg1 time.Duration) dockerapi.ListImagesResponse {
ret := m.ctrl.Call(m, "ListImages", arg0, arg1)
ret0, _ := ret[0].(dockerapi.ListImagesResponse)
return ret0
} | go | {
"resource": ""
} |
q169097 | ListPlugins | validation | func (m *MockDockerClient) ListPlugins(arg0 context.Context, arg1 time.Duration, arg2 filters.Args) dockerapi.ListPluginsResponse {
ret := m.ctrl.Call(m, "ListPlugins", arg0, arg1, arg2)
ret0, _ := ret[0].(dockerapi.ListPluginsResponse)
return ret0
} | go | {
"resource": ""
} |
q169098 | ListPluginsWithFilters | validation | func (m *MockDockerClient) ListPluginsWithFilters(arg0 context.Context, arg1 bool, arg2 []string, arg3 time.Duration) ([]string, error) {
ret := m.ctrl.Call(m, "ListPluginsWithFilters", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169099 | PullImage | validation | func (m *MockDockerClient) PullImage(arg0 context.Context, arg1 string, arg2 *container.RegistryAuthenticationData, arg3 time.Duration) dockerapi.DockerContainerMetadata {
ret := m.ctrl.Call(m, "PullImage", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(dockerapi.DockerContainerMetadata)
return ret0
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.