id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168900 | ret0, _ := ret[0].(*secretsmanager.RotateSecretOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168901 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*secretsmanager.RotateSecretOutput)
return ret0, ret1
} | |
c168902 | append(varargs, a)
}
ret := m.ctrl.Call(m, "RotateSecretWithContext", varargs...)
ret0, _ := ret[0].(*secretsmanager.RotateSecretOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168903 | ret0, _ := ret[0].(*secretsmanager.TagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168904 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*secretsmanager.TagResourceOutput)
return ret0, ret1
} | |
c168905 | ret0, _ := ret[0].(*secretsmanager.UntagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168906 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*secretsmanager.UntagResourceOutput)
return ret0, ret1
} | |
c168907 | append(varargs, a)
}
ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...)
ret0, _ := ret[0].(*secretsmanager.UntagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168908 | ret0, _ := ret[0].(*secretsmanager.UpdateSecretOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168909 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*secretsmanager.UpdateSecretOutput)
return ret0, ret1
} | |
c168910 | ret0, _ := ret[0].(*secretsmanager.UpdateSecretVersionStageOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168911 | _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*secretsmanager.UpdateSecretVersionStageOutput)
return ret0, ret1
} | |
c168912 | = append(varargs, a)
}
ret := m.ctrl.Call(m, "UpdateSecretVersionStageWithContext", varargs...)
ret0, _ := ret[0].(*secretsmanager.UpdateSecretVersionStageOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168913 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretVersionStageWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UpdateSecretVersionStageWithContext), varargs...)
} | |
c168914 | append(varargs, a)
}
ret := m.ctrl.Call(m, "UpdateSecretWithContext", varargs...)
ret0, _ := ret[0].(*secretsmanager.UpdateSecretOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168915 | dataDirOnHost, metadataDirectoryPath, mountPoint, randID)
metadataEnvVariable := fmt.Sprintf("%s=%s/%s/%s", metadataEnvironmentVariable, mountPoint, randID, metadataFile)
binds = append(binds, instanceBind)
env = append(env, metadataEnvVariable)
return binds, env
} | |
c168916 | containerInstanceARN: manager.containerInstanceARN,
metadataStatus: MetadataInitial,
availabilityZone: manager.availabilityZone,
hostPublicIPv4Address: manager.hostPublicIPv4Address,
}
} | |
c168917 | taskDefinitionFamily: task.Family,
taskDefinitionRevision: task.Version,
},
dockerContainerMetadata: dockerMD,
containerInstanceARN: manager.containerInstanceARN,
metadataStatus: MetadataReady,
availabilityZone: manager.availabilityZone,
hostPublicIPv4Address: manager.hostPublicI... | |
c168918 | container %s: %v", taskARN, containerName, err)
}
// Get Port bindings from NetworkSettings
var ports []apicontainer.PortBinding
ports, err = apicontainer.PortBindingFromDockerPortBinding(dockerContainer.NetworkSettings.Ports)
if err != nil {
seelog.Warnf("Failed to parse container metadata for task %s contain... | |
c168919 | this is the network with which the container is created
ipv4AddressFromSettings := settings.IPAddress
networkModeFromHostConfig := string(hostConfig.NetworkMode)
// Extensive Network information is not available for Docker API versions 1.17-1.20
// Instead we only get the details of the first network
networkList... | |
c168920 | if err != nil {
return errors.Wrapf(err, "could not unmarshal GPU file content")
}
n.SetDriverVersion(nvidiaGPUInfo.GetDriverVersion())
nvidiaGPUInfo.lock.RLock()
gpuIDs := nvidiaGPUInfo.GetGPUIDsUnsafe()
nvidiaGPUInfo.lock.RUnlock()
n.SetGPUIDs(gpuIDs)
n.SetDevices()
} else {
seelog.Error("Config ... | |
c168921 | defer n.lock.Unlock()
n.GPUIDs = gpuIDs
} | |
c168922 |
defer n.lock.Unlock()
n.DriverVersion = version
} | |
c168923 | defer n.lock.RUnlock()
return n.DriverVersion
} | |
c168924 | defer n.lock.RUnlock()
return n.GPUDevices
} | |
c168925 | ctrl}
mock.recorder = &MockLicenseProviderMockRecorder{mock}
return mock
} | |
c168926 | := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168927 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetText", reflect.TypeOf((*MockLicenseProvider)(nil).GetText))
} | |
c168928 | mock.recorder = &MockBackoffMockRecorder{mock}
return mock
} | |
c168929 | ret0, _ := ret[0].(time.Duration)
return ret0
} | |
c168930 | "Duration", reflect.TypeOf((*MockBackoff)(nil).Duration))
} | |
c168931 | *status = MetadataReady
default:
return fmt.Errorf("failed unmarshalling MetadataStatus %s", text)
}
return nil
} | |
c168932 | {
return time.After(d)
} | |
c168933 |
return time.AfterFunc(d, f)
} | |
c168934 | {
return _time.Now().Sub(t)
} | |
c168935 |
mock.recorder = &MockTaskResourceMockRecorder{mock}
return mock
} | |
c168936 | := m.ctrl.Call(m, "ApplyTransition", arg0)
ret0, _ := ret[0].(error)
return ret0
} | |
c168937 | ret0, _ := ret[0].(error)
return ret0
} | |
c168938 | ret0, _ := ret[0].(time.Time)
return ret0
} | |
c168939 |
ret0, _ := ret[0].(string)
return ret0
} | |
c168940 | reflect.TypeOf((*MockTaskResource)(nil).Initialize), arg0, arg1, arg2)
} | |
c168941 | ret0, _ := ret[0].(bool)
return ret0
} | |
c168942 | "MarshalJSON", reflect.TypeOf((*MockTaskResource)(nil).MarshalJSON))
} | |
c168943 |
ret := m.ctrl.Call(m, "NextKnownState")
ret0, _ := ret[0].(status0.ResourceStatus)
return ret0
} | |
c168944 | := m.ctrl.Call(m, "SetAppliedStatus", arg0)
ret0, _ := ret[0].(bool)
return ret0
} | |
c168945 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAppliedStatus", reflect.TypeOf((*MockTaskResource)(nil).SetAppliedStatus), arg0)
} | |
c168946 | time.Time) {
m.ctrl.Call(m, "SetCreatedAt", arg0)
} | |
c168947 | status0.ResourceStatus) {
m.ctrl.Call(m, "SetDesiredStatus", arg0)
} | |
c168948 | status0.ResourceStatus) {
m.ctrl.Call(m, "SetKnownStatus", arg0)
} | |
c168949 | := m.ctrl.Call(m, "StatusString", arg0)
ret0, _ := ret[0].(string)
return ret0
} | |
c168950 | mock.recorder = &MockLoaderMockRecorder{mock}
return mock
} | |
c168951 |
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadImage", reflect.TypeOf((*MockLoader)(nil).LoadImage), arg0, arg1, arg2)
} | |
c168952 | in task '%s'",
cnferror.ContainerName, cnferror.TaskArn)
} | |
c168953 | event.Volumes)
}
if len(event.Labels) != 0 {
res += fmt.Sprintf(", Labels: %v", event.Labels)
}
if !event.CreatedAt.IsZero() {
res += ", CreatedAt: " + event.CreatedAt.String()
}
if !event.StartedAt.IsZero() {
res += ", StartedAt: " + event.StartedAt.String()
}
if !event.FinishedAt.IsZero() {
res += ... | |
c168954 | to host")
}
if err := json.Unmarshal(volumeType, &tv.Type); err != nil {
return err
}
switch tv.Type {
case HostVolumeType:
return tv.unmarshalHostVolume(intermediate["host"])
case DockerVolumeType:
return tv.unmarshalDockerVolume(intermediate["dockerVolumeConfiguration"])
default:
return errors.Errorf... | |
c168955 |
result["host"] = tv.Volume
default:
return nil, errors.Errorf("unrecognized volume type: %q", tv.Type)
}
return json.Marshal(result)
} | |
c168956 | awscreds.NewStaticCredentials(creds.AccessKeyID, creds.SecretAccessKey,
creds.SessionToken))
sess := session.Must(session.NewSession(cfg))
return ssm.New(sess)
} | |
c168957 | := range getWindowsReplaceableVersions() {
if v == version {
version = minDockerAPIVersion
break
}
}
return f.getClient(version)
} | |
c168958 |
dockerclient.Version_1_18,
dockerclient.Version_1_19,
dockerclient.Version_1_20,
dockerclient.Version_1_21,
dockerclient.Version_1_22,
dockerclient.Version_1_23,
}
} | |
c168959 |
dockerclient.Version_1_25,
dockerclient.Version_1_26,
dockerclient.Version_1_27,
dockerclient.Version_1_28,
dockerclient.Version_1_29,
dockerclient.Version_1_30,
}
} | |
c168960 | err := strconv.Atoi(binding.HostPort)
if err != nil {
return nil, &apierrors.DefaultNamedError{Name: UnparseablePortErrorName, Err: "Error parsing port binding as int " + err.Error()}
}
portBindings = append(portBindings, PortBinding{
ContainerPort: uint16(containerPort),
HostPort: uint16(hos... | |
c168961 | credentialsManager,
executionCredentialsID: executionCredentialsID,
asmClientCreator: asmClientCreator,
}
c.initStatusToTransition()
return c
} | |
c168962 | err := auth.retrieveASMDockerAuthData(a)
if err != nil {
auth.setTerminalReason(err.Error())
return err
}
}
return nil
} | |
c168963 | defer auth.lock.RUnlock()
return auth.requiredASMResources
} | |
c168964 | defer auth.lock.RUnlock()
return auth.executionCredentialsID
} | |
c168965 | auth.dockerAuthData {
delete(auth.dockerAuthData, k)
}
} | |
c168966 |
defer auth.lock.RUnlock()
d, ok := auth.dockerAuthData[secretID]
return d, ok
} | |
c168967 | {
desiredState := auth.GetDesiredStatus()
status := ASMAuthStatus(desiredState)
return &status
}(),
KnownStatus: func() *ASMAuthStatus {
knownState := auth.GetKnownStatus()
status := ASMAuthStatus(knownState)
return &status
}(),
RequiredASMResources: auth.GetRequiredASMResources(),
Execut... | |
c168968 | !temp.CreatedAt.IsZero() {
auth.SetCreatedAt(*temp.CreatedAt)
}
if temp.RequiredASMResources != nil {
auth.requiredASMResources = temp.RequiredASMResources
}
auth.taskARN = temp.TaskARN
auth.executionCredentialsID = temp.ExecutionCredentialsID
return nil
} | |
c168969 | errResponseJSON, utils.RequestTypeContainerMetadata)
return
}
seelog.Infof("V3 container metadata handler: writing response for container '%s'", containerID)
responseJSON, _ := json.Marshal(containerResponse)
utils.WriteJSONToResponse(w, http.StatusOK, responseJSON, utils.RequestTypeContainerMetadata)
}
} | |
c168970 | set
if containerResponse.Networks == nil {
if containerResponse.Networks, err = GetContainerNetworkMetadata(containerID, state); err != nil {
return nil, err
}
}
return containerResponse, nil
} | |
c168971 | {
for modeFromSettings, containerNetwork := range settings.Networks {
networkMode := modeFromSettings
ipv4Addresses := []string{containerNetwork.IPAddress}
network := containermetadata.Network{NetworkMode: networkMode, IPv4Addresses: ipv4Addresses}
networks = append(networks, network)
}
} else {
ipv... | |
c168972 | status.TaskStatus,
taskDesiredStatus status.TaskStatus) {
} | |
c168973 |
seelog.Criticalf("Error saving state before final shutdown: %v", err)
// Terminal because it's a sigterm; the user doesn't want it to restart
os.Exit(exitcodes.ExitTerminal)
}
os.Exit(exitcodes.ExitSuccess)
} | |
c168974 | to save to disk")
})
go func() {
seelog.Debug("Saving state before shutting down")
stateSaved <- saver.ForceSave()
saveTimer.Stop()
}()
saveErr := <-stateSaved
if disableErr != nil || saveErr != nil {
return apierrors.NewMultiError(disableErr, saveErr)
}
return nil
} | |
c168975 | key.roleARN, key.region, key.registryID, key.endpointOverride)
} | |
c168976 | &ecrAuthProvider{
tokenCache: cache,
factory: ecrFactory,
}
} | |
c168977 | err)
// Remove invalid token from cache
authProvider.tokenCache.Delete(key.String())
return nil
}
return &auth
} else {
// Remove invalid token from cache
authProvider.tokenCache.Delete(key.String())
}
return nil
} | |
c168978 |
// Verify the auth data has the correct format for ECR
if ecrAuthData.ProxyEndpoint != nil &&
strings.HasPrefix(proxyEndpointScheme+image, aws.StringValue(ecrAuthData.ProxyEndpoint)) &&
ecrAuthData.AuthorizationToken != nil {
// Cache the new token
authProvider.tokenCache.Set(key.String(), ecrAuthData)
re... | |
c168979 | retry.AddJitter(MinimumJitterDuration, MinimumJitterDuration))
return time.Now().Before(refreshTime)
} | |
c168980 | find requested resource: " + resourceID)
responseJSON, _ = json.Marshal(&TaskResponse{})
status = http.StatusNotFound
}
return responseJSON, status
} | |
c168981 | sent",
taskKnownStatus.String())
}
event = TaskStateChange{
TaskARN: task.Arn,
Status: taskKnownStatus,
Reason: reason,
Task: task,
}
event.SetTaskTimestamps()
return event, nil
} | |
c168982 | api: internal container: %s",
cont.Name)
}
if cont.GetSentStatus() >= contKnownStatus {
return event, errors.Errorf(
"create container state change event api: status [%s] already sent for container %s, task %s",
contKnownStatus.String(), cont.Name, task.Arn)
}
if reason == "" && cont.ApplyingError != n... | |
c168983 | aws.Time(timestamp.UTC())
}
if timestamp := change.Task.GetPullStoppedAt(); !timestamp.IsZero() {
change.PullStoppedAt = aws.Time(timestamp.UTC())
}
if timestamp := change.Task.GetExecutionStoppedAt(); !timestamp.IsZero() {
change.ExecutionStoppedAt = aws.Time(timestamp.UTC())
}
} | |
c168984 | the Attachment statechange check into this method
if change.Status == apitaskstatus.TaskRunning || change.Status == apitaskstatus.TaskStopped {
return true
}
if len(change.Containers) != 0 {
return true
}
return false
} | |
c168985 | = append(addresses, addr.Address)
}
return addresses
} | |
c168986 | = append(addresses, addr.Address)
}
return addresses
} | |
c168987 | dns: [%s], dns search: [%s], gateway ipv4: [%s]",
eni.ID, eni.MacAddress, eni.GetHostname(), strings.Join(ipv4Addresses, ","), strings.Join(ipv6Addresses, ","),
strings.Join(eni.DomainNameServers, ","), strings.Join(eni.DomainNameSearchList, ","), eni.SubnetGatewayIPV4Address)
} | |
c168988 | ipv6,
MacAddress: aws.StringValue(acsenis[0].MacAddress),
PrivateDNSName: aws.StringValue(acsenis[0].PrivateDnsName),
SubnetGatewayIPV4Address: aws.StringValue(acsenis[0].SubnetGatewayIpv4Address),
}
for _, nameserverIP := range acsenis[0].DomainNameServers {
eni.DomainNameServers... | |
c168989 | addresses in the message(%d)", len(acsenis[0].Ipv6Addresses))
}
if acsenis[0].MacAddress == nil {
return errors.Errorf("eni message validation: empty eni mac address in the message")
}
if acsenis[0].Ec2Id == nil {
return errors.Errorf("eni message validation: empty eni id in the message")
}
return nil
} | |
c168990 | mock.recorder = &MockPluginsMockRecorder{mock}
return mock
} | |
c168991 | := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168992 | "Scan", reflect.TypeOf((*MockPlugins)(nil).Scan))
} | |
c168993 | != apicontainer.ContainerOverrides{}) && container.Overrides.Command != nil {
container.Command = *container.Overrides.Command
}
container.TransitionDependenciesMap = make(map[apicontainerstatus.ContainerStatus]apicontainer.TransitionDependencySet)
}
// initialize resources map for task
task.ResourcesMapUnsa... | |
c168994 | taskresourcevolume.TaskScope {
err := task.addTaskScopedVolumes(ctx, dockerClient, &task.Volumes[i])
if err != nil {
return err
}
} else {
// Agent needs to create shared volume if that's auto provisioned
err := task.addSharedVolumes(sharedVolumeMatchFullConfig, ctx, dockerClient, &task.Volumes[i]... | |
c168995 | dockerClient)
if err != nil {
return err
}
vol.Volume = &volumeResource.VolumeConfig
task.AddResource(resourcetype.DockerVolumeKey, volumeResource)
task.updateContainerVolumeDependency(vol.Name)
return nil
} | |
c168996 |
container.BuildResourceDependency(name,
resourcestatus.ResourceCreated,
apicontainerstatus.ContainerPulled)
}
}
}
} | |
c168997 | task.Containers {
// container.Environment map would not be initialized if there are
// no environment variables to be set or overridden in the container
// config. Check if that's the case and initilialize if needed
if container.Environment == nil {
container.Environment = make(map[string]string)
}
con... | |
c168998 | container.GetV3EndpointID()
if v3EndpointID == "" { // if container's v3 endpoint has not been set
container.SetV3EndpointID(uuidProvider.New())
}
container.InjectV3MetadataEndpoint()
}
} | |
c168999 | := range task.Containers {
if container.ShouldPullWithASMAuth() {
return true
}
}
return false
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.