_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168500 | ListPluginsWithFilters | validation | func (dg *dockerGoClient) ListPluginsWithFilters(ctx context.Context, enabled bool, capabilities []string, timeout time.Duration) ([]string, error) {
// Create filter list
filterList := filters.NewArgs(filters.Arg("enabled", strconv.FormatBool(enabled)))
for _, capability := range capabilities {
filterList.Add("ca... | go | {
"resource": ""
} |
q168501 | APIVersion | validation | func (dg *dockerGoClient) APIVersion() (dockerclient.DockerVersion, error) {
client, err := dg.sdkDockerClient()
if err != nil {
return "", err
}
return dg.sdkClientFactory.FindClientAPIVersion(client), nil
} | go | {
"resource": ""
} |
q168502 | LoadImage | validation | func (dg *dockerGoClient) LoadImage(ctx context.Context, inputStream io.Reader, timeout time.Duration) error {
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
defer metrics.MetricsEngineGlobal.RecordDockerMetric("LOAD_IMAGE")()
response := make(chan error, 1)
go func() {
response <- dg.loadImage(... | go | {
"resource": ""
} |
q168503 | UpdateContainerReference | validation | func (imageState *ImageState) UpdateContainerReference(container *apicontainer.Container) {
imageState.lock.Lock()
defer imageState.lock.Unlock()
seelog.Infof("Updating container reference %v in Image State - %v", container.Name, imageState.Image.ImageID)
imageState.Containers = append(imageState.Containers, contai... | go | {
"resource": ""
} |
q168504 | AddImageName | validation | func (imageState *ImageState) AddImageName(imageName string) {
imageState.lock.Lock()
defer imageState.lock.Unlock()
if !imageState.HasImageName(imageName) {
seelog.Infof("Adding image name- %v to Image state- %v", imageName, imageState.Image.ImageID)
imageState.Image.Names = append(imageState.Image.Names, image... | go | {
"resource": ""
} |
q168505 | GetImageNamesCount | validation | func (imageState *ImageState) GetImageNamesCount() int {
imageState.lock.RLock()
defer imageState.lock.RUnlock()
return len(imageState.Image.Names)
} | go | {
"resource": ""
} |
q168506 | UpdateImageState | validation | func (imageState *ImageState) UpdateImageState(container *apicontainer.Container) {
imageState.AddImageName(container.Image)
imageState.UpdateContainerReference(container)
} | go | {
"resource": ""
} |
q168507 | RemoveImageName | validation | func (imageState *ImageState) RemoveImageName(containerImageName string) {
imageState.lock.Lock()
defer imageState.lock.Unlock()
for i, imageName := range imageState.Image.Names {
if imageName == containerImageName {
imageState.Image.Names = append(imageState.Image.Names[:i], imageState.Image.Names[i+1:]...)
... | go | {
"resource": ""
} |
q168508 | HasImageName | validation | func (imageState *ImageState) HasImageName(containerImageName string) bool {
for _, imageName := range imageState.Image.Names {
if imageName == containerImageName {
return true
}
}
return false
} | go | {
"resource": ""
} |
q168509 | RemoveContainerReference | validation | func (imageState *ImageState) RemoveContainerReference(container *apicontainer.Container) error {
// Get the image state write lock for updating container reference
imageState.lock.Lock()
defer imageState.lock.Unlock()
for i := range imageState.Containers {
if imageState.Containers[i].Name == container.Name {
... | go | {
"resource": ""
} |
q168510 | SetPullSucceeded | validation | func (imageState *ImageState) SetPullSucceeded(pullSucceeded bool) {
imageState.lock.Lock()
defer imageState.lock.Unlock()
imageState.PullSucceeded = pullSucceeded
} | go | {
"resource": ""
} |
q168511 | GetPullSucceeded | validation | func (imageState *ImageState) GetPullSucceeded() bool {
imageState.lock.RLock()
defer imageState.lock.RUnlock()
return imageState.PullSucceeded
} | go | {
"resource": ""
} |
q168512 | MarshalJSON | validation | func (imageState *ImageState) MarshalJSON() ([]byte, error) {
imageState.lock.Lock()
defer imageState.lock.Unlock()
return json.Marshal(&struct {
Image *Image
PulledAt time.Time
LastUsedAt time.Time
PullSucceeded bool
}{
Image: imageState.Image,
PulledAt: imageState.PulledA... | go | {
"resource": ""
} |
q168513 | UnmarshalJSON | validation | func (ts *TaskStatus) UnmarshalJSON(b []byte) error {
if strings.ToLower(string(b)) == "null" {
*ts = TaskStatusNone
return nil
}
if b[0] != '"' || b[len(b)-1] != '"' {
*ts = TaskStatusNone
return errors.New("TaskStatus must be a string or null")
}
strStatus := string(b[1 : len(b)-1])
// 'UNKNOWN' and 'DE... | go | {
"resource": ""
} |
q168514 | MarshalJSON | validation | func (ts *TaskStatus) MarshalJSON() ([]byte, error) {
if ts == nil {
return nil, nil
}
return []byte(`"` + ts.String() + `"`), nil
} | go | {
"resource": ""
} |
q168515 | NewClient | validation | func NewClient(cfg *Config) CNIClient {
libcniConfig := &libcni.CNIConfig{
Path: []string{cfg.PluginsPath},
}
return &cniClient{
pluginsPath: cfg.PluginsPath,
cniVersion: cfg.MinSupportedCNIVersion,
subnet: ecsSubnet,
libcni: libcniConfig,
}
} | go | {
"resource": ""
} |
q168516 | SetupNS | validation | func (client *cniClient) SetupNS(ctx context.Context,
cfg *Config,
timeout time.Duration) (*current.Result, error) {
derivedCtx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
type output struct {
result *current.Result
err error
}
response := make(chan output)
go func(response chan output) ... | go | {
"resource": ""
} |
q168517 | CleanupNS | validation | func (client *cniClient) CleanupNS(
ctx context.Context,
cfg *Config,
timeout time.Duration) error {
derivedCtx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
err := make(chan error)
go func(err chan error) {
err <- client.cleanupNS(cfg)
}(err)
select {
case <-derivedCtx.Done():
return err... | go | {
"resource": ""
} |
q168518 | ReleaseIPResource | validation | func (client *cniClient) ReleaseIPResource(cfg *Config) error {
runtimeConfig := libcni.RuntimeConf{
ContainerID: cfg.ContainerID,
NetNS: fmt.Sprintf(netnsFormat, cfg.ContainerPID),
}
seelog.Debugf("[ECSCNI] Releasing the ip resource from ipam db, id: [%s], ip: [%v]", cfg.ID, cfg.IPAMV4Address)
os.Setenv... | go | {
"resource": ""
} |
q168519 | add | validation | func (client *cniClient) add(runtimeConfig libcni.RuntimeConf,
cfg *Config,
pluginConfigFunc func(*Config) (string, *libcni.NetworkConfig, error)) (cnitypes.Result, error) {
deviceName, networkConfig, err := pluginConfigFunc(cfg)
if err != nil {
return nil, err
}
runtimeConfig.IfName = deviceName
return clie... | go | {
"resource": ""
} |
q168520 | del | validation | func (client *cniClient) del(runtimeConfig libcni.RuntimeConf,
cfg *Config,
pluginConfigFunc func(*Config) (string, *libcni.NetworkConfig, error)) error {
deviceName, networkConfig, err := pluginConfigFunc(cfg)
if err != nil {
return err
}
runtimeConfig.IfName = deviceName
return client.libcni.DelNetwork(net... | go | {
"resource": ""
} |
q168521 | createBridgeNetworkConfigWithIPAM | validation | func (client *cniClient) createBridgeNetworkConfigWithIPAM(cfg *Config) (string, *libcni.NetworkConfig, error) {
// Create the bridge config first
bridgeConfig := client.createBridgeConfig(cfg)
// Create the ipam config
ipamConfig, err := client.createIPAMConfig(cfg)
if err != nil {
return "", nil, errors.Wrap(... | go | {
"resource": ""
} |
q168522 | createBridgeNetworkConfigWithoutIPAM | validation | func (client *cniClient) createBridgeNetworkConfigWithoutIPAM(cfg *Config) (string, *libcni.NetworkConfig, error) {
networkConfig, err := client.constructNetworkConfig(client.createBridgeConfig(cfg), ECSBridgePluginName)
if err != nil {
return "", nil, errors.Wrap(err, "createBridgeNetworkConfigWithoutIPAM: constru... | go | {
"resource": ""
} |
q168523 | constructNetworkConfig | validation | func (client *cniClient) constructNetworkConfig(cfg interface{}, plugin string) (*libcni.NetworkConfig, error) {
configBytes, err := json.Marshal(cfg)
if err != nil {
seelog.Errorf("[ECSCNI] Marshal configuration for plugin %s failed, error: %v", plugin, err)
return nil, err
}
networkConfig := &libcni.NetworkCo... | go | {
"resource": ""
} |
q168524 | createIPAMNetworkConfig | validation | func (client *cniClient) createIPAMNetworkConfig(cfg *Config) (string, *libcni.NetworkConfig, error) {
ipamConfig, err := client.createIPAMConfig(cfg)
if err != nil {
return defaultVethName, nil, errors.Wrap(err, "createIPAMNetworkConfig: create ipam network configuration failed")
}
ipamNetworkConfig := IPAMNetw... | go | {
"resource": ""
} |
q168525 | Version | validation | func (client *cniClient) Version(name string) (string, error) {
file := filepath.Join(client.pluginsPath, name)
// Check if the plugin file exists before executing it
_, err := os.Stat(file)
if err != nil {
return "", err
}
cmd := exec.Command(file, versionCommand)
versionInfo, err := cmd.Output()
if err !=... | go | {
"resource": ""
} |
q168526 | Capabilities | validation | func (client *cniClient) Capabilities(name string) ([]string, error) {
file := filepath.Join(client.pluginsPath, name)
// Check if the plugin file exists before executing it
_, err := os.Stat(file)
if err != nil {
return nil, errors.Wrapf(err, "ecscni: unable to describe file info for '%s'", file)
}
cmd := ex... | go | {
"resource": ""
} |
q168527 | New | validation | func New(ctx context.Context, primaryMAC string, udevwrap udevwrapper.Udev,
state dockerstate.TaskEngineState, stateChangeEvents chan<- statechange.Event) *UdevWatcher {
return newWatcher(ctx, primaryMAC, netlinkwrapper.New(), udevwrap, state, stateChangeEvents)
} | go | {
"resource": ""
} |
q168528 | newWatcher | validation | func newWatcher(ctx context.Context,
primaryMAC string,
nlWrap netlinkwrapper.NetLink,
udevWrap udevwrapper.Udev,
state dockerstate.TaskEngineState,
stateChangeEvents chan<- statechange.Event) *UdevWatcher {
derivedContext, cancel := context.WithCancel(ctx)
return &UdevWatcher{
ctx: derivedContext,... | go | {
"resource": ""
} |
q168529 | performPeriodicReconciliation | validation | func (udevWatcher *UdevWatcher) performPeriodicReconciliation(updateInterval time.Duration) {
udevWatcher.updateIntervalTicker = time.NewTicker(updateInterval)
for {
select {
case <-udevWatcher.updateIntervalTicker.C:
if err := udevWatcher.reconcileOnce(); err != nil {
log.Warnf("Udev watcher reconciliatio... | go | {
"resource": ""
} |
q168530 | reconcileOnce | validation | func (udevWatcher *UdevWatcher) reconcileOnce() error {
links, err := udevWatcher.netlinkClient.LinkList()
if err != nil {
return errors.Wrapf(err, "udev watcher: unable to retrieve network interfaces")
}
// Return on empty list
if len(links) == 0 {
log.Info("Udev watcher reconciliation: no network interfaces... | go | {
"resource": ""
} |
q168531 | sendENIStateChange | validation | func (udevWatcher *UdevWatcher) sendENIStateChange(mac string) error {
if mac == "" {
return errors.New("udev watcher send ENI state change: empty mac address")
}
// check if this is an eni required by a task
eni, ok := udevWatcher.agentState.ENIByMac(mac)
if !ok {
return &unmanagedENIError{mac}
}
if eni.IsS... | go | {
"resource": ""
} |
q168532 | buildState | validation | func (udevWatcher *UdevWatcher) buildState(links []netlink.Link) map[string]string {
state := make(map[string]string)
for _, link := range links {
if link.Type() != linkTypeDevice {
// We only care about netlink.Device types. These are created
// by udev like 'lo' and 'eth0'. Ignore other link types
contin... | go | {
"resource": ""
} |
q168533 | sendENIStateChangeWithRetries | validation | func (udevWatcher *UdevWatcher) sendENIStateChangeWithRetries(parentCtx context.Context,
macAddress string,
timeout time.Duration) error {
backoff := retry.NewExponentialBackoff(sendENIStateChangeBackoffMin, sendENIStateChangeBackoffMax,
sendENIStateChangeBackoffJitter, sendENIStateChangeBackoffMultiple)
ctx, can... | go | {
"resource": ""
} |
q168534 | Close | validation | func (cs *clientServer) Close() error {
if cs.publishTicker != nil {
cs.publishTicker.Stop()
}
if cs.publishHealthTicker != nil {
cs.publishHealthTicker.Stop()
}
cs.cancel()
return cs.Disconnect()
} | go | {
"resource": ""
} |
q168535 | signRequestFunc | validation | func signRequestFunc(url, region string, credentialProvider *credentials.Credentials) wsclient.MakeRequestHookFunc {
return func(payload []byte) ([]byte, error) {
reqBody := bytes.NewReader(payload)
request, err := http.NewRequest("GET", url, reqBody)
if err != nil {
return nil, err
}
err = utils.SignHT... | go | {
"resource": ""
} |
q168536 | publishMetrics | validation | func (cs *clientServer) publishMetrics() {
if cs.publishTicker == nil {
seelog.Debug("Skipping publishing metrics. Publish ticker is uninitialized")
return
}
// Publish metrics immediately after we connect and wait for ticks. This makes
// sure that there is no data loss when a scheduled metrics publishing fai... | go | {
"resource": ""
} |
q168537 | publishMetricsOnce | validation | func (cs *clientServer) publishMetricsOnce() error {
// Get the list of objects to send to backend.
requests, err := cs.metricsToPublishMetricRequests()
if err != nil {
return err
}
// Make the publish metrics request to the backend.
for _, request := range requests {
err = cs.MakeRequest(request)
if err !... | go | {
"resource": ""
} |
q168538 | metricsToPublishMetricRequests | validation | func (cs *clientServer) metricsToPublishMetricRequests() ([]*ecstcs.PublishMetricsRequest, error) {
metadata, taskMetrics, err := cs.statsEngine.GetInstanceMetrics()
if err != nil {
return nil, err
}
var requests []*ecstcs.PublishMetricsRequest
if *metadata.Idle {
metadata.Fin = aws.Bool(true)
// Idle insta... | go | {
"resource": ""
} |
q168539 | publishHealthMetrics | validation | func (cs *clientServer) publishHealthMetrics() {
if cs.publishTicker == nil {
seelog.Debug("Skipping publishing health metrics. Publish ticker is uninitialized")
return
}
// Publish metrics immediately after we connect and wait for ticks. This makes
// sure that there is no data loss when a scheduled metrics p... | go | {
"resource": ""
} |
q168540 | publishHealthMetricsOnce | validation | func (cs *clientServer) publishHealthMetricsOnce() error {
// Get the list of health request to send to backend.
requests, err := cs.createPublishHealthRequests()
if err != nil {
return err
}
// Make the publish metrics request to the backend.
for _, request := range requests {
err = cs.MakeRequest(request)
... | go | {
"resource": ""
} |
q168541 | createPublishHealthRequests | validation | func (cs *clientServer) createPublishHealthRequests() ([]*ecstcs.PublishHealthRequest, error) {
metadata, taskHealthMetrics, err := cs.statsEngine.GetTaskHealthMetrics()
if err != nil {
return nil, err
}
if metadata == nil || taskHealthMetrics == nil {
seelog.Debug("No container health metrics to report")
re... | go | {
"resource": ""
} |
q168542 | copyMetricsMetadata | validation | func copyMetricsMetadata(metadata *ecstcs.MetricsMetadata, fin bool) *ecstcs.MetricsMetadata {
return &ecstcs.MetricsMetadata{
Cluster: aws.String(*metadata.Cluster),
ContainerInstance: aws.String(*metadata.ContainerInstance),
Idle: aws.Bool(*metadata.Idle),
MessageId: aws.String... | go | {
"resource": ""
} |
q168543 | copyTaskMetrics | validation | func copyTaskMetrics(from []*ecstcs.TaskMetric) []*ecstcs.TaskMetric {
to := make([]*ecstcs.TaskMetric, len(from))
copy(to, from)
return to
} | go | {
"resource": ""
} |
q168544 | copyHealthMetadata | validation | func copyHealthMetadata(metadata *ecstcs.HealthMetadata, fin bool) *ecstcs.HealthMetadata {
return &ecstcs.HealthMetadata{
Cluster: aws.String(aws.StringValue(metadata.Cluster)),
ContainerInstance: aws.String(aws.StringValue(metadata.ContainerInstance)),
Fin: aws.Bool(fin),
MessageId: ... | go | {
"resource": ""
} |
q168545 | copyTaskHealthMetrics | validation | func copyTaskHealthMetrics(from []*ecstcs.TaskHealth) []*ecstcs.TaskHealth {
to := make([]*ecstcs.TaskHealth, len(from))
copy(to, from)
return to
} | go | {
"resource": ""
} |
q168546 | UnmarshalJSON | validation | func (rm *ResourcesMap) UnmarshalJSON(data []byte) error {
resources := make(map[string]json.RawMessage)
err := json.Unmarshal(data, &resources)
if err != nil {
return err
}
result := make(map[string][]taskresource.TaskResource)
for key, value := range resources {
switch key {
case CgroupKey:
if unmarshl... | go | {
"resource": ""
} |
q168547 | NewVolumeResource | validation | func NewVolumeResource(ctx context.Context,
name string,
dockerVolumeName string,
scope string,
autoprovision bool,
driver string,
driverOptions map[string]string,
labels map[string]string,
client dockerapi.DockerClient) (*VolumeResource, error) {
if scope == TaskScope && autoprovision {
return nil, errors.... | go | {
"resource": ""
} |
q168548 | KnownCreated | validation | func (vol *VolumeResource) KnownCreated() bool {
vol.lock.RLock()
defer vol.lock.RUnlock()
return vol.knownStatusUnsafe == resourcestatus.ResourceStatus(VolumeCreated)
} | go | {
"resource": ""
} |
q168549 | setMountPoint | validation | func (vol *VolumeResource) setMountPoint(mountPoint string) {
vol.lock.Lock()
defer vol.lock.Unlock()
vol.VolumeConfig.Mountpoint = mountPoint
} | go | {
"resource": ""
} |
q168550 | GetMountPoint | validation | func (vol *VolumeResource) GetMountPoint() string {
vol.lock.RLock()
defer vol.lock.RUnlock()
return vol.VolumeConfig.Mountpoint
} | go | {
"resource": ""
} |
q168551 | Create | validation | func (vol *VolumeResource) Create() error {
seelog.Debugf("Creating volume with name %s using driver %s", vol.VolumeConfig.DockerVolumeName, vol.VolumeConfig.Driver)
volumeResponse := vol.client.CreateVolume(
vol.ctx,
vol.VolumeConfig.DockerVolumeName,
vol.VolumeConfig.Driver,
vol.VolumeConfig.DriverOpts,
v... | go | {
"resource": ""
} |
q168552 | Cleanup | validation | func (vol *VolumeResource) Cleanup() error {
// Enable volume clean up if it's task scoped
if vol.VolumeConfig.Scope != TaskScope {
seelog.Debugf("Volume [%s] is shared, not removing", vol.Name)
return nil
}
seelog.Debugf("Removing volume with name %s", vol.Name)
err := vol.client.RemoveVolume(vol.ctx, vol.Vo... | go | {
"resource": ""
} |
q168553 | MarshalJSON | validation | func (vol *VolumeResource) MarshalJSON() ([]byte, error) {
if vol == nil {
return nil, nil
}
return json.Marshal(volumeResourceJSON{
vol.Name,
vol.VolumeConfig,
vol.GetCreatedAt(),
func() *VolumeStatus { desiredState := VolumeStatus(vol.GetDesiredStatus()); return &desiredState }(),
func() *VolumeStatus ... | go | {
"resource": ""
} |
q168554 | UnmarshalJSON | validation | func (vol *VolumeResource) UnmarshalJSON(b []byte) error {
temp := &volumeResourceJSON{}
if err := json.Unmarshal(b, &temp); err != nil {
return err
}
vol.Name = temp.Name
vol.VolumeConfig = temp.VolumeConfig
if temp.DesiredStatus != nil {
vol.SetDesiredStatus(resourcestatus.ResourceStatus(*temp.DesiredStat... | go | {
"resource": ""
} |
q168555 | NewMockClientCreator | validation | func NewMockClientCreator(ctrl *gomock.Controller) *MockClientCreator {
mock := &MockClientCreator{ctrl: ctrl}
mock.recorder = &MockClientCreatorMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168556 | NewASMClient | validation | func (m *MockClientCreator) NewASMClient(arg0 string, arg1 credentials.IAMRoleCredentials) secretsmanageriface.SecretsManagerAPI {
ret := m.ctrl.Call(m, "NewASMClient", arg0, arg1)
ret0, _ := ret[0].(secretsmanageriface.SecretsManagerAPI)
return ret0
} | go | {
"resource": ""
} |
q168557 | NewASMClient | validation | func (mr *MockClientCreatorMockRecorder) NewASMClient(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewASMClient", reflect.TypeOf((*MockClientCreator)(nil).NewASMClient), arg0, arg1)
} | go | {
"resource": ""
} |
q168558 | NewTransportProtocol | validation | func NewTransportProtocol(protocol string) (TransportProtocol, error) {
switch protocol {
case tcp:
return TransportProtocolTCP, nil
case udp:
return TransportProtocolUDP, nil
default:
return TransportProtocolTCP, errors.New(protocol + " is not a recognized transport protocol")
}
} | go | {
"resource": ""
} |
q168559 | String | validation | func (tp *TransportProtocol) String() string {
if tp == nil {
return tcp
}
switch *tp {
case TransportProtocolUDP:
return udp
case TransportProtocolTCP:
return tcp
default:
seelog.Critical("Unknown TransportProtocol type!")
return tcp
}
} | go | {
"resource": ""
} |
q168560 | UnmarshalJSON | validation | func (tp *TransportProtocol) UnmarshalJSON(b []byte) error {
if strings.ToLower(string(b)) == "null" {
*tp = TransportProtocolTCP
seelog.Warn("Unmarshalled nil TransportProtocol as TCP")
return nil
}
switch string(b) {
case `"tcp"`:
*tp = TransportProtocolTCP
case `"udp"`:
*tp = TransportProtocolUDP
def... | go | {
"resource": ""
} |
q168561 | MarshalJSON | validation | func (tp *TransportProtocol) MarshalJSON() ([]byte, error) {
if tp == nil {
return []byte("null"), nil
}
return []byte(`"` + tp.String() + `"`), nil
} | go | {
"resource": ""
} |
q168562 | NewMockManager | validation | func NewMockManager(ctrl *gomock.Controller) *MockManager {
mock := &MockManager{ctrl: ctrl}
mock.recorder = &MockManagerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168563 | GetTaskCredentials | validation | func (m *MockManager) GetTaskCredentials(arg0 string) (credentials.TaskIAMRoleCredentials, bool) {
ret := m.ctrl.Call(m, "GetTaskCredentials", arg0)
ret0, _ := ret[0].(credentials.TaskIAMRoleCredentials)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q168564 | RemoveCredentials | validation | func (m *MockManager) RemoveCredentials(arg0 string) {
m.ctrl.Call(m, "RemoveCredentials", arg0)
} | go | {
"resource": ""
} |
q168565 | SetTaskCredentials | validation | func (m *MockManager) SetTaskCredentials(arg0 *credentials.TaskIAMRoleCredentials) error {
ret := m.ctrl.Call(m, "SetTaskCredentials", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q168566 | GetDockerAuthFromASM | validation | func GetDockerAuthFromASM(secretID string, client secretsmanageriface.SecretsManagerAPI) (types.AuthConfig, error) {
in := &secretsmanager.GetSecretValueInput{
SecretId: aws.String(secretID),
}
out, err := client.GetSecretValue(in)
if err != nil {
return types.AuthConfig{}, errors.Wrapf(err,
"asm fetching s... | go | {
"resource": ""
} |
q168567 | GetSecretFromASM | validation | func GetSecretFromASM(secretID string, client secretsmanageriface.SecretsManagerAPI) (string, error) {
in := &secretsmanager.GetSecretValueInput{
SecretId: aws.String(secretID),
}
out, err := client.GetSecretValue(in)
if err != nil {
return "", errors.Wrapf(err, "secret %s", secretID)
}
return aws.StringVal... | go | {
"resource": ""
} |
q168568 | NewMockCgroupFactory | validation | func NewMockCgroupFactory(ctrl *gomock.Controller) *MockCgroupFactory {
mock := &MockCgroupFactory{ctrl: ctrl}
mock.recorder = &MockCgroupFactoryMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168569 | Load | validation | func (m *MockCgroupFactory) Load(arg0 cgroups.Hierarchy, arg1 cgroups.Path) (cgroups.Cgroup, error) {
ret := m.ctrl.Call(m, "Load", arg0, arg1)
ret0, _ := ret[0].(cgroups.Cgroup)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168570 | Load | validation | func (mr *MockCgroupFactoryMockRecorder) Load(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockCgroupFactory)(nil).Load), arg0, arg1)
} | go | {
"resource": ""
} |
q168571 | LoadImage | validation | func (*loader) LoadImage(ctx context.Context, cfg *config.Config, dockerClient dockerapi.DockerClient) (*types.ImageInspect, error) {
log.Debugf("Loading pause container tarball: %s", cfg.PauseContainerTarballPath)
if err := loadFromFile(ctx, cfg.PauseContainerTarballPath, dockerClient, os.Default); err != nil {
re... | go | {
"resource": ""
} |
q168572 | NewCgroupResource | validation | func NewCgroupResource(taskARN string,
control control.Control,
ioutil ioutilwrapper.IOUtil,
cgroupRoot string,
cgroupMountPath string,
resourceSpec specs.LinuxResources) *CgroupResource {
c := &CgroupResource{
taskARN: taskARN,
control: control,
ioutil: ioutil,
cgroupRoot: c... | go | {
"resource": ""
} |
q168573 | Create | validation | func (cgroup *CgroupResource) Create() error {
err := cgroup.setupTaskCgroup()
if err != nil {
seelog.Criticalf("Cgroup resource [%s]: unable to setup cgroup root: %v", cgroup.taskARN, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q168574 | Cleanup | validation | func (cgroup *CgroupResource) Cleanup() error {
err := cgroup.control.Remove(cgroup.cgroupRoot)
// Explicitly handle cgroup deleted error
if err != nil {
if err == cgroups.ErrCgroupDeleted {
seelog.Warnf("Cgroup at %s has already been removed: %v", cgroup.cgroupRoot, err)
return nil
}
return errors.Wrapf... | go | {
"resource": ""
} |
q168575 | MarshalJSON | validation | func (cgroup *CgroupResource) MarshalJSON() ([]byte, error) {
if cgroup == nil {
return nil, errors.New("cgroup resource is nil")
}
return json.Marshal(cgroupResourceJSON{
cgroup.cgroupRoot,
cgroup.cgroupMountPath,
cgroup.GetCreatedAt(),
func() *CgroupStatus {
desiredState := cgroup.GetDesiredStatus()
... | go | {
"resource": ""
} |
q168576 | UnmarshalJSON | validation | func (cgroup *CgroupResource) UnmarshalJSON(b []byte) error {
temp := cgroupResourceJSON{}
if err := json.Unmarshal(b, &temp); err != nil {
return err
}
cgroup.cgroupRoot = temp.CgroupRoot
cgroup.cgroupMountPath = temp.CgroupMountPath
cgroup.resourceSpec = temp.LinuxSpec
if temp.DesiredStatus != nil {
cgro... | go | {
"resource": ""
} |
q168577 | GetCgroupRoot | validation | func (cgroup *CgroupResource) GetCgroupRoot() string {
cgroup.lock.RLock()
defer cgroup.lock.RUnlock()
return cgroup.cgroupRoot
} | go | {
"resource": ""
} |
q168578 | GetCgroupMountPath | validation | func (cgroup *CgroupResource) GetCgroupMountPath() string {
cgroup.lock.RLock()
defer cgroup.lock.RUnlock()
return cgroup.cgroupMountPath
} | go | {
"resource": ""
} |
q168579 | Initialize | validation | func (cgroup *CgroupResource) Initialize(resourceFields *taskresource.ResourceFields,
taskKnownStatus status.TaskStatus,
taskDesiredStatus status.TaskStatus) {
cgroup.lock.Lock()
defer cgroup.lock.Unlock()
cgroup.initializeResourceStatusToTransitionFunction()
cgroup.ioutil = resourceFields.IOUtil
cgroup.control... | go | {
"resource": ""
} |
q168580 | LoadImage | validation | func (*loader) LoadImage(ctx context.Context, cfg *config.Config, dockerClient dockerapi.DockerClient) (*types.ImageInspect, error) {
return nil, NewUnsupportedPlatformError(errors.Errorf(
"pause container load: unsupported platform: %s/%s",
runtime.GOOS, runtime.GOARCH))
} | go | {
"resource": ""
} |
q168581 | NewECRFactory | validation | func NewECRFactory(acceptInsecureCert bool) ECRFactory {
return &ecrFactory{
httpClient: httpclient.New(roundtripTimeout, acceptInsecureCert),
}
} | go | {
"resource": ""
} |
q168582 | GetClient | validation | func (factory *ecrFactory) GetClient(authData *apicontainer.ECRAuthData) (ECRClient, error) {
clientConfig, err := getClientConfig(factory.httpClient, authData)
if err != nil {
return &ecrClient{}, err
}
return factory.newClient(clientConfig), nil
} | go | {
"resource": ""
} |
q168583 | getClientConfig | validation | func getClientConfig(httpClient *http.Client, authData *apicontainer.ECRAuthData) (*aws.Config, error) {
cfg := aws.NewConfig().WithRegion(authData.Region).WithHTTPClient(httpClient)
if authData.EndpointOverride != "" {
cfg.Endpoint = aws.String(authData.EndpointOverride)
}
if authData.UseExecutionRole {
if au... | go | {
"resource": ""
} |
q168584 | NewMockAuditLogger | validation | func NewMockAuditLogger(ctrl *gomock.Controller) *MockAuditLogger {
mock := &MockAuditLogger{ctrl: ctrl}
mock.recorder = &MockAuditLoggerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168585 | GetContainerInstanceArn | validation | func (m *MockAuditLogger) GetContainerInstanceArn() string {
ret := m.ctrl.Call(m, "GetContainerInstanceArn")
ret0, _ := ret[0].(string)
return ret0
} | go | {
"resource": ""
} |
q168586 | GetContainerInstanceArn | validation | func (mr *MockAuditLoggerMockRecorder) GetContainerInstanceArn() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInstanceArn", reflect.TypeOf((*MockAuditLogger)(nil).GetContainerInstanceArn))
} | go | {
"resource": ""
} |
q168587 | Log | validation | func (m *MockAuditLogger) Log(arg0 request.LogRequest, arg1 int, arg2 string) {
m.ctrl.Call(m, "Log", arg0, arg1, arg2)
} | go | {
"resource": ""
} |
q168588 | Log | validation | func (mr *MockAuditLoggerMockRecorder) Log(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockAuditLogger)(nil).Log), arg0, arg1, arg2)
} | go | {
"resource": ""
} |
q168589 | NewMockInfoLogger | validation | func NewMockInfoLogger(ctrl *gomock.Controller) *MockInfoLogger {
mock := &MockInfoLogger{ctrl: ctrl}
mock.recorder = &MockInfoLoggerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168590 | Info | validation | func (m *MockInfoLogger) Info(arg0 ...interface{}) {
varargs := []interface{}{}
for _, a := range arg0 {
varargs = append(varargs, a)
}
m.ctrl.Call(m, "Info", varargs...)
} | go | {
"resource": ""
} |
q168591 | Info | validation | func (mr *MockInfoLoggerMockRecorder) Info(arg0 ...interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockInfoLogger)(nil).Info), arg0...)
} | go | {
"resource": ""
} |
q168592 | taskShouldBeSent | validation | func (event *sendableEvent) taskShouldBeSent() bool {
event.lock.RLock()
defer event.lock.RUnlock()
if event.isContainerEvent {
return false
}
tevent := event.taskChange
if event.taskSent {
return false // redundant event
}
// task and container change event should have task != nil
if tevent.Task == nil ... | go | {
"resource": ""
} |
q168593 | send | validation | func (event *sendableEvent) send(
sendStatusToECS sendStatusChangeToECS,
setChangeSent setStatusSent,
eventType string,
client api.ECSClient,
eventToSubmit *list.Element,
stateSaver statemanager.Saver,
backoff retry.Backoff,
taskEvents *taskSendableEvents) error {
seelog.Infof("TaskHandler: Sending %s change:... | go | {
"resource": ""
} |
q168594 | sendContainerStatusToECS | validation | func sendContainerStatusToECS(client api.ECSClient, event *sendableEvent) error {
return client.SubmitContainerStateChange(event.containerChange)
} | go | {
"resource": ""
} |
q168595 | sendTaskStatusToECS | validation | func sendTaskStatusToECS(client api.ECSClient, event *sendableEvent) error {
return client.SubmitTaskStateChange(event.taskChange)
} | go | {
"resource": ""
} |
q168596 | setContainerChangeSent | validation | func setContainerChangeSent(event *sendableEvent) {
containerChangeStatus := event.containerChange.Status
container := event.containerChange.Container
if container != nil && container.GetSentStatus() < containerChangeStatus {
container.SetSentStatus(containerChangeStatus)
}
} | go | {
"resource": ""
} |
q168597 | setTaskChangeSent | validation | func setTaskChangeSent(event *sendableEvent) {
taskChangeStatus := event.taskChange.Status
task := event.taskChange.Task
if task != nil && task.GetSentStatus() < taskChangeStatus {
task.SetSentStatus(taskChangeStatus)
}
for _, containerStateChange := range event.taskChange.Containers {
container := containerSt... | go | {
"resource": ""
} |
q168598 | setTaskAttachmentSent | validation | func setTaskAttachmentSent(event *sendableEvent) {
if event.taskChange.Attachment != nil {
event.taskChange.Attachment.SetSentStatus()
event.taskChange.Attachment.StopAckTimer()
}
} | go | {
"resource": ""
} |
q168599 | GetSecretsFromSSM | validation | func GetSecretsFromSSM(names []string, client SSMClient) (map[string]string, error) {
var secretNames []*string
for _, name := range names {
secretNames = append(secretNames, aws.String(name))
}
in := &ssm.GetParametersInput{
Names: secretNames,
WithDecryption: aws.Bool(true),
}
out, err := clien... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.