_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q169200 | GetParameters | validation | func (mr *MockSSMClientMockRecorder) GetParameters(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameters", reflect.TypeOf((*MockSSMClient)(nil).GetParameters), arg0)
} | go | {
"resource": ""
} |
q169201 | NewMockFactory | validation | func NewMockFactory(ctrl *gomock.Controller) *MockFactory {
mock := &MockFactory{ctrl: ctrl}
mock.recorder = &MockFactoryMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169202 | FindClientAPIVersion | validation | func (m *MockFactory) FindClientAPIVersion(arg0 sdkclient.Client) dockerclient.DockerVersion {
ret := m.ctrl.Call(m, "FindClientAPIVersion", arg0)
ret0, _ := ret[0].(dockerclient.DockerVersion)
return ret0
} | go | {
"resource": ""
} |
q169203 | FindKnownAPIVersions | validation | func (m *MockFactory) FindKnownAPIVersions() []dockerclient.DockerVersion {
ret := m.ctrl.Call(m, "FindKnownAPIVersions")
ret0, _ := ret[0].([]dockerclient.DockerVersion)
return ret0
} | go | {
"resource": ""
} |
q169204 | GetDefaultClient | validation | func (m *MockFactory) GetDefaultClient() (sdkclient.Client, error) {
ret := m.ctrl.Call(m, "GetDefaultClient")
ret0, _ := ret[0].(sdkclient.Client)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169205 | NewMockFileSystem | validation | func NewMockFileSystem(ctrl *gomock.Controller) *MockFileSystem {
mock := &MockFileSystem{ctrl: ctrl}
mock.recorder = &MockFileSystemMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169206 | Copy | validation | func (m *MockFileSystem) Copy(arg0 io.Writer, arg1 io.Reader) (int64, error) {
ret := m.ctrl.Call(m, "Copy", arg0, arg1)
ret0, _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169207 | Exit | validation | func (m *MockFileSystem) Exit(arg0 int) {
m.ctrl.Call(m, "Exit", arg0)
} | go | {
"resource": ""
} |
q169208 | MkdirAll | validation | func (m *MockFileSystem) MkdirAll(arg0 string, arg1 os.FileMode) error {
ret := m.ctrl.Call(m, "MkdirAll", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169209 | Open | validation | func (m *MockFileSystem) Open(arg0 string) (io.ReadWriteCloser, error) {
ret := m.ctrl.Call(m, "Open", arg0)
ret0, _ := ret[0].(io.ReadWriteCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169210 | ReadAll | validation | func (m *MockFileSystem) ReadAll(arg0 io.Reader) ([]byte, error) {
ret := m.ctrl.Call(m, "ReadAll", arg0)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169211 | Remove | validation | func (m *MockFileSystem) Remove(arg0 string) {
m.ctrl.Call(m, "Remove", arg0)
} | go | {
"resource": ""
} |
q169212 | Rename | validation | func (m *MockFileSystem) Rename(arg0, arg1 string) error {
ret := m.ctrl.Call(m, "Rename", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169213 | TeeReader | validation | func (m *MockFileSystem) TeeReader(arg0 io.Reader, arg1 io.Writer) io.Reader {
ret := m.ctrl.Call(m, "TeeReader", arg0, arg1)
ret0, _ := ret[0].(io.Reader)
return ret0
} | go | {
"resource": ""
} |
q169214 | initializeTaskENIDependencies | validation | func (agent *ecsAgent) initializeTaskENIDependencies(state dockerstate.TaskEngineState, taskEngine engine.TaskEngine) (error, bool) {
// Check if the Agent process's pid == 1, which means it's running without an init system
if agent.os.Getpid() == initPID {
// This is a terminal error. Bad things happen with invok... | go | {
"resource": ""
} |
q169215 | setVPCSubnet | validation | func (agent *ecsAgent) setVPCSubnet() (error, bool) {
mac, err := agent.ec2MetadataClient.PrimaryENIMAC()
if err != nil {
return fmt.Errorf("unable to get mac address of instance's primary ENI from instance metadata: %v", err), false
}
vpcID, err := agent.ec2MetadataClient.VPCID(mac)
if err != nil {
if isInst... | go | {
"resource": ""
} |
q169216 | startUdevWatcher | validation | func (agent *ecsAgent) startUdevWatcher(state dockerstate.TaskEngineState, stateChangeEvents chan<- statechange.Event) error {
seelog.Debug("Setting up ENI Watcher")
udevMonitor, err := udevwrapper.New()
if err != nil {
return errors.Wrapf(err, "unable to create udev monitor")
}
// Create Watcher
eniWatcher := ... | go | {
"resource": ""
} |
q169217 | IncrementCallCount | validation | func (gm *GenericMetrics) IncrementCallCount(callName string) {
defer func() {
if r := recover(); r != nil {
seelog.Errorf("IncrementCallCount for %s panicked. Recovering quietly: %s", callName, r)
}
}()
gm.lock.Lock()
defer gm.lock.Unlock()
gm.counterVec.WithLabelValues(callName).Inc()
} | go | {
"resource": ""
} |
q169218 | NewMockTaskEngineState | validation | func NewMockTaskEngineState(ctrl *gomock.Controller) *MockTaskEngineState {
mock := &MockTaskEngineState{ctrl: ctrl}
mock.recorder = &MockTaskEngineStateMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169219 | AddContainer | validation | func (m *MockTaskEngineState) AddContainer(arg0 *container.DockerContainer, arg1 *task.Task) {
m.ctrl.Call(m, "AddContainer", arg0, arg1)
} | go | {
"resource": ""
} |
q169220 | AddENIAttachment | validation | func (m *MockTaskEngineState) AddENIAttachment(arg0 *eni.ENIAttachment) {
m.ctrl.Call(m, "AddENIAttachment", arg0)
} | go | {
"resource": ""
} |
q169221 | AddImageState | validation | func (m *MockTaskEngineState) AddImageState(arg0 *image.ImageState) {
m.ctrl.Call(m, "AddImageState", arg0)
} | go | {
"resource": ""
} |
q169222 | AddTaskIPAddress | validation | func (m *MockTaskEngineState) AddTaskIPAddress(arg0, arg1 string) {
m.ctrl.Call(m, "AddTaskIPAddress", arg0, arg1)
} | go | {
"resource": ""
} |
q169223 | AllImageStates | validation | func (m *MockTaskEngineState) AllImageStates() []*image.ImageState {
ret := m.ctrl.Call(m, "AllImageStates")
ret0, _ := ret[0].([]*image.ImageState)
return ret0
} | go | {
"resource": ""
} |
q169224 | AllImageStates | validation | func (mr *MockTaskEngineStateMockRecorder) AllImageStates() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllImageStates", reflect.TypeOf((*MockTaskEngineState)(nil).AllImageStates))
} | go | {
"resource": ""
} |
q169225 | AllTasks | validation | func (m *MockTaskEngineState) AllTasks() []*task.Task {
ret := m.ctrl.Call(m, "AllTasks")
ret0, _ := ret[0].([]*task.Task)
return ret0
} | go | {
"resource": ""
} |
q169226 | ContainerByID | validation | func (m *MockTaskEngineState) ContainerByID(arg0 string) (*container.DockerContainer, bool) {
ret := m.ctrl.Call(m, "ContainerByID", arg0)
ret0, _ := ret[0].(*container.DockerContainer)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q169227 | ENIByMac | validation | func (m *MockTaskEngineState) ENIByMac(arg0 string) (*eni.ENIAttachment, bool) {
ret := m.ctrl.Call(m, "ENIByMac", arg0)
ret0, _ := ret[0].(*eni.ENIAttachment)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q169228 | GetAllContainerIDs | validation | func (m *MockTaskEngineState) GetAllContainerIDs() []string {
ret := m.ctrl.Call(m, "GetAllContainerIDs")
ret0, _ := ret[0].([]string)
return ret0
} | go | {
"resource": ""
} |
q169229 | RemoveENIAttachment | validation | func (m *MockTaskEngineState) RemoveENIAttachment(arg0 string) {
m.ctrl.Call(m, "RemoveENIAttachment", arg0)
} | go | {
"resource": ""
} |
q169230 | RemoveImageState | validation | func (m *MockTaskEngineState) RemoveImageState(arg0 *image.ImageState) {
m.ctrl.Call(m, "RemoveImageState", arg0)
} | go | {
"resource": ""
} |
q169231 | RemoveTask | validation | func (m *MockTaskEngineState) RemoveTask(arg0 *task.Task) {
m.ctrl.Call(m, "RemoveTask", arg0)
} | go | {
"resource": ""
} |
q169232 | RemoveTask | validation | func (mr *MockTaskEngineStateMockRecorder) RemoveTask(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTask", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveTask), arg0)
} | go | {
"resource": ""
} |
q169233 | TaskARNByV3EndpointID | validation | func (m *MockTaskEngineState) TaskARNByV3EndpointID(arg0 string) (string, bool) {
ret := m.ctrl.Call(m, "TaskARNByV3EndpointID", arg0)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q169234 | TaskByArn | validation | func (m *MockTaskEngineState) TaskByArn(arg0 string) (*task.Task, bool) {
ret := m.ctrl.Call(m, "TaskByArn", arg0)
ret0, _ := ret[0].(*task.Task)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q169235 | UnmarshalJSON | validation | func (m *MockTaskEngineState) UnmarshalJSON(arg0 []byte) error {
ret := m.ctrl.Call(m, "UnmarshalJSON", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169236 | String | validation | func (containerType ContainerType) String() string {
for str, contType := range stringToContainerType {
if contType == containerType {
return str
}
}
return "NORMAL"
} | go | {
"resource": ""
} |
q169237 | UnmarshalJSON | validation | func (containerType *ContainerType) UnmarshalJSON(b []byte) error {
strType := string(b)
switch strType {
case "null":
*containerType = ContainerNormal
seelog.Warn("Unmarshalled nil ContainerType as Normal")
return nil
// 'true' or 'false' for compatibility with state version <= 5
case "true":
*containerT... | go | {
"resource": ""
} |
q169238 | MarshalJSON | validation | func (containerType *ContainerType) MarshalJSON() ([]byte, error) {
if containerType == nil {
return []byte("null"), nil
}
return []byte(`"` + containerType.String() + `"`), nil
} | go | {
"resource": ""
} |
q169239 | parseNanoTime | validation | func parseNanoTime(value string) time.Time {
ts, _ := time.Parse(time.RFC3339Nano, value)
return ts
} | go | {
"resource": ""
} |
q169240 | NewMockResponseWriter | validation | func NewMockResponseWriter(ctrl *gomock.Controller) *MockResponseWriter {
mock := &MockResponseWriter{ctrl: ctrl}
mock.recorder = &MockResponseWriterMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169241 | Header | validation | func (m *MockResponseWriter) Header() http.Header {
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(http.Header)
return ret0
} | go | {
"resource": ""
} |
q169242 | Header | validation | func (mr *MockResponseWriterMockRecorder) Header() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockResponseWriter)(nil).Header))
} | go | {
"resource": ""
} |
q169243 | WriteHeader | validation | func (m *MockResponseWriter) WriteHeader(arg0 int) {
m.ctrl.Call(m, "WriteHeader", arg0)
} | go | {
"resource": ""
} |
q169244 | WriteHeader | validation | func (mr *MockResponseWriterMockRecorder) WriteHeader(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteHeader", reflect.TypeOf((*MockResponseWriter)(nil).WriteHeader), arg0)
} | go | {
"resource": ""
} |
q169245 | compareDockerVersions | validation | func compareDockerVersions(lhs, rhs dockerVersion) int {
switch {
case lhs.major < rhs.major:
return -1
case lhs.major > rhs.major:
return 1
case lhs.minor < rhs.minor:
return -1
case lhs.minor > rhs.minor:
return 1
}
return 0
} | go | {
"resource": ""
} |
q169246 | SignHTTPRequest | validation | func SignHTTPRequest(req *http.Request, region, service string, creds *credentials.Credentials, body io.ReadSeeker) error {
signer := v4.NewSigner(creds)
_, err := signer.Sign(req, body, service, region, time.Now())
if err != nil {
seelog.Warnf("Signing HTTP request failed: %v", err)
return errors.Wrap(err, "aws... | go | {
"resource": ""
} |
q169247 | GetClient | validation | func (f *factory) GetClient(version dockerclient.DockerVersion) (sdkclient.Client, error) {
return f.getClient(version)
} | go | {
"resource": ""
} |
q169248 | getAgentVersions | validation | func getAgentVersions() []dockerclient.DockerVersion {
return []dockerclient.DockerVersion{
dockerclient.Version_1_17,
dockerclient.Version_1_18,
dockerclient.Version_1_19,
dockerclient.Version_1_20,
dockerclient.Version_1_21,
dockerclient.Version_1_22,
dockerclient.Version_1_23,
dockerclient.Version_1... | go | {
"resource": ""
} |
q169249 | dockerCPUShares | validation | func (task *Task) dockerCPUShares(containerCPU uint) int64 {
if containerCPU <= 1 {
seelog.Debugf(
"Converting CPU shares to allowed minimum of 2 for task arn: [%s] and cpu shares: %d",
task.Arn, containerCPU)
return 2
}
return int64(containerCPU)
} | go | {
"resource": ""
} |
q169250 | verifyTasksMetadata | validation | func verifyTasksMetadata(tasksMetadataRawMsg json.RawMessage) error {
var tasksMetadataMap map[string]json.RawMessage
json.Unmarshal(tasksMetadataRawMsg, &tasksMetadataMap)
if tasksMetadataMap["Tasks"] == nil {
return notEmptyErrMsg("Tasks")
}
var tasksMetadataArray []json.RawMessage
json.Unmarshal(tasksMetad... | go | {
"resource": ""
} |
q169251 | verifyTaskMetadata | validation | func verifyTaskMetadata(taskMetadataRawMsg json.RawMessage) error {
taskMetadataMap := make(map[string]json.RawMessage)
json.Unmarshal(taskMetadataRawMsg, &taskMetadataMap)
if taskMetadataMap["Arn"] == nil {
return notEmptyErrMsg("Arn")
}
if taskMetadataMap["DesiredStatus"] == nil {
return notEmptyErrMsg("De... | go | {
"resource": ""
} |
q169252 | verifyContainerMetadata | validation | func verifyContainerMetadata(containerMetadataRawMsg json.RawMessage) error {
containerMetadataMap := make(map[string]json.RawMessage)
json.Unmarshal(containerMetadataRawMsg, &containerMetadataMap)
if containerMetadataMap["Name"] == nil {
return notEmptyErrMsg("Name")
}
var actualContainerName string
json.Unm... | go | {
"resource": ""
} |
q169253 | NewMockResult | validation | func NewMockResult(ctrl *gomock.Controller) *MockResult {
mock := &MockResult{ctrl: ctrl}
mock.recorder = &MockResultMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169254 | GetAsVersion | validation | func (m *MockResult) GetAsVersion(arg0 string) (types.Result, error) {
ret := m.ctrl.Call(m, "GetAsVersion", arg0)
ret0, _ := ret[0].(types.Result)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169255 | GetAsVersion | validation | func (mr *MockResultMockRecorder) GetAsVersion(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAsVersion", reflect.TypeOf((*MockResult)(nil).GetAsVersion), arg0)
} | go | {
"resource": ""
} |
q169256 | Print | validation | func (m *MockResult) Print() error {
ret := m.ctrl.Call(m, "Print")
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169257 | Print | validation | func (mr *MockResultMockRecorder) Print() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Print", reflect.TypeOf((*MockResult)(nil).Print))
} | go | {
"resource": ""
} |
q169258 | ContainerCreate | validation | func (m *MockClient) ContainerCreate(arg0 context.Context, arg1 *container.Config, arg2 *container.HostConfig, arg3 *network.NetworkingConfig, arg4 string) (container.ContainerCreateCreatedBody, error) {
ret := m.ctrl.Call(m, "ContainerCreate", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(container.ContainerCreat... | go | {
"resource": ""
} |
q169259 | ContainerInspect | validation | func (m *MockClient) ContainerInspect(arg0 context.Context, arg1 string) (types.ContainerJSON, error) {
ret := m.ctrl.Call(m, "ContainerInspect", arg0, arg1)
ret0, _ := ret[0].(types.ContainerJSON)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169260 | ContainerList | validation | func (m *MockClient) ContainerList(arg0 context.Context, arg1 types.ContainerListOptions) ([]types.Container, error) {
ret := m.ctrl.Call(m, "ContainerList", arg0, arg1)
ret0, _ := ret[0].([]types.Container)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169261 | ContainerRemove | validation | func (m *MockClient) ContainerRemove(arg0 context.Context, arg1 string, arg2 types.ContainerRemoveOptions) error {
ret := m.ctrl.Call(m, "ContainerRemove", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169262 | ContainerStart | validation | func (m *MockClient) ContainerStart(arg0 context.Context, arg1 string, arg2 types.ContainerStartOptions) error {
ret := m.ctrl.Call(m, "ContainerStart", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169263 | ContainerStats | validation | func (m *MockClient) ContainerStats(arg0 context.Context, arg1 string, arg2 bool) (types.ContainerStats, error) {
ret := m.ctrl.Call(m, "ContainerStats", arg0, arg1, arg2)
ret0, _ := ret[0].(types.ContainerStats)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169264 | ContainerStop | validation | func (m *MockClient) ContainerStop(arg0 context.Context, arg1 string, arg2 *time.Duration) error {
ret := m.ctrl.Call(m, "ContainerStop", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169265 | Events | validation | func (m *MockClient) Events(arg0 context.Context, arg1 types.EventsOptions) (<-chan events.Message, <-chan error) {
ret := m.ctrl.Call(m, "Events", arg0, arg1)
ret0, _ := ret[0].(<-chan events.Message)
ret1, _ := ret[1].(<-chan error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169266 | ImageImport | validation | func (m *MockClient) ImageImport(arg0 context.Context, arg1 types.ImageImportSource, arg2 string, arg3 types.ImageImportOptions) (io.ReadCloser, error) {
ret := m.ctrl.Call(m, "ImageImport", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169267 | ImageInspectWithRaw | validation | func (m *MockClient) ImageInspectWithRaw(arg0 context.Context, arg1 string) (types.ImageInspect, []byte, error) {
ret := m.ctrl.Call(m, "ImageInspectWithRaw", arg0, arg1)
ret0, _ := ret[0].(types.ImageInspect)
ret1, _ := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | go | {
"resource": ""
} |
q169268 | ImageList | validation | func (m *MockClient) ImageList(arg0 context.Context, arg1 types.ImageListOptions) ([]types.ImageSummary, error) {
ret := m.ctrl.Call(m, "ImageList", arg0, arg1)
ret0, _ := ret[0].([]types.ImageSummary)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169269 | ImageLoad | validation | func (m *MockClient) ImageLoad(arg0 context.Context, arg1 io.Reader, arg2 bool) (types.ImageLoadResponse, error) {
ret := m.ctrl.Call(m, "ImageLoad", arg0, arg1, arg2)
ret0, _ := ret[0].(types.ImageLoadResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169270 | ImagePull | validation | func (m *MockClient) ImagePull(arg0 context.Context, arg1 string, arg2 types.ImagePullOptions) (io.ReadCloser, error) {
ret := m.ctrl.Call(m, "ImagePull", arg0, arg1, arg2)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169271 | ImageRemove | validation | func (m *MockClient) ImageRemove(arg0 context.Context, arg1 string, arg2 types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
ret := m.ctrl.Call(m, "ImageRemove", arg0, arg1, arg2)
ret0, _ := ret[0].([]types.ImageDeleteResponseItem)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169272 | Ping | validation | func (m *MockClient) Ping(arg0 context.Context) (types.Ping, error) {
ret := m.ctrl.Call(m, "Ping", arg0)
ret0, _ := ret[0].(types.Ping)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169273 | PluginList | validation | func (m *MockClient) PluginList(arg0 context.Context, arg1 filters.Args) (types.PluginsListResponse, error) {
ret := m.ctrl.Call(m, "PluginList", arg0, arg1)
ret0, _ := ret[0].(types.PluginsListResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169274 | VolumeCreate | validation | func (m *MockClient) VolumeCreate(arg0 context.Context, arg1 volume.VolumeCreateBody) (types.Volume, error) {
ret := m.ctrl.Call(m, "VolumeCreate", arg0, arg1)
ret0, _ := ret[0].(types.Volume)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169275 | VolumeInspect | validation | func (m *MockClient) VolumeInspect(arg0 context.Context, arg1 string) (types.Volume, error) {
ret := m.ctrl.Call(m, "VolumeInspect", arg0, arg1)
ret0, _ := ret[0].(types.Volume)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169276 | VolumeRemove | validation | func (m *MockClient) VolumeRemove(arg0 context.Context, arg1 string, arg2 bool) error {
ret := m.ctrl.Call(m, "VolumeRemove", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169277 | ResolveTask | validation | func (resolver *DockerContainerMetadataResolver) ResolveTask(dockerID string) (*apitask.Task, error) {
if resolver.dockerTaskEngine == nil {
return nil, fmt.Errorf("Docker task engine uninitialized")
}
task, found := resolver.dockerTaskEngine.State().TaskByID(dockerID)
if !found {
return nil, fmt.Errorf("Could ... | go | {
"resource": ""
} |
q169278 | ResolveContainer | validation | func (resolver *DockerContainerMetadataResolver) ResolveContainer(dockerID string) (*apicontainer.DockerContainer, error) {
if resolver.dockerTaskEngine == nil {
return nil, fmt.Errorf("Docker task engine uninitialized")
}
container, found := resolver.dockerTaskEngine.State().ContainerByID(dockerID)
if !found {
... | go | {
"resource": ""
} |
q169279 | synchronizeState | validation | func (engine *DockerStatsEngine) synchronizeState() error {
listContainersResponse := engine.client.ListContainers(engine.ctx, false, dockerclient.ListContainersTimeout)
if listContainersResponse.Error != nil {
return listContainersResponse.Error
}
for _, containerID := range listContainersResponse.DockerIDs {
... | go | {
"resource": ""
} |
q169280 | addAndStartStatsContainer | validation | func (engine *DockerStatsEngine) addAndStartStatsContainer(containerID string) {
engine.lock.Lock()
defer engine.lock.Unlock()
statsContainer, err := engine.addContainerUnsafe(containerID)
if err != nil {
seelog.Debugf("Adding container to stats watch list failed, container: %s, err: %v", containerID, err)
retu... | go | {
"resource": ""
} |
q169281 | MustInit | validation | func (engine *DockerStatsEngine) MustInit(ctx context.Context, taskEngine ecsengine.TaskEngine, cluster string, containerInstanceArn string) error {
derivedCtx, cancel := context.WithCancel(ctx)
engine.stopEngine = cancel
engine.ctx = derivedCtx
// TODO ensure that this is done only once per engine object
seelog.... | go | {
"resource": ""
} |
q169282 | waitToStop | validation | func (engine *DockerStatsEngine) waitToStop() {
// Waiting for the event stream to close
ctx := engine.containerChangeEventStream.Context()
select {
case <-ctx.Done():
seelog.Debug("Event stream closed, stop listening to the event stream")
engine.containerChangeEventStream.Unsubscribe(containerChangeHandler)
... | go | {
"resource": ""
} |
q169283 | removeAll | validation | func (engine *DockerStatsEngine) removeAll() {
engine.lock.Lock()
defer engine.lock.Unlock()
for task, containers := range engine.tasksToContainers {
for _, statsContainer := range containers {
statsContainer.StopStatsCollection()
}
delete(engine.tasksToContainers, task)
}
for task := range engine.tasks... | go | {
"resource": ""
} |
q169284 | addContainerUnsafe | validation | func (engine *DockerStatsEngine) addContainerUnsafe(dockerID string) (*StatsContainer, error) {
// Make sure that this container belongs to a task and that the task
// is not terminal.
task, err := engine.resolver.ResolveTask(dockerID)
if err != nil {
return nil, errors.Wrapf(err, "could not map container to task... | go | {
"resource": ""
} |
q169285 | addToStatsContainerMapUnsafe | validation | func (engine *DockerStatsEngine) addToStatsContainerMapUnsafe(
taskARN, containerID string,
statsContainer *StatsContainer,
statsMapToUpdate func() map[string]map[string]*StatsContainer) bool {
taskToContainerMap := statsMapToUpdate()
// Check if this container is already being watched.
_, taskExists := taskToC... | go | {
"resource": ""
} |
q169286 | GetInstanceMetrics | validation | func (engine *DockerStatsEngine) GetInstanceMetrics() (*ecstcs.MetricsMetadata, []*ecstcs.TaskMetric, error) {
var taskMetrics []*ecstcs.TaskMetric
idle := engine.isIdle()
metricsMetadata := &ecstcs.MetricsMetadata{
Cluster: aws.String(engine.cluster),
ContainerInstance: aws.String(engine.containerInst... | go | {
"resource": ""
} |
q169287 | GetTaskHealthMetrics | validation | func (engine *DockerStatsEngine) GetTaskHealthMetrics() (*ecstcs.HealthMetadata, []*ecstcs.TaskHealth, error) {
var taskHealths []*ecstcs.TaskHealth
metadata := &ecstcs.HealthMetadata{
Cluster: aws.String(engine.cluster),
ContainerInstance: aws.String(engine.containerInstanceArn),
MessageId: a... | go | {
"resource": ""
} |
q169288 | stopTrackingContainerUnsafe | validation | func (engine *DockerStatsEngine) stopTrackingContainerUnsafe(container *StatsContainer, taskARN string) bool {
terminal, err := container.terminal()
if err != nil {
// Error determining if the container is terminal. This means that the container
// id could not be resolved to a container that is being tracked by ... | go | {
"resource": ""
} |
q169289 | handleDockerEvents | validation | func (engine *DockerStatsEngine) handleDockerEvents(events ...interface{}) error {
for _, event := range events {
dockerContainerChangeEvent, ok := event.(dockerapi.DockerContainerChangeEvent)
if !ok {
return fmt.Errorf("Unexpected event received, expected docker container change event")
}
switch dockerCon... | go | {
"resource": ""
} |
q169290 | removeContainer | validation | func (engine *DockerStatsEngine) removeContainer(dockerID string) {
engine.lock.Lock()
defer engine.lock.Unlock()
// Make sure that this container belongs to a task.
task, err := engine.resolver.ResolveTask(dockerID)
if err != nil {
seelog.Debugf("Could not map container to task, ignoring, err: %v, id: %s", err... | go | {
"resource": ""
} |
q169291 | newDockerContainerMetadataResolver | validation | func newDockerContainerMetadataResolver(taskEngine ecsengine.TaskEngine) (*DockerContainerMetadataResolver, error) {
dockerTaskEngine, ok := taskEngine.(*ecsengine.DockerTaskEngine)
if !ok {
// Error type casting docker task engine.
return nil, fmt.Errorf("Could not load docker task engine")
}
resolver := &Doc... | go | {
"resource": ""
} |
q169292 | taskContainerMetricsUnsafe | validation | func (engine *DockerStatsEngine) taskContainerMetricsUnsafe(taskArn string) ([]*ecstcs.ContainerMetric, error) {
containerMap, taskExists := engine.tasksToContainers[taskArn]
if !taskExists {
return nil, fmt.Errorf("Task not found")
}
var containerMetrics []*ecstcs.ContainerMetric
for _, container := range cont... | go | {
"resource": ""
} |
q169293 | resetStatsUnsafe | validation | func (engine *DockerStatsEngine) resetStatsUnsafe() {
for _, containerMap := range engine.tasksToContainers {
for _, container := range containerMap {
container.statsQueue.Reset()
}
}
} | go | {
"resource": ""
} |
q169294 | ContainerDockerStats | validation | func (engine *DockerStatsEngine) ContainerDockerStats(taskARN string, containerID string) (*types.StatsJSON, error) {
engine.lock.RLock()
defer engine.lock.RUnlock()
containerIDToStatsContainer, ok := engine.tasksToContainers[taskARN]
if !ok {
return nil, errors.Errorf("stats engine: task '%s' for container '%s'... | go | {
"resource": ""
} |
q169295 | newMetricsMetadata | validation | func newMetricsMetadata(cluster *string, containerInstance *string) *ecstcs.MetricsMetadata {
return &ecstcs.MetricsMetadata{
Cluster: cluster,
ContainerInstance: containerInstance,
}
} | go | {
"resource": ""
} |
q169296 | compareSemver | validation | func compareSemver(lhs, rhs semver) int {
if lhs.major < rhs.major {
return -1
}
if lhs.major > rhs.major {
return 1
}
if lhs.minor < rhs.minor {
return -1
}
if lhs.minor > rhs.minor {
return 1
}
if lhs.patch < rhs.patch {
return -1
}
if lhs.patch > rhs.patch {
return 1
}
if lhs.preReleaseVersi... | go | {
"resource": ""
} |
q169297 | ExtractVersion | validation | func ExtractVersion(input string) string {
versionNumberRegex := regexp.MustCompile(` v(\d+\.\d+\.\d+(\-[\S\.\-]+)?(\+[\S\.\-]+)?)`)
versionNumberStr := versionNumberRegex.FindStringSubmatch(input)
if len(versionNumberStr) >= 2 {
return string(versionNumberStr[1])
}
return "UNKNOWN"
} | go | {
"resource": ""
} |
q169298 | GetIAMRoleCredentials | validation | func (role *TaskIAMRoleCredentials) GetIAMRoleCredentials() IAMRoleCredentials {
role.lock.RLock()
defer role.lock.RUnlock()
return role.IAMRoleCredentials
} | go | {
"resource": ""
} |
q169299 | GenerateCredentialsEndpointRelativeURI | validation | func (roleCredentials *IAMRoleCredentials) GenerateCredentialsEndpointRelativeURI() string {
return fmt.Sprintf(credentialsEndpointRelativeURIFormat, CredentialsPath, roleCredentials.CredentialsID)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.