id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168500 | capabilities {
filterList.Add("capability", capability)
}
var filteredPluginNames []string
response := dg.ListPlugins(ctx, timeout, filterList)
if response.Error != nil {
return nil, response.Error
}
// Create a list of the filtered plugin names
for _, plugin := range response.Plugins {
filteredPluginNa... | |
c168501 | := dg.sdkDockerClient()
if err != nil {
return "", err
}
return dg.sdkClientFactory.FindClientAPIVersion(client), nil
} | |
c168502 | response := make(chan error, 1)
go func() {
response <- dg.loadImage(ctx, inputStream)
}()
select {
case resp := <-response:
return resp
case <-ctx.Done():
return &DockerTimeoutError{timeout, "loading image"}
}
} | |
c168503 | %v", container.Name, imageState.Image.ImageID)
imageState.Containers = append(imageState.Containers, container)
} | |
c168504 | state- %v", imageName, imageState.Image.ImageID)
imageState.Image.Names = append(imageState.Image.Names, imageName)
}
} | |
c168505 | imageState.lock.RUnlock()
return len(imageState.Image.Names)
} | |
c168506 | imageState.AddImageName(container.Image)
imageState.UpdateContainerReference(container)
} | |
c168507 | imageState.Image.Names = append(imageState.Image.Names[:i], imageState.Image.Names[i+1:]...)
}
}
} | |
c168508 | == containerImageName {
return true
}
}
return false
} | |
c168509 | Image State- %v", container.Name, imageState.Image.ImageID)
imageState.Containers = append(imageState.Containers[:i], imageState.Containers[i+1:]...)
// Update the last used time for the image
imageState.LastUsedAt = time.Now()
return nil
}
}
return fmt.Errorf("Container reference is not found in the i... | |
c168510 | imageState.lock.Unlock()
imageState.PullSucceeded = pullSucceeded
} | |
c168511 | imageState.lock.RUnlock()
return imageState.PullSucceeded
} | |
c168512 |
PulledAt: imageState.PulledAt,
LastUsedAt: imageState.LastUsedAt,
PullSucceeded: imageState.PullSucceeded,
})
} | |
c168513 |
if strStatus == "DEAD" {
*ts = TaskStopped
return nil
}
stat, ok := taskStatusMap[strStatus]
if !ok {
*ts = TaskStatusNone
return errors.New("Unrecognized TaskStatus")
}
*ts = stat
return nil
} | |
c168514 | nil
}
return []byte(`"` + ts.String() + `"`), nil
} | |
c168515 | cfg.PluginsPath,
cniVersion: cfg.MinSupportedCNIVersion,
subnet: ecsSubnet,
libcni: libcniConfig,
}
} | |
c168516 | err,
}
}(response)
select {
case <-derivedCtx.Done():
return nil, errors.Wrap(derivedCtx.Err(), "cni setup: container namespace setup failed")
case result := <-response:
return result.result, result.err
}
} | |
c168517 | }(err)
select {
case <-derivedCtx.Done():
return errors.Wrap(derivedCtx.Err(), "cni cleanup: container namespace cleanup failed")
case err := <-err:
return err
}
} | |
c168518 |
os.Setenv("ECS_CNI_LOGLEVEL", logger.GetLevel())
defer os.Unsetenv("ECS_CNI_LOGLEVEL")
return client.del(runtimeConfig, cfg, client.createIPAMNetworkConfig)
} | |
c168519 | nil, err
}
runtimeConfig.IfName = deviceName
return client.libcni.AddNetwork(networkConfig, &runtimeConfig)
} | |
c168520 | return err
}
runtimeConfig.IfName = deviceName
return client.libcni.DelNetwork(networkConfig, &runtimeConfig)
} | |
c168521 | ipamConfig
networkConfig, err := client.constructNetworkConfig(bridgeConfig, ECSBridgePluginName)
if err != nil {
return "", nil, errors.Wrap(err, "createBridgeNetworkConfigWithIPAM: construct bridge and ipam network configuration failed")
}
return defaultVethName, networkConfig, nil
} | |
c168522 | return "", nil, errors.Wrap(err, "createBridgeNetworkConfigWithoutIPAM: construct bridge network configuration failed")
}
return defaultVethName, networkConfig, nil
} | |
c168523 | networkConfig := &libcni.NetworkConfig{
Network: &cnitypes.NetConf{
Type: plugin,
},
Bytes: configBytes,
}
return networkConfig, nil
} | |
c168524 | networkConfig, err := client.constructNetworkConfig(ipamNetworkConfig, ECSIPAMPluginName)
if err != nil {
return "", nil, errors.Wrap(err, "createIPAMNetworkConfig: construct ipam network configuration failed")
}
return defaultVethName, networkConfig, nil
} | |
c168525 | err := cmd.Output()
if err != nil {
return "", err
}
version := &cniPluginVersion{}
// versionInfo is of the format
// {"version":"2017.06.0","dirty":true,"gitShortHash":"226db36"}
// Unmarshal this
err = json.Unmarshal(versionInfo, version)
if err != nil {
return "", errors.Wrapf(err, "ecscni: unmarshal ... | |
c168526 | []string `json:"capabilities"`
}{}
err = json.Unmarshal(capabilitiesInfo, capabilities)
if err != nil {
return nil, errors.Wrapf(err, "ecscni: failed to unmarshal capabilities for '%s' from string: %s", name, capabilitiesInfo)
}
return capabilities.Capabilities, nil
} | |
c168527 | stateChangeEvents chan<- statechange.Event) *UdevWatcher {
return newWatcher(ctx, primaryMAC, netlinkwrapper.New(), udevwrap, state, stateChangeEvents)
} | |
c168528 | nlWrap,
udevMonitor: udevWrap,
events: make(chan *udev.UEvent),
agentState: state,
eniChangeEvent: stateChangeEvents,
primaryMAC: primaryMAC,
}
} | |
c168529 | log.Warnf("Udev watcher reconciliation failed: %v", err)
}
case <-udevWatcher.ctx.Done():
udevWatcher.updateIntervalTicker.Stop()
return
}
}
} | |
c168530 | allow
// the race here. The state would be corrected during the next reconciliation loop.
// Add new interfaces next
for mac := range currentState {
if err := udevWatcher.sendENIStateChange(mac); err != nil {
log.Warnf("Udev watcher reconciliation: unable to send state change: %v", err)
}
}
return nil
} | |
c168531 | the ENI, but we decide not to ack it
// as it's ack timeout has expired
udevWatcher.agentState.RemoveENIAttachment(eni.MACAddress)
return errors.Errorf(
"udev watcher send ENI state change: eni status expired, no longer tracking it: %s",
eni.String())
}
// We found an ENI, which has the expiration time ... | |
c168532 |
continue
}
macAddress := link.Attrs().HardwareAddr.String()
if macAddress != "" && macAddress != udevWatcher.primaryMAC {
state[macAddress] = link.Attrs().Name
}
}
return state
} | |
c168533 | nil {
return err
}
// RetryWithBackoffCtx returns nil when the context is cancelled. Check if there was
// a timeout here. TODO: Fix RetryWithBackoffCtx to return ctx.Err() on context Done()
if err = ctx.Err(); err != nil {
return errors.Wrapf(err,
"udev watcher send ENI state change: timed out waiting for ... | |
c168534 | cs.publishHealthTicker.Stop()
}
cs.cancel()
return cs.Disconnect()
} | |
c168535 | }
request.Header.Add("Host", request.Host)
var dataBuffer bytes.Buffer
request.Header.Write(&dataBuffer)
io.WriteString(&dataBuffer, "\r\n")
data := dataBuffer.Bytes()
data = append(data, payload...)
return data, nil
}
} | |
c168536 | over the ticker since its channel doesn't ever get closed
for {
select {
case <-cs.publishTicker.C:
err := cs.publishMetricsOnce()
if err != nil {
seelog.Warnf("Error publishing metrics: %v", err)
}
case <-cs.ctx.Done():
return
}
}
} | |
c168537 | metrics request to the backend.
for _, request := range requests {
err = cs.MakeRequest(request)
if err != nil {
return err
}
}
return nil
} | |
c168538 | send to backend.
requests = append(requests, ecstcs.NewPublishMetricsRequest(requestMetadata, copyTaskMetrics(messageTaskMetrics)))
messageTaskMetrics = messageTaskMetrics[:0]
}
}
if len(messageTaskMetrics) > 0 {
// Create the new metadata object and set fin to true as this is the last message in the payl... | |
c168539 |
for {
select {
case <-cs.publishHealthTicker.C:
err := cs.publishHealthMetricsOnce()
if err != nil {
seelog.Warnf("Unable to publish health metrics: %v", err)
}
case <-cs.ctx.Done():
return
}
}
} | |
c168540 | request to the backend.
for _, request := range requests {
err = cs.MakeRequest(request)
if err != nil {
return err
}
}
return nil
} | |
c168541 | (i+1) == numOfTasks)
requestTaskHealth := copyTaskHealthMetrics(taskHealths)
request := ecstcs.NewPublishHealthMetricsRequest(requestMetadata, requestTaskHealth)
requests = append(requests, request)
taskHealths = taskHealths[:0]
}
}
// Put the rest of the metrics in another request
if len(taskHealths... | |
c168542 | aws.Bool(*metadata.Idle),
MessageId: aws.String(*metadata.MessageId),
Fin: aws.Bool(fin),
}
} | |
c168543 | make([]*ecstcs.TaskMetric, len(from))
copy(to, from)
return to
} | |
c168544 |
ContainerInstance: aws.String(aws.StringValue(metadata.ContainerInstance)),
Fin: aws.Bool(fin),
MessageId: aws.String(aws.StringValue(metadata.MessageId)),
}
} | |
c168545 | make([]*ecstcs.TaskHealth, len(from))
copy(to, from)
return to
} | |
c168546 | return err
}
case DockerVolumeKey:
if unmarshalDockerVolume(key, value, result) != nil {
return err
}
case ASMAuthKey:
if unmarshalASMAuthKey(key, value, result) != nil {
return err
}
case SSMSecretKey:
if unmarshalSSMSecretKey(key, value, result) != nil {
return err
}
case ... | |
c168547 | scope,
Autoprovision: autoprovision,
Driver: driver,
DriverOpts: driverOptions,
Labels: labels,
DockerVolumeName: dockerVolumeName,
},
client: client,
ctx: ctx,
}
v.initStatusToTransitions()
return v, nil
} | |
c168548 | vol.knownStatusUnsafe == resourcestatus.ResourceStatus(VolumeCreated)
} | |
c168549 | defer vol.lock.Unlock()
vol.VolumeConfig.Mountpoint = mountPoint
} | |
c168550 | vol.lock.RUnlock()
return vol.VolumeConfig.Mountpoint
} | |
c168551 | volumeResponse.Error != nil {
return volumeResponse.Error
}
// set readonly field after creation
vol.setMountPoint(volumeResponse.DockerVolume.Name)
return nil
} | |
c168552 | err := vol.client.RemoveVolume(vol.ctx, vol.VolumeConfig.DockerVolumeName, dockerclient.RemoveVolumeTimeout)
if err != nil {
return err
}
return nil
} | |
c168553 | := VolumeStatus(vol.GetDesiredStatus()); return &desiredState }(),
func() *VolumeStatus { knownState := VolumeStatus(vol.GetKnownStatus()); return &knownState }(),
})
} | |
c168554 | {
vol.SetDesiredStatus(resourcestatus.ResourceStatus(*temp.DesiredStatus))
}
if temp.KnownStatus != nil {
vol.SetKnownStatus(resourcestatus.ResourceStatus(*temp.KnownStatus))
}
return nil
} | |
c168555 |
mock.recorder = &MockClientCreatorMockRecorder{mock}
return mock
} | |
c168556 | {
ret := m.ctrl.Call(m, "NewASMClient", arg0, arg1)
ret0, _ := ret[0].(secretsmanageriface.SecretsManagerAPI)
return ret0
} | |
c168557 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewASMClient", reflect.TypeOf((*MockClientCreator)(nil).NewASMClient), arg0, arg1)
} | |
c168558 |
default:
return TransportProtocolTCP, errors.New(protocol + " is not a recognized transport protocol")
}
} | |
c168559 | return tcp
default:
seelog.Critical("Unknown TransportProtocol type!")
return tcp
}
} | |
c168560 | = TransportProtocolTCP
case `"udp"`:
*tp = TransportProtocolUDP
default:
*tp = TransportProtocolTCP
return errors.New("TransportProtocol must be \"tcp\" or \"udp\"; Got " + string(b))
}
return nil
} | |
c168561 |
}
return []byte(`"` + tp.String() + `"`), nil
} | |
c168562 | mock.recorder = &MockManagerMockRecorder{mock}
return mock
} | |
c168563 | := m.ctrl.Call(m, "GetTaskCredentials", arg0)
ret0, _ := ret[0].(credentials.TaskIAMRoleCredentials)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c168564 | string) {
m.ctrl.Call(m, "RemoveCredentials", arg0)
} | |
c168565 | := m.ctrl.Call(m, "SetTaskCredentials", arg0)
ret0, _ := ret[0].(error)
return ret0
} | |
c168566 |
return types.AuthConfig{}, errors.Wrapf(err,
"asm fetching secret from the service for %s", secretID)
}
return extractASMValue(out)
} | |
c168567 |
return "", errors.Wrapf(err, "secret %s", secretID)
}
return aws.StringValue(out.SecretString), nil
} | |
c168568 |
mock.recorder = &MockCgroupFactoryMockRecorder{mock}
return mock
} | |
c168569 |
ret0, _ := ret[0].(cgroups.Cgroup)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168570 |
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockCgroupFactory)(nil).Load), arg0, arg1)
} | |
c168571 |
if err := loadFromFile(ctx, cfg.PauseContainerTarballPath, dockerClient, os.Default); err != nil {
return nil, err
}
return getPauseContainerImage(
config.DefaultPauseContainerImageName, config.DefaultPauseContainerTag, dockerClient)
} | |
c168572 | ioutil,
cgroupRoot: cgroupRoot,
cgroupMountPath: cgroupMountPath,
resourceSpec: resourceSpec,
}
c.initializeResourceStatusToTransitionFunction()
return c
} | |
c168573 | setup cgroup root: %v", cgroup.taskARN, err)
return err
}
return nil
} | |
c168574 | return nil
}
return errors.Wrapf(err, "resource: cleanup cgroup: unable to remove cgroup at %s", cgroup.cgroupRoot)
}
return nil
} | |
c168575 | := CgroupStatus(desiredState)
return &status
}(),
func() *CgroupStatus {
knownState := cgroup.GetKnownStatus()
status := CgroupStatus(knownState)
return &status
}(),
cgroup.resourceSpec,
})
} | |
c168576 | != nil {
cgroup.SetDesiredStatus(resourcestatus.ResourceStatus(*temp.DesiredStatus))
}
if temp.KnownStatus != nil {
cgroup.SetKnownStatus(resourcestatus.ResourceStatus(*temp.KnownStatus))
}
return nil
} | |
c168577 | defer cgroup.lock.RUnlock()
return cgroup.cgroupRoot
} | |
c168578 | defer cgroup.lock.RUnlock()
return cgroup.cgroupMountPath
} | |
c168579 | cgroup.initializeResourceStatusToTransitionFunction()
cgroup.ioutil = resourceFields.IOUtil
cgroup.control = resourceFields.Control
} | |
c168580 | error) {
return nil, NewUnsupportedPlatformError(errors.Errorf(
"pause container load: unsupported platform: %s/%s",
runtime.GOOS, runtime.GOARCH))
} | |
c168581 | httpclient.New(roundtripTimeout, acceptInsecureCert),
}
} | |
c168582 | {
return &ecrClient{}, err
}
return factory.newClient(clientConfig), nil
} | |
c168583 | the credentials are empty")
}
creds := awscreds.NewStaticCredentials(authData.GetPullCredentials().AccessKeyID,
authData.GetPullCredentials().SecretAccessKey,
authData.GetPullCredentials().SessionToken)
cfg = cfg.WithCredentials(creds)
}
return cfg, nil
} | |
c168584 |
mock.recorder = &MockAuditLoggerMockRecorder{mock}
return mock
} | |
c168585 | ret := m.ctrl.Call(m, "GetContainerInstanceArn")
ret0, _ := ret[0].(string)
return ret0
} | |
c168586 | "GetContainerInstanceArn", reflect.TypeOf((*MockAuditLogger)(nil).GetContainerInstanceArn))
} | |
c168587 | {
m.ctrl.Call(m, "Log", arg0, arg1, arg2)
} | |
c168588 | "Log", reflect.TypeOf((*MockAuditLogger)(nil).Log), arg0, arg1, arg2)
} | |
c168589 | mock.recorder = &MockInfoLoggerMockRecorder{mock}
return mock
} | |
c168590 | varargs = append(varargs, a)
}
m.ctrl.Call(m, "Info", varargs...)
} | |
c168591 |
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockInfoLogger)(nil).Info), arg0...)
} | |
c168592 | sent
for _, containerStateChange := range tevent.Containers {
container := containerStateChange.Container
if container.GetSentStatus() < container.GetKnownStatus() {
// We found a container that needs its state
// change to be sent to ECS.
return true
}
}
return false
} | |
c168593 | return err
}
// submitted; ensure we don't retry it
event.setSent()
// Mark event as sent
setChangeSent(event)
// Update the state file
stateSaver.Save()
seelog.Debugf("TaskHandler: Submitted task state change: %s", event.toString())
taskEvents.events.Remove(eventToSubmit)
backoff.Reset()
return nil
} | |
c168594 | client.SubmitContainerStateChange(event.containerChange)
} | |
c168595 | client.SubmitTaskStateChange(event.taskChange)
} | |
c168596 | := event.containerChange.Container
if container != nil && container.GetSentStatus() < containerChangeStatus {
container.SetSentStatus(containerChangeStatus)
}
} | |
c168597 | }
for _, containerStateChange := range event.taskChange.Containers {
container := containerStateChange.Container
containerChangeStatus := containerStateChange.Status
if container.GetSentStatus() < containerChangeStatus {
container.SetSentStatus(containerStateChange.Status)
}
}
} | |
c168598 | event.taskChange.Attachment.SetSentStatus()
event.taskChange.Attachment.StopAckTimer()
}
} | |
c168599 | secretNames,
WithDecryption: aws.Bool(true),
}
out, err := client.GetParameters(in)
if err != nil {
return nil, err
}
return extractSSMValues(out)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.