id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c169200 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameters", reflect.TypeOf((*MockSSMClient)(nil).GetParameters), arg0)
} | |
c169201 | mock.recorder = &MockFactoryMockRecorder{mock}
return mock
} | |
c169202 | {
ret := m.ctrl.Call(m, "FindClientAPIVersion", arg0)
ret0, _ := ret[0].(dockerclient.DockerVersion)
return ret0
} | |
c169203 |
ret := m.ctrl.Call(m, "FindKnownAPIVersions")
ret0, _ := ret[0].([]dockerclient.DockerVersion)
return ret0
} | |
c169204 | := ret[0].(sdkclient.Client)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169205 | mock.recorder = &MockFileSystemMockRecorder{mock}
return mock
} | |
c169206 | _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169207 | int) {
m.ctrl.Call(m, "Exit", arg0)
} | |
c169208 | error {
ret := m.ctrl.Call(m, "MkdirAll", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | |
c169209 | m.ctrl.Call(m, "Open", arg0)
ret0, _ := ret[0].(io.ReadWriteCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169210 | m.ctrl.Call(m, "ReadAll", arg0)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169211 | string) {
m.ctrl.Call(m, "Remove", arg0)
} | |
c169212 | "Rename", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | |
c169213 | {
ret := m.ctrl.Call(m, "TeeReader", arg0, arg1)
ret0, _ := ret[0].(io.Reader)
return ret0
} | |
c169214 | from the 'disk'
if _, err := agent.pauseLoader.LoadImage(agent.ctx, agent.cfg, agent.dockerClient); err != nil {
if pause.IsNoSuchFileError(err) || pause.UnsupportedPlatform(err) {
// If the pause container's image tarball doesn't exist or if the
// invocation is done for an unsupported platform, we cannot recover.
// Return the error as terminal for these cases
return err, true
}
return err, false
}
if err := agent.startUdevWatcher(state, taskEngine.StateChangeEvents()); err != nil {
// If udev watcher was not initialized in this run because of the udev socket
// file not being available etc, the Agent might be able to retry and succeed
// on the next run. Hence, returning a false here for terminal bool
return err, false
}
return nil, false
} | |
c169215 |
subnetID, err := agent.ec2MetadataClient.SubnetID(mac)
if err != nil {
return fmt.Errorf("unable to get subnet id from instance metadata: %v", err), false
}
agent.vpc = vpcID
agent.subnet = subnetID
agent.mac = mac
return nil, false
} | |
c169216 | eniWatcher := watcher.New(agent.ctx, agent.mac, udevMonitor, state, stateChangeEvents)
if err := eniWatcher.Init(); err != nil {
return errors.Wrapf(err, "unable to initialize eni watcher")
}
go eniWatcher.Start()
return nil
} | |
c169217 | }
}()
gm.lock.Lock()
defer gm.lock.Unlock()
gm.counterVec.WithLabelValues(callName).Inc()
} | |
c169218 | ctrl}
mock.recorder = &MockTaskEngineStateMockRecorder{mock}
return mock
} | |
c169219 | m.ctrl.Call(m, "AddContainer", arg0, arg1)
} | |
c169220 | *eni.ENIAttachment) {
m.ctrl.Call(m, "AddENIAttachment", arg0)
} | |
c169221 | *image.ImageState) {
m.ctrl.Call(m, "AddImageState", arg0)
} | |
c169222 | m.ctrl.Call(m, "AddTaskIPAddress", arg0, arg1)
} | |
c169223 | {
ret := m.ctrl.Call(m, "AllImageStates")
ret0, _ := ret[0].([]*image.ImageState)
return ret0
} | |
c169224 | "AllImageStates", reflect.TypeOf((*MockTaskEngineState)(nil).AllImageStates))
} | |
c169225 |
ret := m.ctrl.Call(m, "AllTasks")
ret0, _ := ret[0].([]*task.Task)
return ret0
} | |
c169226 | := ret[0].(*container.DockerContainer)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c169227 | := m.ctrl.Call(m, "ENIByMac", arg0)
ret0, _ := ret[0].(*eni.ENIAttachment)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c169228 | "GetAllContainerIDs")
ret0, _ := ret[0].([]string)
return ret0
} | |
c169229 | string) {
m.ctrl.Call(m, "RemoveENIAttachment", arg0)
} | |
c169230 | *image.ImageState) {
m.ctrl.Call(m, "RemoveImageState", arg0)
} | |
c169231 | *task.Task) {
m.ctrl.Call(m, "RemoveTask", arg0)
} | |
c169232 | "RemoveTask", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveTask), arg0)
} | |
c169233 | := m.ctrl.Call(m, "TaskARNByV3EndpointID", arg0)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c169234 | := m.ctrl.Call(m, "TaskByArn", arg0)
ret0, _ := ret[0].(*task.Task)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | |
c169235 | m.ctrl.Call(m, "UnmarshalJSON", arg0)
ret0, _ := ret[0].(error)
return ret0
} | |
c169236 | containerType {
return str
}
}
return "NORMAL"
} | |
c169237 | != '"' || b[len(b)-1] != '"' {
*containerType = ContainerNormal
return errors.New("invalid value set for ContainerType, must be a string or null; got " + string(b))
}
strType = string(b[1 : len(b)-1])
contType, ok := stringToContainerType[strType]
if !ok {
*containerType = ContainerNormal
return errors.New("unrecognized ContainerType: " + strType)
}
*containerType = contType
return nil
} | |
c169238 | }
return []byte(`"` + containerType.String() + `"`), nil
} | |
c169239 | := time.Parse(time.RFC3339Nano, value)
return ts
} | |
c169240 | ctrl}
mock.recorder = &MockResponseWriterMockRecorder{mock}
return mock
} | |
c169241 |
ret0, _ := ret[0].(http.Header)
return ret0
} | |
c169242 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockResponseWriter)(nil).Header))
} | |
c169243 | int) {
m.ctrl.Call(m, "WriteHeader", arg0)
} | |
c169244 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteHeader", reflect.TypeOf((*MockResponseWriter)(nil).WriteHeader), arg0)
} | |
c169245 | -1
case lhs.major > rhs.major:
return 1
case lhs.minor < rhs.minor:
return -1
case lhs.minor > rhs.minor:
return 1
}
return 0
} | |
c169246 | HTTP request failed: %v", err)
return errors.Wrap(err, "aws sdk http signer: failed to sign http request")
}
return nil
} | |
c169247 | (sdkclient.Client, error) {
return f.getClient(version)
} | |
c169248 | dockerclient.Version_1_22,
dockerclient.Version_1_23,
dockerclient.Version_1_24,
dockerclient.Version_1_25,
dockerclient.Version_1_26,
dockerclient.Version_1_27,
dockerclient.Version_1_28,
dockerclient.Version_1_29,
dockerclient.Version_1_30,
dockerclient.Version_1_31,
dockerclient.Version_1_32,
}
} | |
c169249 | task arn: [%s] and cpu shares: %d",
task.Arn, containerCPU)
return 2
}
return int64(containerCPU)
} | |
c169250 | json.Unmarshal(tasksMetadataMap["Tasks"], &tasksMetadataArray)
if len(tasksMetadataArray) != 1 {
return fmt.Errorf("incorrect number of tasks, expected 1, received %d",
len(tasksMetadataArray))
}
return verifyTaskMetadata(tasksMetadataArray[0])
} | |
c169251 | return notEmptyErrMsg("Containers")
}
var containersMetadataArray []json.RawMessage
json.Unmarshal(taskMetadataMap["Containers"], &containersMetadataArray)
if len(containersMetadataArray) != 1 {
return fmt.Errorf("incorrect number of containers, expected 1, received %d",
len(containersMetadataArray))
}
return verifyContainerMetadata(containersMetadataArray[0])
} | |
c169252 |
containerName, actualContainerName)
}
if containerMetadataMap["DockerId"] == nil {
return notEmptyErrMsg("DockerId")
}
if containerMetadataMap["DockerName"] == nil {
return notEmptyErrMsg("DockerName")
}
if containerMetadataMap["Volumes"] == nil {
return notEmptyErrMsg("Volumes")
}
return nil
} | |
c169253 | mock.recorder = &MockResultMockRecorder{mock}
return mock
} | |
c169254 | m.ctrl.Call(m, "GetAsVersion", arg0)
ret0, _ := ret[0].(types.Result)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169255 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAsVersion", reflect.TypeOf((*MockResult)(nil).GetAsVersion), arg0)
} | |
c169256 | _ := ret[0].(error)
return ret0
} | |
c169257 | "Print", reflect.TypeOf((*MockResult)(nil).Print))
} | |
c169258 | arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(container.ContainerCreateCreatedBody)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169259 | ret0, _ := ret[0].(types.ContainerJSON)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169260 |
ret0, _ := ret[0].([]types.Container)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169261 | := m.ctrl.Call(m, "ContainerRemove", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | |
c169262 | := m.ctrl.Call(m, "ContainerStart", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | |
c169263 | arg2)
ret0, _ := ret[0].(types.ContainerStats)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169264 | error {
ret := m.ctrl.Call(m, "ContainerStop", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | |
c169265 |
ret0, _ := ret[0].(<-chan events.Message)
ret1, _ := ret[1].(<-chan error)
return ret0, ret1
} | |
c169266 | arg1, arg2, arg3)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169267 | ret[0].(types.ImageInspect)
ret1, _ := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | |
c169268 |
ret0, _ := ret[0].([]types.ImageSummary)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169269 | arg2)
ret0, _ := ret[0].(types.ImageLoadResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169270 | arg2)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169271 | arg2)
ret0, _ := ret[0].([]types.ImageDeleteResponseItem)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169272 | := m.ctrl.Call(m, "Ping", arg0)
ret0, _ := ret[0].(types.Ping)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169273 | ret0, _ := ret[0].(types.PluginsListResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169274 |
ret0, _ := ret[0].(types.Volume)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169275 | ret0, _ := ret[0].(types.Volume)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c169276 | error {
ret := m.ctrl.Call(m, "VolumeRemove", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | |
c169277 | := resolver.dockerTaskEngine.State().TaskByID(dockerID)
if !found {
return nil, fmt.Errorf("Could not map docker id to task: %s", dockerID)
}
return task, nil
} | |
c169278 | found := resolver.dockerTaskEngine.State().ContainerByID(dockerID)
if !found {
return nil, fmt.Errorf("Could not map docker id to container: %s", dockerID)
}
return container, nil
} | |
c169279 | if listContainersResponse.Error != nil {
return listContainersResponse.Error
}
for _, containerID := range listContainersResponse.DockerIDs {
engine.addAndStartStatsContainer(containerID)
}
return nil
} | |
c169280 | %v", containerID, err)
return
}
if engine.disableMetrics || statsContainer == nil {
return
}
statsContainer.StartStatsCollection()
} | |
c169281 | = engine.containerChangeEventStream.Subscribe(containerChangeHandler, engine.handleDockerEvents)
if err != nil {
return fmt.Errorf("Failed to subscribe to container change event stream, err %v", err)
}
err = engine.synchronizeState()
if err != nil {
seelog.Warnf("Synchronize the container state failed, err: %v", err)
}
go engine.waitToStop()
return nil
} | |
c169282 | select {
case <-ctx.Done():
seelog.Debug("Event stream closed, stop listening to the event stream")
engine.containerChangeEventStream.Unsubscribe(containerChangeHandler)
engine.removeAll()
}
} | |
c169283 | statsContainer := range containers {
statsContainer.StopStatsCollection()
}
delete(engine.tasksToContainers, task)
}
for task := range engine.tasksToHealthCheckContainers {
delete(engine.tasksToContainers, task)
}
} | |
c169284 | container to the map for collecting stats
watchStatsContainer = engine.addToStatsContainerMapUnsafe(task.Arn, dockerID, statsContainer, engine.containerMetricsMapUnsafe)
}
if dockerContainer, err := engine.resolver.ResolveContainer(dockerID); err != nil {
seelog.Debugf("Could not map container ID to container, container: %s, err: %s", dockerID, err)
} else if dockerContainer.Container.HealthStatusShouldBeReported() {
// Track the container health status
engine.addToStatsContainerMapUnsafe(task.Arn, dockerID, statsContainer, engine.healthCheckContainerMapUnsafe)
seelog.Debugf("Adding container to stats health check watch list, id: %s, task: %s", dockerID, task.Arn)
}
if !watchStatsContainer {
return nil, nil
}
return statsContainer, nil
} | |
c169285 | already being watched, ignoring, id: %s", containerID)
return false
}
} else {
// Create a map for the task arn if it doesn't exist yet.
taskToContainerMap[taskARN] = make(map[string]*StatsContainer)
}
taskToContainerMap[taskARN][containerID] = statsContainer
return true
} | |
c169286 | map task to definition, task: %s", taskArn)
continue
}
metricTaskArn := taskArn
taskMetric := &ecstcs.TaskMetric{
TaskArn: &metricTaskArn,
TaskDefinitionFamily: &taskDef.family,
TaskDefinitionVersion: &taskDef.version,
ContainerMetrics: containerMetrics,
}
taskMetrics = append(taskMetrics, taskMetric)
}
if len(taskMetrics) == 0 {
// Not idle. Expect taskMetrics to be there.
return nil, nil, EmptyMetricsError
}
// Reset current stats. Retaining older stats results in incorrect utilization stats
// until they are removed from the queue.
engine.resetStatsUnsafe()
return metricsMetadata, taskMetrics, nil
} | |
c169287 |
if !engine.containerHealthsToMonitor() {
return metadata, taskHealths, nil
}
engine.lock.RLock()
defer engine.lock.RUnlock()
for taskARN := range engine.tasksToHealthCheckContainers {
taskHealth := engine.getTaskHealthUnsafe(taskARN)
if taskHealth == nil {
continue
}
taskHealths = append(taskHealths, taskHealth)
}
if len(taskHealths) == 0 {
return nil, nil, EmptyHealthMetricsError
}
return metadata, taskHealths, nil
} | |
c169288 | err)
engine.doRemoveContainerUnsafe(container, taskARN)
return true
}
if terminal {
// Container is in known terminal state. Stop collection metrics.
seelog.Infof("Container %s is terminal, removing from stats", container.containerMetadata.DockerID)
engine.doRemoveContainerUnsafe(container, taskARN)
return true
}
return false
} | |
c169289 | case apicontainerstatus.ContainerStopped:
engine.removeContainer(dockerContainerChangeEvent.DockerID)
default:
seelog.Debugf("Ignoring event for container, id: %s, status: %d", dockerContainerChangeEvent.DockerID, dockerContainerChangeEvent.Status)
}
}
return nil
} | |
c169290 | in map.
container, containerExists := engine.tasksToContainers[task.Arn][dockerID]
if !containerExists {
// container arn does not exist in map.
seelog.Debugf("Container not being watched, id: %s", dockerID)
return
}
engine.doRemoveContainerUnsafe(container, task.Arn)
} | |
c169291 | not load docker task engine")
}
resolver := &DockerContainerMetadataResolver{
dockerTaskEngine: dockerTaskEngine,
}
return resolver, nil
} | |
c169292 |
seelog.Warnf("Error getting cpu stats, err: %v, container: %v", err, dockerID)
continue
}
// Get memory stats set.
memoryStatsSet, err := container.statsQueue.GetMemoryStatsSet()
if err != nil {
seelog.Warnf("Error getting memory stats, err: %v, container: %v", err, dockerID)
continue
}
containerMetrics = append(containerMetrics, &ecstcs.ContainerMetric{
CpuStatsSet: cpuStatsSet,
MemoryStatsSet: memoryStatsSet,
})
}
return containerMetrics, nil
} | |
c169293 | range containerMap {
container.statsQueue.Reset()
}
}
} | |
c169294 | taskARN, containerID)
}
container, ok := containerIDToStatsContainer[containerID]
if !ok {
return nil, errors.Errorf("stats engine: container not found: %s", containerID)
}
return container.statsQueue.GetLastStat(), nil
} | |
c169295 | cluster,
ContainerInstance: containerInstance,
}
} | |
c169296 | == "" && rhs.preReleaseVersion != "" {
return 1
}
if lhs.preReleaseVersion < rhs.preReleaseVersion {
return -1
}
if lhs.preReleaseVersion > rhs.preReleaseVersion {
return 1
}
return 0
} | |
c169297 |
if len(versionNumberStr) >= 2 {
return string(versionNumberStr[1])
}
return "UNKNOWN"
} | |
c169298 | defer role.lock.RUnlock()
return role.IAMRoleCredentials
} | |
c169299 | fmt.Sprintf(credentialsEndpointRelativeURIFormat, CredentialsPath, roleCredentials.CredentialsID)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.