From 6e9aadd968463a453d2c27a277796e117b15281e Mon Sep 17 00:00:00 2001 From: huerdong Date: Tue, 13 Jun 2017 23:16:51 +0000 Subject: [PATCH 01/58] mdservice: initial commit all @huerdong commits squashed for manageable commit history in PR --- README.md | 6 + agent/acs/update_handler/updater_test.go | 12 +- agent/app/agent.go | 24 +- agent/config/config.go | 4 + agent/config/config_test.go | 6 + agent/config/config_unix.go | 1 + agent/config/config_unix_test.go | 2 + agent/config/config_windows.go | 5 +- agent/config/config_windows_test.go | 2 + agent/config/types.go | 10 +- agent/containermetadata/generate_mocks.go | 16 + agent/containermetadata/manager.go | 170 ++++++++ agent/containermetadata/manager_test.go | 187 +++++++++ agent/containermetadata/manager_unix_test.go | 96 +++++ .../containermetadata/manager_windows_test.go | 93 +++++ .../mocks/containermetadata_mocks.go | 129 ++++++ agent/containermetadata/parse_metadata.go | 136 +++++++ .../containermetadata/parse_metadata_test.go | 197 +++++++++ agent/containermetadata/types.go | 114 ++++++ agent/containermetadata/utils.go | 64 +++ agent/containermetadata/utils_test.go | 36 ++ .../containermetadata/write_metadata_test.go | 50 +++ .../containermetadata/write_metadata_unix.go | 68 ++++ .../write_metadata_unix_test.go | 96 +++++ .../write_metadata_windows.go | 70 ++++ .../write_metadata_windows_test.go | 72 ++++ agent/engine/default.go | 5 +- agent/engine/docker_container_engine.go | 1 + agent/engine/docker_task_engine.go | 41 +- agent/engine/docker_task_engine_test.go | 376 +++++++++++++++++- agent/engine/engine_integ_test.go | 5 +- agent/engine/engine_mocks.go | 182 ++++++--- agent/engine/task_manager_test.go | 5 + agent/statemanager/state_manager_test.go | 2 +- agent/statemanager/state_manager_unix_test.go | 4 +- agent/stats/engine_integ_test.go | 4 +- agent/utils/ioutilwrapper/generate_mocks.go | 16 + agent/utils/ioutilwrapper/ioutil.go | 37 ++ .../mocks/ioutilwrapper_mocks.go | 58 +++ agent/utils/oswrapper/generate_mocks.go | 16 + .../utils/oswrapper/mocks/oswrapper_mocks.go | 205 ++++++++++ agent/utils/oswrapper/os.go | 66 +++ 42 files changed, 2598 insertions(+), 91 deletions(-) create mode 100644 agent/containermetadata/generate_mocks.go create mode 100644 agent/containermetadata/manager.go create mode 100644 agent/containermetadata/manager_test.go create mode 100644 agent/containermetadata/manager_unix_test.go create mode 100644 agent/containermetadata/manager_windows_test.go create mode 100644 agent/containermetadata/mocks/containermetadata_mocks.go create mode 100644 agent/containermetadata/parse_metadata.go create mode 100644 agent/containermetadata/parse_metadata_test.go create mode 100644 agent/containermetadata/types.go create mode 100644 agent/containermetadata/utils.go create mode 100644 agent/containermetadata/utils_test.go create mode 100644 agent/containermetadata/write_metadata_test.go create mode 100644 agent/containermetadata/write_metadata_unix.go create mode 100644 agent/containermetadata/write_metadata_unix_test.go create mode 100644 agent/containermetadata/write_metadata_windows.go create mode 100644 agent/containermetadata/write_metadata_windows_test.go create mode 100644 agent/utils/ioutilwrapper/generate_mocks.go create mode 100644 agent/utils/ioutilwrapper/ioutil.go create mode 100644 agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go create mode 100644 agent/utils/oswrapper/generate_mocks.go create mode 100644 agent/utils/oswrapper/mocks/oswrapper_mocks.go create mode 100644 agent/utils/oswrapper/os.go diff --git a/README.md b/README.md index c993500b4d1..e52acd2823c 100644 --- a/README.md +++ b/README.md @@ -175,10 +175,16 @@ configure them as something other than the defaults. | `ECS_IMAGE_MINIMUM_CLEANUP_AGE` | 30m | The minimum time interval between when an image is pulled and when it can be considered for automated image cleanup. | 1h | 1h | | `ECS_NUM_IMAGES_DELETE_PER_CYCLE` | 5 | The maximum number of images to delete in a single automated image cleanup cycle. If set to less than 1, the value is ignored. | 5 | 5 | | `ECS_INSTANCE_ATTRIBUTES` | `{"stack": "prod"}` | These attributes take effect only during initial registration. After the agent has joined an ECS cluster, use the PutAttributes API action to add additional attributes. For more information, see [Amazon ECS Container Agent Configuration](http://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the Amazon ECS Developer Guide.| `{}` | `{}` | +<<<<<<< 6f11735d92bbf1ce7bbe099721a17384095fdff7 | `ECS_ENABLE_TASK_ENI` | `false` | Whether to enable task networking for task to be launched with its own network interface | `false` | Not applicable | | `ECS_CNI_PLUGINS_PATH` | `/ecs/cni` | The path where the cni binary file is located | `/amazon-ecs-cni-plugins` | Not applicable | | `ECS_AWSVPC_BLOCK_IMDS` | `true` | Whether to block access to [Instance Metdata](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) for Tasks started with `awsvpc` network mode | `false` | Not applicable | | `ECS_AWSVPC_ADDITIONAL_LOCAL_ROUTES` | `["10.0.15.0/24"]` | In `awsvpc` network mode, traffic to these prefixes will be routed via the host bridge instead of the task ENI | `[]` | Not applicable | +| `ECS_ENABLE_TASK_ENI` | `false` | Whether to enable task networking for task to be launched with its own network interface | `false` | `false` | +| `ECS_CNI_PLUGINS_PATH` | `/ecs/cni` | The path where the cni binary file is located | `/amazon-ecs-cni-plugins` | `/amazon-ecs-cni-plugins` | +| `ECS_AWSVPC_BLOCK_IMDS` | `true` | Whether to block access to [Instance Metdata](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) for Tasks started with `awsvpc` network mode | `false` | `false`| +| `ECS_ENABLE_CONTAINER_METADATA` | `` | Whether to enable creation of a metadata file in the containers. If enabled the agent will inject a file with the container's various metadata and the user can access the container's metadata internally by accessing the environment variable $ECS_CONTAINER_METADATA_FILE. | `false` | `false` | +| `ECS_HOST_DATA_DIR` | `/var/lib/ecs` | The source directory on the host from which ECS_DATADIR is mounted. We use this to determine the source mount path for container metadata files in the case the Agent is run in a container. We do not use this value in Windows because the Agent is not run on a container in Windows. | `/var/lib/ecs` | `Not used` | ### Persistence diff --git a/agent/acs/update_handler/updater_test.go b/agent/acs/update_handler/updater_test.go index 6d8d0071565..9cf5776c14b 100644 --- a/agent/acs/update_handler/updater_test.go +++ b/agent/acs/update_handler/updater_test.go @@ -105,7 +105,7 @@ func TestPerformUpdateWithUpdatesDisabled(t *testing.T) { Reason: ptr("Updates are disabled").(*string), }}) - u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ + u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ ClusterArn: ptr("cluster").(*string), ContainerInstanceArn: ptr("containerInstance").(*string), MessageId: ptr("mid").(*string), @@ -159,7 +159,7 @@ func TestFullUpdateFlow(t *testing.T) { require.Equal(t, "update-tar-data", writtenFile.String(), "incorrect data written") - u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ + u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ ClusterArn: ptr("cluster").(*string), ContainerInstanceArn: ptr("containerInstance").(*string), MessageId: ptr("mid2").(*string), @@ -224,7 +224,7 @@ func TestUndownloadedUpdate(t *testing.T) { MessageId: ptr("mid").(*string), }}) - u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ + u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ ClusterArn: ptr("cluster").(*string), ContainerInstanceArn: ptr("containerInstance").(*string), MessageId: ptr("mid").(*string), @@ -282,7 +282,7 @@ func TestDuplicateUpdateMessagesWithSuccess(t *testing.T) { require.Equal(t, "update-tar-data", writtenFile.String(), "incorrect data written") - u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ + u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ ClusterArn: ptr("cluster").(*string), ContainerInstanceArn: ptr("containerInstance").(*string), MessageId: ptr("mid3").(*string), @@ -347,7 +347,7 @@ func TestDuplicateUpdateMessagesWithFailure(t *testing.T) { require.Equal(t, "update-tar-data", writtenFile.String(), "incorrect data written") - u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ + u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ ClusterArn: ptr("cluster").(*string), ContainerInstanceArn: ptr("containerInstance").(*string), MessageId: ptr("mid3").(*string), @@ -420,7 +420,7 @@ func TestNewerUpdateMessages(t *testing.T) { require.Equal(t, "newer-update-tar-data", writtenFile.String(), "incorrect data written") - u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ + u.performUpdateHandler(statemanager.NewNoopStateManager(), engine.NewTaskEngine(cfg, nil, nil, nil, nil, nil, nil))(&ecsacs.PerformUpdateMessage{ ClusterArn: ptr("cluster").(*string), ContainerInstanceArn: ptr("containerInstance").(*string), MessageId: ptr("mid2").(*string), diff --git a/agent/app/agent.go b/agent/app/agent.go index 15829ae289d..07b44b6d80a 100644 --- a/agent/app/agent.go +++ b/agent/app/agent.go @@ -25,6 +25,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/app/factory" "github.com/aws/amazon-ecs-agent/agent/app/oswrapper" "github.com/aws/amazon-ecs-agent/agent/config" + "github.com/aws/amazon-ecs-agent/agent/containermetadata" "github.com/aws/amazon-ecs-agent/agent/credentials" "github.com/aws/amazon-ecs-agent/agent/ec2" "github.com/aws/amazon-ecs-agent/agent/ecs_client/model/ecs" @@ -92,6 +93,7 @@ type ecsAgent struct { vpc string subnet string mac string + metadataManager containermetadata.Manager } // newAgent returns a new ecsAgent object @@ -126,6 +128,14 @@ func newAgent( return nil, err } + var metadataManager containermetadata.Manager + if cfg.ContainerMetadataEnabled { + // We use the default API client for the metadata inspect call. This version has some information + // missing which means if we need those fields later we will need to change this client to + // the appropriate version + metadataManager = containermetadata.NewManager(dockerClient, cfg) + } + return &ecsAgent{ ctx: ctx, ec2MetadataClient: ec2MetadataClient, @@ -142,7 +152,8 @@ func newAgent( PluginsPath: cfg.CNIPluginsPath, MinSupportedCNIVersion: config.DefaultMinSupportedCNIVersion, }), - os: oswrapper.New(), + os: oswrapper.New(), + metadataManager: metadataManager, }, nil } @@ -224,6 +235,10 @@ func (agent *ecsAgent) doStart(containerChangeEventStream *eventstream.EventStre } return exitcodes.ExitTerminal } + // Add container instance ARN to metadata manager + if agent.cfg.ContainerMetadataEnabled { + agent.metadataManager.SetContainerInstanceARN(agent.containerInstanceARN) + } // Begin listening to the docker daemon and saving changes taskEngine.SetSaver(stateManager) @@ -255,13 +270,13 @@ func (agent *ecsAgent) newTaskEngine(containerChangeEventStream *eventstream.Eve if !agent.cfg.Checkpoint { seelog.Info("Checkpointing not enabled; a new container instance will be created each time the agent is run") return engine.NewTaskEngine(agent.cfg, agent.dockerClient, - credentialsManager, containerChangeEventStream, imageManager, state), "", nil + credentialsManager, containerChangeEventStream, imageManager, state, agent.metadataManager), "", nil } // We try to set these values by loading the existing state file first var previousCluster, previousEC2InstanceID, previousContainerInstanceArn string previousTaskEngine := engine.NewTaskEngine(agent.cfg, agent.dockerClient, - credentialsManager, containerChangeEventStream, imageManager, state) + credentialsManager, containerChangeEventStream, imageManager, state, agent.metadataManager) // previousState is used to verify that our current runtime configuration is // compatible with our past configuration as reflected by our state-file @@ -287,7 +302,7 @@ func (agent *ecsAgent) newTaskEngine(containerChangeEventStream *eventstream.Eve state.Reset() // Reset taskEngine; all the other values are still default return engine.NewTaskEngine(agent.cfg, agent.dockerClient, credentialsManager, - containerChangeEventStream, imageManager, state), currentEC2InstanceID, nil + containerChangeEventStream, imageManager, state, agent.metadataManager), currentEC2InstanceID, nil } if previousCluster != "" { @@ -298,6 +313,7 @@ func (agent *ecsAgent) newTaskEngine(containerChangeEventStream *eventstream.Eve // Use the values we loaded if there's no issue agent.containerInstanceARN = previousContainerInstanceArn + return previousTaskEngine, currentEC2InstanceID, nil } diff --git a/agent/config/config.go b/agent/config/config.go index bb33dfe8442..57cabeb3e1f 100644 --- a/agent/config/config.go +++ b/agent/config/config.go @@ -353,6 +353,8 @@ func environmentConfig() (Config, error) { errs = append(errs, err) } } + containerMetadataEnabled := utils.ParseBool(os.Getenv("ECS_ENABLE_CONTAINER_METADATA"), false) + dataDirOnHost := os.Getenv("ECS_HOST_DATA_DIR") if len(errs) > 0 { err = utils.NewMultiError(errs...) @@ -393,6 +395,8 @@ func environmentConfig() (Config, error) { CNIPluginsPath: cniPluginsPath, AWSVPCBlockInstanceMetdata: awsVPCBlockInstanceMetadata, AWSVPCAdditionalLocalRoutes: additionalLocalRoutes, + ContainerMetadataEnabled: containerMetadataEnabled, + DataDirOnHost: dataDirOnHost, }, err } diff --git a/agent/config/config_test.go b/agent/config/config_test.go index dd18dbe825d..e9a4a680a00 100644 --- a/agent/config/config_test.go +++ b/agent/config/config_test.go @@ -120,6 +120,10 @@ func TestEnvironmentConfig(t *testing.T) { additionalLocalRoutesJSON := `["1.2.3.4/22","5.6.7.8/32"]` os.Setenv("ECS_AWSVPC_ADDITIONAL_LOCAL_ROUTES", additionalLocalRoutesJSON) defer os.Unsetenv("ECS_AWSVPC_ADDITIONAL_LOCAL_ROUTES") + os.Setenv("ECS_ENABLE_CONTAINER_METADATA", "true") + os.Setenv("ECS_HOST_DATA_DIR", "/etc/ecs/") + defer os.Unsetenv("ECS_ENABLE_CONTAINER_METADATA") + defer os.Unsetenv("ECS_HOST_DATA_DIR") conf, err := environmentConfig() assert.NoError(t, err) @@ -146,6 +150,8 @@ func TestEnvironmentConfig(t *testing.T) { serializedAdditionalLocalRoutesJSON, err := json.Marshal(conf.AWSVPCAdditionalLocalRoutes) assert.NoError(t, err, "should marshal additional local routes") assert.Equal(t, additionalLocalRoutesJSON, string(serializedAdditionalLocalRoutesJSON)) + assert.Equal(t, (90 * time.Second), conf.TaskCleanupWaitDuration) + assert.Equal(t, "/etc/ecs/", conf.DataDirOnHost) } func TestTrimWhitespace(t *testing.T) { diff --git a/agent/config/config_unix.go b/agent/config/config_unix.go index 5229e2515d1..1987f86018b 100644 --- a/agent/config/config_unix.go +++ b/agent/config/config_unix.go @@ -32,6 +32,7 @@ func DefaultConfig() Config { ReservedPorts: []uint16{SSHPort, DockerReservedPort, DockerReservedSSLPort, AgentIntrospectionPort, AgentCredentialsPort}, ReservedPortsUDP: []uint16{}, DataDir: "/data/", + DataDirOnHost: "/var/lib/ecs", DisableMetrics: false, ReservedMemory: 0, AvailableLoggingDrivers: []dockerclient.LoggingDriver{dockerclient.JSONFileDriver}, diff --git a/agent/config/config_unix_test.go b/agent/config/config_unix_test.go index c5b21b7da4a..d9446236f1a 100644 --- a/agent/config/config_unix_test.go +++ b/agent/config/config_unix_test.go @@ -49,6 +49,7 @@ func TestConfigDefault(t *testing.T) { os.Unsetenv("ECS_ENABLE_TASK_ENI") os.Unsetenv("ECS_CNI_PLUGINS_PATH") os.Unsetenv("ECS_AWSVPC_BLOCK_IMDS") + os.Unsetenv("ECS_HOST_DATA_DIR") cfg, err := NewConfig(ec2.NewBlackholeEC2MetadataClient()) assert.NoError(t, err) @@ -73,6 +74,7 @@ func TestConfigDefault(t *testing.T) { assert.Equal(t, DefaultNumImagesToDeletePerCycle, cfg.NumImagesToDeletePerCycle, "NumImagesToDeletePerCycle default is set incorrectly") assert.Equal(t, defaultCNIPluginsPath, cfg.CNIPluginsPath, "CNIPluginsPath default is set incorrectly") assert.False(t, cfg.AWSVPCBlockInstanceMetdata, "AWSVPCBlockInstanceMetdata default is incorrectly set") + assert.Equal(t, "/var/lib/ecs", cfg.DataDirOnHost, "Default DataDirOnHost set incorrectly") } // TestConfigFromFile tests the configuration can be read from file diff --git a/agent/config/config_windows.go b/agent/config/config_windows.go index 5034f0ce3ef..ec41ac89fb9 100644 --- a/agent/config/config_windows.go +++ b/agent/config/config_windows.go @@ -44,6 +44,7 @@ const ( func DefaultConfig() Config { programData := utils.DefaultIfBlank(os.Getenv("ProgramData"), `C:\ProgramData`) ecsRoot := filepath.Join(programData, "Amazon", "ECS") + dataDir := filepath.Join(ecsRoot, "data") return Config{ DockerEndpoint: "npipe:////./pipe/docker_engine", ReservedPorts: []uint16{ @@ -59,7 +60,9 @@ func DefaultConfig() Config { netBIOSPort, }, ReservedPortsUDP: []uint16{}, - DataDir: filepath.Join(ecsRoot, "data"), + DataDir: dataDir, + // DataDirOnHost is identical to DataDir for Windows because we do not run on a container + DataDirOnHost: dataDir, // DisableMetrics is set to true on Windows as docker stats does not work DisableMetrics: true, ReservedMemory: 0, diff --git a/agent/config/config_windows_test.go b/agent/config/config_windows_test.go index e984f47e2c3..f052faf965f 100644 --- a/agent/config/config_windows_test.go +++ b/agent/config/config_windows_test.go @@ -42,6 +42,7 @@ func TestConfigDefault(t *testing.T) { os.Unsetenv("ECS_NUM_IMAGES_DELETE_PER_CYCLE") os.Unsetenv("ECS_IMAGE_MINIMUM_CLEANUP_AGE") os.Unsetenv("ECS_IMAGE_CLEANUP_INTERVAL") + os.Unsetenv("ECS_HOST_DATA_DIR") cfg, err := NewConfig(ec2.NewBlackholeEC2MetadataClient()) assert.NoError(t, err) @@ -63,6 +64,7 @@ func TestConfigDefault(t *testing.T) { assert.Equal(t, DefaultImageDeletionAge, cfg.MinimumImageDeletionAge, "MinimumImageDeletionAge default is set incorrectly") assert.Equal(t, DefaultImageCleanupTimeInterval, cfg.ImageCleanupInterval, "ImageCleanupInterval default is set incorrectly") assert.Equal(t, DefaultNumImagesToDeletePerCycle, cfg.NumImagesToDeletePerCycle, "NumImagesToDeletePerCycle default is set incorrectly") + assert.Equal(t, `C:\ProgramData\Amazon\ECS\data`, cfg.DataDirOnHost, "Default DataDirOnHost set incorrectly") } func TestConfigIAMTaskRolesReserves80(t *testing.T) { diff --git a/agent/config/types.go b/agent/config/types.go index 0c87a92f695..05549c9c58f 100644 --- a/agent/config/types.go +++ b/agent/config/types.go @@ -52,8 +52,12 @@ type Config struct { ReservedPortsUDP []uint16 // DataDir is the directory data is saved to in order to preserve state - // across agent restarts. It is only used if "Checkpoint" is true as well. + // across agent restarts. + // It is also used to keep the metadata of containers managed by the agent DataDir string + // DataDirOnHost is the directory in the instance from which we mount + // DataDir to the ecs-agent container and to agent managed containers + DataDirOnHost string // Checkpoint configures whether data should be periodically to a checkpoint // file, in DataDir, such that on instance or agent restarts it will resume // as the same ContainerInstance. It defaults to false. @@ -180,6 +184,10 @@ type Config struct { // entries that will be added in the task's network namespace via the // instance bridge interface rather than via the ENI. AWSVPCAdditionalLocalRoutes []cnitypes.IPNet + + // ContainerMetadataEnabled specifies if the agent should provide a metadata + // file for containers. + ContainerMetadataEnabled bool } // SensitiveRawMessage is a struct to store some data that should not be logged diff --git a/agent/containermetadata/generate_mocks.go b/agent/containermetadata/generate_mocks.go new file mode 100644 index 00000000000..227ba525873 --- /dev/null +++ b/agent/containermetadata/generate_mocks.go @@ -0,0 +1,16 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +//go:generate go run ../../scripts/generate/mockgen.go github.com/aws/amazon-ecs-agent/agent/containermetadata Manager,DockerMetadataClient mocks/containermetadata_mocks.go diff --git a/agent/containermetadata/manager.go b/agent/containermetadata/manager.go new file mode 100644 index 00000000000..6ff5f242348 --- /dev/null +++ b/agent/containermetadata/manager.go @@ -0,0 +1,170 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "encoding/json" + "fmt" + "os" + "time" + + "github.com/aws/amazon-ecs-agent/agent/config" + "github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper" + + "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" + + docker "github.com/fsouza/go-dockerclient" +) + +const ( + metadataEnvironmentVariable = "ECS_CONTAINER_METADATA_FILE" + inspectContainerTimeout = 30 * time.Second + metadataFile = "ecs-container-metadata.json" + metadataPerm = 0644 +) + +// MetadataStatus specifies the current update status of the metadata file. +// The purpose of this status is for users to check if the metadata file has +// reached the stage they need before they read the rest of the file to avoid +// race conditions (Since the final stage will need to be after the container +// starts up +// In the future the metadata may require multiple stages of update and these +// statuses should amended/appended accordingly. +type MetadataStatus string + +const ( + // MetadataInitial is the initial state of the metadata file which + // contains metadata provided by the ECS Agent + MetadataInitial = "INITIAL" + // MetadataReady is the final state of the metadata file which indicates + // it has acquired all the data it needs (Currently from the Agent and Docker) + MetadataReady = "READY" +) + +// Manager is an interface that allows us to abstract away the metadata +// operations +type Manager interface { + SetContainerInstanceARN(string) + Create(*docker.Config, *docker.HostConfig, string, string) error + Update(string, string, string) error + Clean(string) error +} + +// metadataManager implements the Manager interface +type metadataManager struct { + // client is the Docker API Client that the metadata manager uses. It defaults + // to 1.21 on Linux and 1.24 on Windows + client DockerMetadataClient + // cluster is the cluster where this agent is run + cluster string + // dataDir is the directory where the metadata is being written. For Linux + // this is a container directory + dataDir string + // dataDirOnHost is the directory from which dataDir is mounted for Linux + // version of the agent + dataDirOnHost string + // containerInstanceARN is the Container Instance ARN registered for this agent + containerInstanceARN string + // osWrap is a wrapper for 'os' package operations + osWrap oswrapper.OS + // ioutilWrap is a wrapper for 'ioutil' package operations + ioutilWrap ioutilwrapper.IOUtil +} + +// NewManager creates a metadataManager for a given DockerTaskEngine settings. +func NewManager(client DockerMetadataClient, cfg *config.Config) Manager { + return &metadataManager{ + client: client, + cluster: cfg.Cluster, + dataDir: cfg.DataDir, + dataDirOnHost: cfg.DataDirOnHost, + osWrap: oswrapper.NewOS(), + ioutilWrap: ioutilwrapper.NewIOUtil(), + } +} + +// SetContainerInstanceARN sets the metadataManager's ContainerInstanceArn which is not available +// at its creation as this information is not present immediately at the agent's startup +func (manager *metadataManager) SetContainerInstanceARN(containerInstanceARN string) { + manager.containerInstanceARN = containerInstanceARN +} + +// Create creates the metadata file and adds the metadata directory to +// the container's mounted host volumes +// Pointer hostConfig is modified directly so there is risk of concurrency errors. +func (manager *metadataManager) Create(config *docker.Config, hostConfig *docker.HostConfig, taskARN string, containerName string) error { + // Create task and container directories if they do not yet exist + metadataDirectoryPath, err := getMetadataFilePath(taskARN, containerName, manager.dataDir) + // Stop metadata creation if path is malformed for any reason + if err != nil { + return fmt.Errorf("container metadata create for task %s container %s: %v", taskARN, containerName, err) + } + + err = manager.osWrap.MkdirAll(metadataDirectoryPath, os.ModePerm) + if err != nil { + return fmt.Errorf("creating metadata directory for task %s: %v", taskARN, err) + } + + // Acquire the metadata then write it in JSON format to the file + metadata := manager.parseMetadataAtContainerCreate(taskARN, containerName) + data, err := json.MarshalIndent(metadata, "", "\t") + if err != nil { + return fmt.Errorf("create metadata for task %s container %s: %v", taskARN, containerName, err) + } + + // Write the metadata to file + err = writeToMetadataFile(manager.osWrap, manager.ioutilWrap, data, taskARN, containerName, manager.dataDir) + if err != nil { + return err + } + + // Add the directory of this container's metadata to the container's mount binds + // Then add the destination directory as an environment variable in the container $METADATA + binds, env := createBindsEnv(hostConfig.Binds, config.Env, manager.dataDirOnHost, metadataDirectoryPath) + config.Env = env + hostConfig.Binds = binds + return nil +} + +// Update updates the metadata file after container starts and dynamic metadata is available +func (manager *metadataManager) Update(dockerID string, taskARN string, containerName string) error { + // Get docker container information through api call + dockerContainer, err := manager.client.InspectContainer(dockerID, inspectContainerTimeout) + if err != nil { + return err + } + + // Ensure we do not update a container that is invalid or is not running + if dockerContainer == nil || !dockerContainer.State.Running { + return fmt.Errorf("container metadata update for task %s container %s: container not running or invalid", taskARN, containerName) + } + + // Acquire the metadata then write it in JSON format to the file + metadata := manager.parseMetadata(dockerContainer, taskARN, containerName) + data, err := json.MarshalIndent(metadata, "", "\t") + if err != nil { + return fmt.Errorf("update metadata for task %s container %s: %v", taskARN, containerName, err) + } + + return writeToMetadataFile(manager.osWrap, manager.ioutilWrap, data, taskARN, containerName, manager.dataDir) +} + +// Clean removes the metadata files of all containers associated with a task +func (manager *metadataManager) Clean(taskARN string) error { + metadataPath, err := getTaskMetadataDir(taskARN, manager.dataDir) + if err != nil { + return fmt.Errorf("clean task %s: %v", taskARN, err) + } + return manager.osWrap.RemoveAll(metadataPath) +} diff --git a/agent/containermetadata/manager_test.go b/agent/containermetadata/manager_test.go new file mode 100644 index 00000000000..22c79470aab --- /dev/null +++ b/agent/containermetadata/manager_test.go @@ -0,0 +1,187 @@ +// +build !integration +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "errors" + "fmt" + "testing" + + "github.com/aws/amazon-ecs-agent/agent/containermetadata/mocks" + "github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper/mocks" + "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper/mocks" + + docker "github.com/fsouza/go-dockerclient" + "github.com/golang/mock/gomock" +) + +const ( + containerInstanceARN = "a6348116-0ba6-43b5-87c9-8a7e10294b75" + dockerID = "888888888887" + invalidTaskARN = "invalidARN" + validTaskARN = "arn:aws:ecs:region:account-id:task/task-id" + containerName = "container" + dataDir = "ecs_mockdata" +) + +func managerSetup(t *testing.T) (*mock_containermetadata.MockDockerMetadataClient, *mock_ioutilwrapper.MockIOUtil, *mock_oswrapper.MockOS, *mock_oswrapper.MockFile, func()) { + ctrl := gomock.NewController(t) + mockDockerMetadataClient := mock_containermetadata.NewMockDockerMetadataClient(ctrl) + mockIOUtil := mock_ioutilwrapper.NewMockIOUtil(ctrl) + mockOS := mock_oswrapper.NewMockOS(ctrl) + mockFile := mock_oswrapper.NewMockFile(ctrl) + return mockDockerMetadataClient, mockIOUtil, mockOS, mockFile, ctrl.Finish +} + +// TestSetContainerInstanceARN checks whether the container instance ARN is set correctly. +func TestSetContainerInstanceARN(t *testing.T) { + _, _, _, _, done := managerSetup(t) + defer done() + + mockARN := containerInstanceARN + + newManager := &metadataManager{} + newManager.SetContainerInstanceARN(mockARN) + if newManager.containerInstanceARN != mockARN { + t.Error("Got unexpected container instance ARN: " + newManager.containerInstanceARN) + } +} + +// TestCreateMalformedFilepath checks case when taskARN is invalid resulting in an invalid file path +func TestCreateMalformedFilepath(t *testing.T) { + _, _, _, _, done := managerSetup(t) + defer done() + + mockTaskARN := invalidTaskARN + mockContainerName := containerName + + newManager := &metadataManager{} + err := newManager.Create(nil, nil, mockTaskARN, mockContainerName) + expectErrorMessage := fmt.Sprintf("container metadata create for task %s container %s: get metdata file path of task %s container %s: get task ARN: invalid TaskARN %s", mockTaskARN, mockContainerName, mockTaskARN, mockContainerName, mockTaskARN) + + if err.Error() != expectErrorMessage { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestCreateMkdirAllFail checks case when MkdirAll call fails +func TestCreateMkdirAllFail(t *testing.T) { + _, _, mockOS, _, done := managerSetup(t) + defer done() + + mockTaskARN := validTaskARN + mockContainerName := containerName + + gomock.InOrder( + mockOS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(errors.New("err")), + ) + + newManager := &metadataManager{ + osWrap: mockOS, + } + err := newManager.Create(nil, nil, mockTaskARN, mockContainerName) + expectErrorMessage := fmt.Sprintf("creating metadata directory for task %s: err", mockTaskARN) + + if err.Error() != expectErrorMessage { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestUpdateInspectFail checks case when Inspect call fails +func TestUpdateInspectFail(t *testing.T) { + mockClient, _, _, _, done := managerSetup(t) + defer done() + + mockDockerID := dockerID + mockTaskARN := validTaskARN + mockContainerName := containerName + + newManager := &metadataManager{ + client: mockClient, + } + + mockClient.EXPECT().InspectContainer(mockDockerID, inspectContainerTimeout).Return(nil, errors.New("Inspect fail")) + err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) + + if err == nil { + t.Error("Expected inspect error to result in update fail") + } else if err.Error() != "Inspect fail" { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestUpdateNotRunningFail checks case where container is not running +func TestUpdateNotRunningFail(t *testing.T) { + mockClient, _, _, _, done := managerSetup(t) + defer done() + + mockDockerID := dockerID + mockTaskARN := validTaskARN + mockContainerName := containerName + mockState := docker.State{ + Running: false, + } + mockContainer := &docker.Container{ + State: mockState, + } + + newManager := &metadataManager{ + client: mockClient, + } + + mockClient.EXPECT().InspectContainer(mockDockerID, inspectContainerTimeout).Return(mockContainer, nil) + err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) + expectErrorMessage := fmt.Sprintf("container metadata update for task %s container %s: container not running or invalid", mockTaskARN, mockContainerName) + + if err.Error() != expectErrorMessage { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestCleanMalformedFilepath checks case where ARN is invalid +func TestCleanMalformedFilepath(t *testing.T) { + _, _, _, _, done := managerSetup(t) + defer done() + + mockTaskARN := invalidTaskARN + + newManager := &metadataManager{} + err := newManager.Clean(mockTaskARN) + expectErrorMessage := fmt.Sprintf("clean task %s: get task ARN: invalid TaskARN invalidARN", mockTaskARN) + + if err.Error() != expectErrorMessage { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestClean is the mainline case for metadata create +func TestClean(t *testing.T) { + _, _, mockOS, _, done := managerSetup(t) + defer done() + + mockTaskARN := validTaskARN + + newManager := &metadataManager{ + osWrap: mockOS, + } + + gomock.InOrder( + mockOS.EXPECT().RemoveAll(gomock.Any()).Return(nil), + ) + err := newManager.Clean(mockTaskARN) + if err != nil { + t.Error("Got unexpected error: " + err.Error()) + } +} diff --git a/agent/containermetadata/manager_unix_test.go b/agent/containermetadata/manager_unix_test.go new file mode 100644 index 00000000000..b2ed8e3e921 --- /dev/null +++ b/agent/containermetadata/manager_unix_test.go @@ -0,0 +1,96 @@ +// +build !integration,!windows +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "testing" + + docker "github.com/fsouza/go-dockerclient" + "github.com/golang/mock/gomock" +) + +// TestCreate is the mainline case for metadata create +func TestCreate(t *testing.T) { + _, mockIOUtil, mockOS, mockFile, done := managerSetup(t) + defer done() + + mockTaskARN := validTaskARN + mockContainerName := containerName + mockConfig := &docker.Config{Env: make([]string, 0)} + mockHostConfig := &docker.HostConfig{Binds: make([]string, 0)} + + gomock.InOrder( + mockOS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(nil), + mockIOUtil.EXPECT().TempFile(gomock.Any(), gomock.Any()).Return(mockFile, nil), + mockFile.EXPECT().Write(gomock.Any()).Return(0, nil), + mockFile.EXPECT().Chmod(gomock.Any()).Return(nil), + mockFile.EXPECT().Name().Return(""), + mockOS.EXPECT().Rename(gomock.Any(), gomock.Any()).Return(nil), + mockFile.EXPECT().Close().Return(nil), + ) + + newManager := &metadataManager{ + osWrap: mockOS, + ioutilWrap: mockIOUtil, + } + err := newManager.Create(mockConfig, mockHostConfig, mockTaskARN, mockContainerName) + + if err != nil { + t.Error("Got unexpected error: " + err.Error()) + } + + if len(mockConfig.Env) != 1 { + t.Error("Unexpected number of environment variables in config: ", len(mockConfig.Env)) + } + if len(mockHostConfig.Binds) != 1 { + t.Error("Unexpected number of binds in host config: ", len(mockHostConfig.Binds)) + } +} + +// TestUpdate is mainline case for metadata update +func TestUpdate(t *testing.T) { + mockClient, mockIOUtil, mockOS, mockFile, done := managerSetup(t) + defer done() + + mockDockerID := dockerID + mockTaskARN := validTaskARN + mockContainerName := containerName + mockState := docker.State{ + Running: true, + } + mockContainer := &docker.Container{ + State: mockState, + } + + newManager := &metadataManager{ + client: mockClient, + osWrap: mockOS, + ioutilWrap: mockIOUtil, + } + + gomock.InOrder( + mockClient.EXPECT().InspectContainer(mockDockerID, inspectContainerTimeout).Return(mockContainer, nil), + mockIOUtil.EXPECT().TempFile(gomock.Any(), gomock.Any()).Return(mockFile, nil), + mockFile.EXPECT().Write(gomock.Any()).Return(0, nil), + mockFile.EXPECT().Chmod(gomock.Any()).Return(nil), + mockFile.EXPECT().Name().Return(""), + mockOS.EXPECT().Rename(gomock.Any(), gomock.Any()).Return(nil), + mockFile.EXPECT().Close().Return(nil), + ) + err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) + if err != nil { + t.Error("Got unexpected error: " + err.Error()) + } +} diff --git a/agent/containermetadata/manager_windows_test.go b/agent/containermetadata/manager_windows_test.go new file mode 100644 index 00000000000..bc8b5063964 --- /dev/null +++ b/agent/containermetadata/manager_windows_test.go @@ -0,0 +1,93 @@ +// +build !integration, windows +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "errors" + "testing" + + docker "github.com/fsouza/go-dockerclient" + "github.com/golang/mock/gomock" +) + +// TestCreate is the mainline case for metadata create +func TestCreate(t *testing.T) { + _, _, mockOS, mockFile, done := managerSetup(t) + defer done() + + mockTaskARN := validTaskARN + mockContainerName := containerName + mockConfig := &docker.Config{Env: make([]string, 0)} + mockHostConfig := &docker.HostConfig{Binds: make([]string, 0)} + + gomock.InOrder( + mockOS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(nil), + mockOS.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, errors.New("err")), + mockOS.EXPECT().IsNotExist(gomock.Any()).Return(true), + mockOS.EXPECT().Create(gomock.Any()).Return(mockFile, nil), + mockFile.EXPECT().Write(gomock.Any()).Return(0, nil), + mockFile.EXPECT().Sync().Return(nil), + mockFile.EXPECT().Close().Return(nil), + ) + + newManager := &metadataManager{ + osWrap: mockOS, + } + err := newManager.Create(mockConfig, mockHostConfig, mockTaskARN, mockContainerName) + + if err != nil { + t.Error("Got unexpected error: " + err.Error()) + } + + if len(mockConfig.Env) != 1 { + t.Error("Unexpected number of environment variables in config: ", len(mockConfig.Env)) + } + if len(mockHostConfig.Binds) != 1 { + t.Error("Unexpected number of binds in host config: ", len(mockHostConfig.Binds)) + } +} + +// TestUpdate is mainline case for metadata update +func TestUpdate(t *testing.T) { + mockClient, _, mockOS, mockFile, done := managerSetup(t) + defer done() + + mockDockerID := dockerID + mockTaskARN := validTaskARN + mockContainerName := containerName + mockState := docker.State{ + Running: true, + } + mockContainer := &docker.Container{ + State: mockState, + } + + newManager := &metadataManager{ + client: mockClient, + osWrap: mockOS, + } + + gomock.InOrder( + mockClient.EXPECT().InspectContainer(mockDockerID, inspectContainerTimeout).Return(mockContainer, nil), + mockOS.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockFile, nil), + mockFile.EXPECT().Write(gomock.Any()).Return(0, nil), + mockFile.EXPECT().Sync().Return(nil), + mockFile.EXPECT().Close().Return(nil), + ) + err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) + if err != nil { + t.Error("Got unexpected error: " + err.Error()) + } +} diff --git a/agent/containermetadata/mocks/containermetadata_mocks.go b/agent/containermetadata/mocks/containermetadata_mocks.go new file mode 100644 index 00000000000..3565da9cc3e --- /dev/null +++ b/agent/containermetadata/mocks/containermetadata_mocks.go @@ -0,0 +1,129 @@ +// Copyright 2015-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/amazon-ecs-agent/agent/containermetadata (interfaces: Manager,DockerMetadataClient) + +package mock_containermetadata + +import ( + time "time" + + go_dockerclient "github.com/fsouza/go-dockerclient" + gomock "github.com/golang/mock/gomock" +) + +// MockManager is a mock of Manager interface +type MockManager struct { + ctrl *gomock.Controller + recorder *MockManagerMockRecorder +} + +// MockManagerMockRecorder is the mock recorder for MockManager +type MockManagerMockRecorder struct { + mock *MockManager +} + +// NewMockManager creates a new mock instance +func NewMockManager(ctrl *gomock.Controller) *MockManager { + mock := &MockManager{ctrl: ctrl} + mock.recorder = &MockManagerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockManager) EXPECT() *MockManagerMockRecorder { + return _m.recorder +} + +// Clean mocks base method +func (_m *MockManager) Clean(_param0 string) error { + ret := _m.ctrl.Call(_m, "Clean", _param0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Clean indicates an expected call of Clean +func (_mr *MockManagerMockRecorder) Clean(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Clean", arg0) +} + +// Create mocks base method +func (_m *MockManager) Create(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 string) error { + ret := _m.ctrl.Call(_m, "Create", _param0, _param1, _param2, _param3) + ret0, _ := ret[0].(error) + return ret0 +} + +// Create indicates an expected call of Create +func (_mr *MockManagerMockRecorder) Create(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2, arg3) +} + +// SetContainerInstanceARN mocks base method +func (_m *MockManager) SetContainerInstanceARN(_param0 string) { + _m.ctrl.Call(_m, "SetContainerInstanceARN", _param0) +} + +// SetContainerInstanceARN indicates an expected call of SetContainerInstanceARN +func (_mr *MockManagerMockRecorder) SetContainerInstanceARN(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetContainerInstanceARN", arg0) +} + +// Update mocks base method +func (_m *MockManager) Update(_param0 string, _param1 string, _param2 string) error { + ret := _m.ctrl.Call(_m, "Update", _param0, _param1, _param2) + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update +func (_mr *MockManagerMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2) +} + +// MockDockerMetadataClient is a mock of DockerMetadataClient interface +type MockDockerMetadataClient struct { + ctrl *gomock.Controller + recorder *MockDockerMetadataClientMockRecorder +} + +// MockDockerMetadataClientMockRecorder is the mock recorder for MockDockerMetadataClient +type MockDockerMetadataClientMockRecorder struct { + mock *MockDockerMetadataClient +} + +// NewMockDockerMetadataClient creates a new mock instance +func NewMockDockerMetadataClient(ctrl *gomock.Controller) *MockDockerMetadataClient { + mock := &MockDockerMetadataClient{ctrl: ctrl} + mock.recorder = &MockDockerMetadataClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockDockerMetadataClient) EXPECT() *MockDockerMetadataClientMockRecorder { + return _m.recorder +} + +// InspectContainer mocks base method +func (_m *MockDockerMetadataClient) InspectContainer(_param0 string, _param1 time.Duration) (*go_dockerclient.Container, error) { + ret := _m.ctrl.Call(_m, "InspectContainer", _param0, _param1) + ret0, _ := ret[0].(*go_dockerclient.Container) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InspectContainer indicates an expected call of InspectContainer +func (_mr *MockDockerMetadataClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) +} diff --git a/agent/containermetadata/parse_metadata.go b/agent/containermetadata/parse_metadata.go new file mode 100644 index 00000000000..14cfd1747f7 --- /dev/null +++ b/agent/containermetadata/parse_metadata.go @@ -0,0 +1,136 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "fmt" + + "github.com/aws/amazon-ecs-agent/agent/api" + + "github.com/cihub/seelog" + docker "github.com/fsouza/go-dockerclient" +) + +// parseMetadataAtContainerCreate gathers metadata from task and cluster configurations +// then packages it for JSON Marshaling. We use this version to get data +// available prior to container creation +// Since we accept incomplete metadata fields, we should not return +// errors here and handle them at this or the above stage. +func (manager *metadataManager) parseMetadataAtContainerCreate(taskARN string, containerName string) Metadata { + return Metadata{ + cluster: manager.cluster, + taskMetadata: TaskMetadata{containerName: containerName, taskARN: taskARN}, + containerInstanceARN: manager.containerInstanceARN, + metadataStatus: MetadataInitial, + } +} + +// parseMetadata gathers metadata from a docker container, and task +// configuration and data then packages it for JSON Marshaling +// Since we accept incomplete metadata fields, we should not return +// errors here and handle them at this or the above stage. +func (manager *metadataManager) parseMetadata(dockerContainer *docker.Container, taskARN string, containerName string) Metadata { + dockerMD := parseDockerContainerMetadata(taskARN, containerName, dockerContainer) + return Metadata{ + cluster: manager.cluster, + taskMetadata: TaskMetadata{containerName: containerName, taskARN: taskARN}, + dockerContainerMetadata: dockerMD, + containerInstanceARN: manager.containerInstanceARN, + metadataStatus: MetadataReady, + } +} + +// parseDockerContainerMetadata parses the metadata in a docker container +// and packages this data for JSON marshaling +// Since we accept incomplete metadata fields, we should not return +// errors here and handle them at this stage. +func parseDockerContainerMetadata(taskARN string, containerName string, dockerContainer *docker.Container) DockerContainerMetadata { + if dockerContainer == nil { + seelog.Warnf("Failed to parse container metadata for task %s container %s: container metadata not available or does not exist", taskARN, containerName) + return DockerContainerMetadata{} + } + + // In most cases a container should never lack a config but we check regardless to avoid + // nil pointer exceptions (Could occur if there is some error in the docker api call, if the + // container we receive has incomplete information) + imageNameFromConfig := "" + if dockerContainer.Config != nil { + imageNameFromConfig = dockerContainer.Config.Image + } else { + seelog.Warnf("Failed to parse container metadata for task %s container %s: container has no configuration", taskARN, containerName) + } + + // Get Port bindings from docker configurations + var ports []api.PortBinding + var err error + if dockerContainer.HostConfig != nil { + ports, err = api.PortBindingFromDockerPortBinding(dockerContainer.HostConfig.PortBindings) + if err != nil { + seelog.Warnf("Failed to parse container metadata for task %s container %s: %v", taskARN, containerName, err) + } + } else { + seelog.Warnf("Failed to parse container metadata for task %s container %s: container has no host configuration", taskARN, containerName) + } + + networkMetadata, err := parseNetworkMetadata(dockerContainer.NetworkSettings, dockerContainer.HostConfig) + if err != nil { + seelog.Warnf("Failed to parse container metadata for task %s container %s: %v", taskARN, containerName, err) + } + + return DockerContainerMetadata{ + containerID: dockerContainer.ID, + dockerContainerName: dockerContainer.Name, + imageID: dockerContainer.Image, + imageName: imageNameFromConfig, + ports: ports, + networkInfo: networkMetadata, + } +} + +// parseNetworkMetadata parses the docker.NetworkSettings struct and +// packages the desired metadata for JSON marshaling +// Since we accept incomplete metadata fields, we should not return +// errors here and handle them at this stage. +func parseNetworkMetadata(settings *docker.NetworkSettings, hostConfig *docker.HostConfig) (NetworkMetadata, error) { + // Network settings and Host configuration should not be missing except due to errors + if settings == nil || hostConfig == nil { + err := fmt.Errorf("parse network metadata: could not find network settings or host configuration") + return NetworkMetadata{}, err + } + + // This metadata is the information provided in older versions of the API + // We get the NetworkMode (Network interface name) from the HostConfig because this + // this is the network with which the container is created + ipv4AddressFromSettings := settings.IPAddress + networkModeFromHostConfig := hostConfig.NetworkMode + + // Extensive Network information is not available for Docker API versions 1.17-1.20 + // Instead we only get the details of the first network + networkList := make([]Network, 0) + if len(settings.Networks) > 0 { + for modeFromSettings, containerNetwork := range settings.Networks { + networkMode := modeFromSettings + ipv4Address := containerNetwork.IPAddress + network := Network{NetworkMode: networkMode, IPv4Address: ipv4Address} + networkList = append(networkList, network) + } + } else { + network := Network{NetworkMode: networkModeFromHostConfig, IPv4Address: ipv4AddressFromSettings} + networkList = append(networkList, network) + } + + return NetworkMetadata{ + networks: networkList, + }, nil +} diff --git a/agent/containermetadata/parse_metadata_test.go b/agent/containermetadata/parse_metadata_test.go new file mode 100644 index 00000000000..bd75ad8754f --- /dev/null +++ b/agent/containermetadata/parse_metadata_test.go @@ -0,0 +1,197 @@ +// +build !integration +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "testing" + + docker "github.com/fsouza/go-dockerclient" + "github.com/stretchr/testify/assert" +) + +const ( + cluster = "us-west2" +) + +// TestParseContainerCreate checks case when parsing is done at metadata creation +func TestParseContainerCreate(t *testing.T) { + mockTaskARN := validTaskARN + mockContainerName := containerName + mockCluster := cluster + mockContainerInstanceARN := containerInstanceARN + + newManager := &metadataManager{ + cluster: mockCluster, + containerInstanceARN: mockContainerInstanceARN, + } + + metadata := newManager.parseMetadataAtContainerCreate(mockTaskARN, mockContainerName) + assert.Equal(t, metadata.cluster, mockCluster, "Expected cluster "+mockCluster) + assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) + assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) + assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) + assert.Equal(t, string(metadata.metadataStatus), "INITIAL", "Expected status "+MetadataInitial) +} + +func TestParseHasNoContainer(t *testing.T) { + mockTaskARN := validTaskARN + mockContainerName := containerName + mockCluster := cluster + mockContainerInstanceARN := containerInstanceARN + + newManager := &metadataManager{ + cluster: mockCluster, + containerInstanceARN: mockContainerInstanceARN, + } + + metadata := newManager.parseMetadata(nil, mockTaskARN, mockContainerName) + assert.Equal(t, metadata.cluster, mockCluster, "Expected cluster "+mockCluster) + assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) + assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) + assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) + assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, metadata.dockerContainerMetadata.containerID, "", "Expected empty container metadata") + assert.Equal(t, metadata.dockerContainerMetadata.dockerContainerName, "", "Expected empty container metadata") + assert.Equal(t, metadata.dockerContainerMetadata.imageID, "", "Expected empty container metadata") + assert.Equal(t, metadata.dockerContainerMetadata.imageName, "", "Expected empty container metadata") +} + +func TestParseHasConfig(t *testing.T) { + mockTaskARN := validTaskARN + mockContainerName := containerName + mockCluster := cluster + mockContainerInstanceARN := containerInstanceARN + + mockConfig := &docker.Config{Image: "image"} + mockContainer := &docker.Container{Config: mockConfig} + + newManager := &metadataManager{ + cluster: mockCluster, + containerInstanceARN: mockContainerInstanceARN, + } + + metadata := newManager.parseMetadata(mockContainer, mockTaskARN, mockContainerName) + assert.Equal(t, metadata.cluster, mockCluster, "Expected cluster "+mockCluster) + assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) + assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) + assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) + assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, metadata.dockerContainerMetadata.imageName, "image", "Expected nonempty imageID") +} + +func TestParseHasHostConfigPortBindsError(t *testing.T) { + mockTaskARN := validTaskARN + mockContainerName := containerName + mockCluster := cluster + mockContainerInstanceARN := containerInstanceARN + + mockPorts := make(map[docker.Port][]docker.PortBinding) + mockPortBinding := make([]docker.PortBinding, 0) + mockPortBinding = append(mockPortBinding, docker.PortBinding{}) + mockPorts["80/tcp"] = mockPortBinding + mockHostConfig := &docker.HostConfig{PortBindings: mockPorts} + mockContainer := &docker.Container{HostConfig: mockHostConfig} + + newManager := &metadataManager{ + cluster: mockCluster, + containerInstanceARN: mockContainerInstanceARN, + } + + metadata := newManager.parseMetadata(mockContainer, mockTaskARN, mockContainerName) + assert.Equal(t, metadata.cluster, mockCluster, "Expected cluster "+mockCluster) + assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) + assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) + assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) + assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, len(metadata.dockerContainerMetadata.ports), 0, "Expected empty list of ports") +} + +func TestParseHasHostConfigPortBindsNoError(t *testing.T) { + mockTaskARN := validTaskARN + mockContainerName := containerName + mockCluster := cluster + mockContainerInstanceARN := containerInstanceARN + + mockPorts := make(map[docker.Port][]docker.PortBinding) + mockPortBinding := make([]docker.PortBinding, 0) + mockPortBinding = append(mockPortBinding, docker.PortBinding{HostIP: "0.0.0.0", HostPort: "80"}) + mockPorts["80/tcp"] = mockPortBinding + mockHostConfig := &docker.HostConfig{PortBindings: mockPorts} + mockContainer := &docker.Container{HostConfig: mockHostConfig} + + newManager := &metadataManager{ + cluster: mockCluster, + containerInstanceARN: mockContainerInstanceARN, + } + + metadata := newManager.parseMetadata(mockContainer, mockTaskARN, mockContainerName) + assert.Equal(t, metadata.cluster, mockCluster, "Expected cluster "+mockCluster) + assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) + assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) + assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) + assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, len(metadata.dockerContainerMetadata.ports), 1, "Expected empty list of ports") +} + +func TestParseHasNetworkSettingsNetworksEmpty(t *testing.T) { + mockTaskARN := validTaskARN + mockContainerName := containerName + mockCluster := cluster + mockContainerInstanceARN := containerInstanceARN + + mockHostConfig := &docker.HostConfig{NetworkMode: "bridge"} + mockNetworkSettings := &docker.NetworkSettings{IPAddress: "0.0.0.0"} + mockContainer := &docker.Container{HostConfig: mockHostConfig, NetworkSettings: mockNetworkSettings} + + newManager := &metadataManager{ + cluster: mockCluster, + containerInstanceARN: mockContainerInstanceARN, + } + + metadata := newManager.parseMetadata(mockContainer, mockTaskARN, mockContainerName) + assert.Equal(t, metadata.cluster, mockCluster, "Expected cluster "+mockCluster) + assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) + assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) + assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) + assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, len(metadata.dockerContainerMetadata.networkInfo.networks), 1, "Expected one network") +} + +func TestParseHasNetworkSettingsNetworksNonEmpty(t *testing.T) { + mockTaskARN := validTaskARN + mockContainerName := containerName + mockCluster := cluster + mockContainerInstanceARN := containerInstanceARN + + mockHostConfig := &docker.HostConfig{NetworkMode: "bridge"} + mockNetworks := make(map[string]docker.ContainerNetwork) + mockNetworks["bridge"] = docker.ContainerNetwork{} + mockNetworks["network0"] = docker.ContainerNetwork{} + mockNetworkSettings := &docker.NetworkSettings{Networks: mockNetworks} + mockContainer := &docker.Container{HostConfig: mockHostConfig, NetworkSettings: mockNetworkSettings} + + newManager := &metadataManager{ + cluster: mockCluster, + containerInstanceARN: mockContainerInstanceARN, + } + + metadata := newManager.parseMetadata(mockContainer, mockTaskARN, mockContainerName) + assert.Equal(t, metadata.cluster, mockCluster, "Expected cluster "+mockCluster) + assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) + assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) + assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) + assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, len(metadata.dockerContainerMetadata.networkInfo.networks), 2, "Expected two networks") +} diff --git a/agent/containermetadata/types.go b/agent/containermetadata/types.go new file mode 100644 index 00000000000..4b33d13c5dd --- /dev/null +++ b/agent/containermetadata/types.go @@ -0,0 +1,114 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "encoding/json" + "time" + + "github.com/aws/amazon-ecs-agent/agent/api" + + docker "github.com/fsouza/go-dockerclient" +) + +// DockerMetadataClient is a wrapper for the docker interface functions we need +// We use this as a dummy type to be able to pass in engine.DockerClient to +// our functions without creating import cycles +// We make it exported because we need to use it for testing (Using the MockDockerClient +// in engine package leads to import cycles) +// The problems described above are indications engine.DockerClient needs to be moved +// outside the engine package +type DockerMetadataClient interface { + InspectContainer(string, time.Duration) (*docker.Container, error) +} + +// Network is a struct that keeps track of metadata of a network interface +type Network struct { + NetworkMode string `json:"NetworkMode,omitempty"` + IPv4Address string `json:"IPv4Address,omitempty"` + IPv6Address string `json:"IPv6Address,omitempty"` +} + +// NetworkMetadata keeps track of the data we parse from the Network Settings +// in docker containers. While most information is redundant with the internal +// Network struct, we keeps this wrapper in case we wish to add data specifically +// from the NetworkSettings +type NetworkMetadata struct { + networks []Network +} + +// DockerContainerMetadata keeps track of all metadata acquired from Docker inspection +// Has redundancies with engine.DockerContainerMetadata but this packages all +// docker metadata we want in the service so we can change features easily +type DockerContainerMetadata struct { + containerID string + dockerContainerName string + imageID string + imageName string + networkMode string + ports []api.PortBinding + networkInfo NetworkMetadata +} + +// TaskMetadata keeps track of all metadata associated with a task +// provided by AWS, does not depend on the creation of the container +type TaskMetadata struct { + containerName string + taskARN string +} + +// Metadata packages all acquired metadata and is used to format it +// into JSON to write to the metadata file. We have it flattened, rather +// than simply containing the previous three structures to simplify JSON +// parsing and avoid exposing those structs in the final metadata file. +type Metadata struct { + cluster string + taskMetadata TaskMetadata + dockerContainerMetadata DockerContainerMetadata + containerInstanceARN string + metadataStatus MetadataStatus +} + +// metadataSerializer is an intermediate struct that converts the information +// in Metadata into information to encode into JSOn +type metadataSerializer struct { + Cluster string `json:"Cluster,omitempty"` + ContainerInstanceARN string `json:"ContainerInstanceARN,omitempty"` + TaskARN string `json:"TaskARN,omitempty"` + ContainerID string `json:"ContainerID,omitempty"` + ContainerName string `json:"ContainerName,omitempty"` + DockerContainerName string `json:"DockerContainerName,omitempty"` + ImageID string `json:"ImageID,omitempty"` + ImageName string `json:"ImageName,omitempty"` + Ports []api.PortBinding `json:"PortMappings,omitempty"` + Networks []Network `json:"Networks,omitempty"` + MetadataFileStatus MetadataStatus `json:"MetadataFileStatus,omitempty"` +} + +func (m Metadata) MarshalJSON() ([]byte, error) { + return json.Marshal( + metadataSerializer{ + Cluster: m.cluster, + ContainerInstanceARN: m.containerInstanceARN, + TaskARN: m.taskMetadata.taskARN, + ContainerID: m.dockerContainerMetadata.containerID, + ContainerName: m.taskMetadata.containerName, + DockerContainerName: m.dockerContainerMetadata.dockerContainerName, + ImageID: m.dockerContainerMetadata.imageID, + ImageName: m.dockerContainerMetadata.imageName, + Ports: m.dockerContainerMetadata.ports, + Networks: m.dockerContainerMetadata.networkInfo.networks, + MetadataFileStatus: m.metadataStatus, + }) +} diff --git a/agent/containermetadata/utils.go b/agent/containermetadata/utils.go new file mode 100644 index 00000000000..5f9f28ef2b3 --- /dev/null +++ b/agent/containermetadata/utils.go @@ -0,0 +1,64 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "fmt" + "path/filepath" + "strings" +) + +const ( + metadataJoinSuffix = "metadata" +) + +// getTaskIDfromARN parses a task ARN and produces the task ID +// A task ARN has format arn:aws:ecs:[region]:[account-id]:task/[task-id] +// For a correctly formatted ARN we split it over ":" into 6 parts, the last part +// containing the task-id which we extract by splitting it by "/". +// This function should be eventually be replaced by a standardized ARN parsing +// module +func getTaskIDfromARN(taskARN string) (string, error) { + colonSplitARN := strings.SplitN(taskARN, ":", 6) + // Incorrectly formatted ARN (Should not happen) + if len(colonSplitARN) < 6 { + return "", fmt.Errorf("get task ARN: invalid TaskARN %s", taskARN) + } + arnTaskPartSplit := strings.SplitN(colonSplitARN[5], "/", 2) + // Incorrectly formatted ARN (Should not happen) + if len(arnTaskPartSplit) < 2 { + return "", fmt.Errorf("get task ARN: cannot find TaskID for TaskARN %s", taskARN) + } + return arnTaskPartSplit[1], nil +} + +// getMetadataFilePath gives the metadata file path for any agent-managed container +func getMetadataFilePath(taskARN string, containerName string, dataDir string) (string, error) { + taskID, err := getTaskIDfromARN(taskARN) + // Empty task ID indicates malformed ARN (Should not happen) + if err != nil { + return "", fmt.Errorf("get metdata file path of task %s container %s: %v", taskARN, containerName, err) + } + return filepath.Join(dataDir, metadataJoinSuffix, taskID, containerName), nil +} + +// getTaskMetadataDir acquires the directory with all of the metadata +// files of a given task +func getTaskMetadataDir(taskARN string, dataDir string) (string, error) { + taskID, err := getTaskIDfromARN(taskARN) + if err != nil { + fmt.Errorf("get task metadata directory: %v", err) + } + return filepath.Join(dataDir, metadataJoinSuffix, taskID), err +} diff --git a/agent/containermetadata/utils_test.go b/agent/containermetadata/utils_test.go new file mode 100644 index 00000000000..315df3250c2 --- /dev/null +++ b/agent/containermetadata/utils_test.go @@ -0,0 +1,36 @@ +// +build !integration +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "fmt" + "testing" +) + +const ( + invalidSplitTaskARN = "arn:aws:ecs:region:account-id:task" +) + +// TestGetTaskIDFailDueToInvalidID checks the case where task ARN has 6 parts but last section is invalid +func TestGetTaskIDFailDueToInvalidID(t *testing.T) { + mockTaskARN := invalidSplitTaskARN + + _, err := getTaskIDfromARN(mockTaskARN) + expectErrorMessage := fmt.Sprintf("get task ARN: cannot find TaskID for TaskARN %s", mockTaskARN) + + if err.Error() != expectErrorMessage { + t.Error("Got unexpected error: " + err.Error()) + } +} diff --git a/agent/containermetadata/write_metadata_test.go b/agent/containermetadata/write_metadata_test.go new file mode 100644 index 00000000000..44fac4ff6d0 --- /dev/null +++ b/agent/containermetadata/write_metadata_test.go @@ -0,0 +1,50 @@ +// +build !integration +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "fmt" + "testing" + + "github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper/mocks" + "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper/mocks" + + "github.com/golang/mock/gomock" +) + +func writeSetup(t *testing.T) (*mock_ioutilwrapper.MockIOUtil, *mock_oswrapper.MockOS, *mock_oswrapper.MockFile, func()) { + ctrl := gomock.NewController(t) + mockIOUtil := mock_ioutilwrapper.NewMockIOUtil(ctrl) + mockOS := mock_oswrapper.NewMockOS(ctrl) + mockFile := mock_oswrapper.NewMockFile(ctrl) + return mockIOUtil, mockOS, mockFile, ctrl.Finish +} + +// TestWriteInvalidARN checks case where task ARN passed in is invalid +func TestWriteInvalidARN(t *testing.T) { + _, _, _, done := writeSetup(t) + defer done() + + mockData := []byte("") + mockTaskARN := invalidTaskARN + mockContainerName := containerName + mockDataDir := dataDir + expectErrorMessage := fmt.Sprintf("write to metadata file for task %s container %s: get metdata file path of task %s container %s: get task ARN: invalid TaskARN %s", mockTaskARN, mockContainerName, mockTaskARN, mockContainerName, mockTaskARN) + + err := writeToMetadataFile(nil, nil, mockData, mockTaskARN, mockContainerName, mockDataDir) + if err.Error() != expectErrorMessage { + t.Error("Got unexpected error: " + err.Error()) + } +} diff --git a/agent/containermetadata/write_metadata_unix.go b/agent/containermetadata/write_metadata_unix.go new file mode 100644 index 00000000000..bce4e046146 --- /dev/null +++ b/agent/containermetadata/write_metadata_unix.go @@ -0,0 +1,68 @@ +// +build !windows + +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "fmt" + "path/filepath" + + "github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper" + "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" + + "github.com/pborman/uuid" +) + +const ( + mountPoint = "/opt/ecs/metadata" +) + +// createBindsEnv will do the appropriate formatting to add a new mount in a container's HostConfig +// and add the metadata file path as an environment variable ECS_CONTAINER_METADATA_FILE +// We add an additional uuid to the path to ensure it does not conflict with user mounts +func createBindsEnv(binds []string, env []string, dataDirOnHost string, metadataDirectoryPath string) ([]string, []string) { + randID := uuid.New() + instanceBind := fmt.Sprintf(`%s/%s:%s/%s`, dataDirOnHost, metadataDirectoryPath, mountPoint, randID) + metadataEnvVariable := fmt.Sprintf("%s=%s/%s/%s", metadataEnvironmentVariable, mountPoint, randID, metadataFile) + binds = append(binds, instanceBind) + env = append(env, metadataEnvVariable) + return binds, env +} + +// writeToMetadata puts the metadata into JSON format and writes into +// the metadata file +func writeToMetadataFile(osWrap oswrapper.OS, ioutilWrap ioutilwrapper.IOUtil, data []byte, taskARN string, containerName string, dataDir string) error { + metadataFileDir, err := getMetadataFilePath(taskARN, containerName, dataDir) + // Boundary case if file path is bad (Such as if task arn is incorrectly formatted) + if err != nil { + return fmt.Errorf("write to metadata file for task %s container %s: %v", taskARN, containerName, err) + } + metadataFileName := filepath.Join(metadataFileDir, metadataFile) + + temp, err := ioutilWrap.TempFile(metadataFileDir, "temp_metadata_file") + if err != nil { + return err + } + defer temp.Close() + _, err = temp.Write(data) + if err != nil { + return err + } + err = temp.Chmod(metadataPerm) + if err != nil { + return err + } + return osWrap.Rename(temp.Name(), metadataFileName) +} diff --git a/agent/containermetadata/write_metadata_unix_test.go b/agent/containermetadata/write_metadata_unix_test.go new file mode 100644 index 00000000000..45e6945312d --- /dev/null +++ b/agent/containermetadata/write_metadata_unix_test.go @@ -0,0 +1,96 @@ +// +build !integration, !windows +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "errors" + "testing" + + "github.com/golang/mock/gomock" +) + +// TestWriteTempFileFail checks case where temp file cannot be made +func TestWriteTempFileFail(t *testing.T) { + mockIOUtil, _, _, done := writeSetup(t) + defer done() + + mockData := []byte("") + mockTaskARN := validTaskARN + mockContainerName := containerName + mockDataDir := dataDir + + gomock.InOrder( + mockIOUtil.EXPECT().TempFile(gomock.Any(), gomock.Any()).Return(nil, errors.New("temp file fail")), + ) + + err := writeToMetadataFile(nil, mockIOUtil, mockData, mockTaskARN, mockContainerName, mockDataDir) + if err == nil { + t.Error("Expected error to be returned") + } + if err.Error() != "temp file fail" { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestWriteFileWriteFail checks case where write to file fails +func TestWriteFileWriteFail(t *testing.T) { + mockIOUtil, _, mockFile, done := writeSetup(t) + defer done() + + mockData := []byte("") + mockTaskARN := validTaskARN + mockContainerName := containerName + mockDataDir := dataDir + + gomock.InOrder( + mockIOUtil.EXPECT().TempFile(gomock.Any(), gomock.Any()).Return(mockFile, nil), + mockFile.EXPECT().Write(mockData).Return(0, errors.New("write fail")), + mockFile.EXPECT().Close(), + ) + + err := writeToMetadataFile(nil, mockIOUtil, mockData, mockTaskARN, mockContainerName, mockDataDir) + if err == nil { + t.Error("Expected error to be returned") + } + if err.Error() != "write fail" { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestWriteChmodFail checks case where chmod fails +func TestWriteChmodFail(t *testing.T) { + mockIOUtil, _, mockFile, done := writeSetup(t) + defer done() + + mockData := []byte("") + mockTaskARN := validTaskARN + mockContainerName := containerName + mockDataDir := dataDir + + gomock.InOrder( + mockIOUtil.EXPECT().TempFile(gomock.Any(), gomock.Any()).Return(mockFile, nil), + mockFile.EXPECT().Write(mockData).Return(0, nil), + mockFile.EXPECT().Chmod(gomock.Any()).Return(errors.New("chmod fail")), + mockFile.EXPECT().Close(), + ) + + err := writeToMetadataFile(nil, mockIOUtil, mockData, mockTaskARN, mockContainerName, mockDataDir) + if err == nil { + t.Error("Expected error to be returned") + } + if err.Error() != "chmod fail" { + t.Error("Got unexpected error: " + err.Error()) + } +} diff --git a/agent/containermetadata/write_metadata_windows.go b/agent/containermetadata/write_metadata_windows.go new file mode 100644 index 00000000000..2201ac3324a --- /dev/null +++ b/agent/containermetadata/write_metadata_windows.go @@ -0,0 +1,70 @@ +// +build windows + +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "fmt" + "os" + "path/filepath" + + "github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper" + "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" + + "github.com/pborman/uuid" +) + +const ( + mountPoint = `C:\ProgramData\Amazon\ECS\metadata` +) + +// createBindsEnv will do the appropriate formatting to add a new mount in a container's HostConfig +// and add the metadata file path as an environment variable ECS_CONTAINER_METADATA_FILE +func createBindsEnv(binds []string, env []string, dataDirOnHost string, metadataDirectoryPath string) ([]string, []string) { + randID := uuid.New() + instanceBind := fmt.Sprintf(`%s:%s\%s`, metadataDirectoryPath, mountPoint, randID) + metadataEnvVariable := fmt.Sprintf(`%s=%s\%s\%s`, metadataEnvironmentVariable, mountPoint, randID, metadataFile) + binds = append(binds, instanceBind) + env = append(env, metadataEnvVariable) + return binds, env +} + +// writeToMetadata puts the metadata into JSON format and writes into +// the metadata file +func writeToMetadataFile(osWrap oswrapper.OS, ioutilWrap ioutilwrapper.IOUtil, data []byte, taskARN string, containerName string, dataDir string) error { + metadataFileDir, err := getMetadataFilePath(taskARN, containerName, dataDir) + // Boundary case if file path is bad (Such as if task arn is incorrectly formatted) + if err != nil { + return fmt.Errorf("write to metadata file for task %s container %s: %v", taskARN, containerName, err) + } + metadataFileName := filepath.Join(metadataFileDir, metadataFile) + + file, err := osWrap.OpenFile(metadataFileName, os.O_WRONLY, metadataPerm) + if err != nil { + // Retry if file does not exist + if osWrap.IsNotExist(err) { + file, err = osWrap.Create(metadataFileName) + } + if err != nil { + return err + } + } + defer file.Close() + _, err = file.Write(data) + if err != nil { + return err + } + return file.Sync() +} diff --git a/agent/containermetadata/write_metadata_windows_test.go b/agent/containermetadata/write_metadata_windows_test.go new file mode 100644 index 00000000000..4c8c0217fae --- /dev/null +++ b/agent/containermetadata/write_metadata_windows_test.go @@ -0,0 +1,72 @@ +// +build !integration, windows +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "errors" + "testing" + + "github.com/golang/mock/gomock" +) + +// TestWriteOpenFileFail checks case where open file fails and does not return a NotExist error +func TestWriteOpenFileFail(t *testing.T) { + _, mockOS, _, done := writeSetup(t) + defer done() + + mockData := []byte("") + mockTaskARN := validTaskARN + mockContainerName := containerName + mockDataDir := dataDir + mockOpenErr := errors.New("does exist") + + gomock.InOrder( + mockOS.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, mockOpenErr), + mockOS.EXPECT().IsNotExist(mockOpenErr).Return(false), + ) + + err := writeToMetadataFile(mockOS, nil, mockData, mockTaskARN, mockContainerName, mockDataDir) + if err == nil { + t.Error("Expected error to be returned") + } + if err.Error() != "does exist" { + t.Error("Got unexpected error: " + err.Error()) + } +} + +// TestWriteFileWrtieFail checks case where we fail to write to file +func TestWriteFileWriteFail(t *testing.T) { + _, mockOS, mockFile, done := writeSetup(t) + defer done() + + mockData := []byte("") + mockTaskARN := validTaskARN + mockContainerName := containerName + mockDataDir := dataDir + + gomock.InOrder( + mockOS.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockFile, nil), + mockFile.EXPECT().Write(mockData).Return(0, errors.New("write fail")), + mockFile.EXPECT().Close(), + ) + + err := writeToMetadataFile(mockOS, nil, mockData, mockTaskARN, mockContainerName, mockDataDir) + if err == nil { + t.Error("Expected error to be returned") + } + if err.Error() != "write fail" { + t.Error("Got unexpected error: " + err.Error()) + } +} diff --git a/agent/engine/default.go b/agent/engine/default.go index 6dbf4a4b00f..20f2d9a54f9 100644 --- a/agent/engine/default.go +++ b/agent/engine/default.go @@ -17,6 +17,7 @@ package engine import ( "github.com/aws/amazon-ecs-agent/agent/config" + "github.com/aws/amazon-ecs-agent/agent/containermetadata" "github.com/aws/amazon-ecs-agent/agent/credentials" "github.com/aws/amazon-ecs-agent/agent/engine/dockerstate" "github.com/aws/amazon-ecs-agent/agent/eventstream" @@ -26,6 +27,6 @@ import ( var log = logger.ForModule("TaskEngine") // NewTaskEngine returns a default TaskEngine -func NewTaskEngine(cfg *config.Config, client DockerClient, credentialsManager credentials.Manager, containerChangeEventStream *eventstream.EventStream, imageManager ImageManager, state dockerstate.TaskEngineState) TaskEngine { - return NewDockerTaskEngine(cfg, client, credentialsManager, containerChangeEventStream, imageManager, state) +func NewTaskEngine(cfg *config.Config, client DockerClient, credentialsManager credentials.Manager, containerChangeEventStream *eventstream.EventStream, imageManager ImageManager, state dockerstate.TaskEngineState, metadataManager containermetadata.Manager) TaskEngine { + return NewDockerTaskEngine(cfg, client, credentialsManager, containerChangeEventStream, imageManager, state, metadataManager) } diff --git a/agent/engine/docker_container_engine.go b/agent/engine/docker_container_engine.go index 4a25e37ef61..47cbf3fb88e 100644 --- a/agent/engine/docker_container_engine.go +++ b/agent/engine/docker_container_engine.go @@ -189,6 +189,7 @@ var scratchCreateLock sync.Mutex // NewDockerGoClient creates a new DockerGoClient func NewDockerGoClient(clientFactory dockerclient.Factory, cfg *config.Config) (DockerClient, error) { client, err := clientFactory.GetDefaultClient() + if err != nil { log.Error("Unable to connect to docker daemon. Ensure docker is running.", "err", err) return nil, err diff --git a/agent/engine/docker_task_engine.go b/agent/engine/docker_task_engine.go index 090f2e1bf90..8ce07345e93 100644 --- a/agent/engine/docker_task_engine.go +++ b/agent/engine/docker_task_engine.go @@ -21,6 +21,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/api" "github.com/aws/amazon-ecs-agent/agent/config" + "github.com/aws/amazon-ecs-agent/agent/containermetadata" "github.com/aws/amazon-ecs-agent/agent/credentials" "github.com/aws/amazon-ecs-agent/agent/ecscni" "github.com/aws/amazon-ecs-agent/agent/engine/dependencygraph" @@ -93,13 +94,14 @@ type DockerTaskEngine struct { _timeOnce sync.Once imageManager ImageManager containerStatusToTransitionFunction map[api.ContainerStatus]transitionApplyFunc + metadataManager containermetadata.Manager } // NewDockerTaskEngine returns a created, but uninitialized, DockerTaskEngine. // The distinction between created and initialized is that when created it may // be serialized/deserialized, but it will not communicate with docker until it // is also initialized. -func NewDockerTaskEngine(cfg *config.Config, client DockerClient, credentialsManager credentials.Manager, containerChangeEventStream *eventstream.EventStream, imageManager ImageManager, state dockerstate.TaskEngineState) *DockerTaskEngine { +func NewDockerTaskEngine(cfg *config.Config, client DockerClient, credentialsManager credentials.Manager, containerChangeEventStream *eventstream.EventStream, imageManager ImageManager, state dockerstate.TaskEngineState, metadataManager containermetadata.Manager) *DockerTaskEngine { dockerTaskEngine := &DockerTaskEngine{ cfg: cfg, client: client, @@ -120,6 +122,8 @@ func NewDockerTaskEngine(cfg *config.Config, client DockerClient, credentialsMan PluginsPath: cfg.CNIPluginsPath, MinSupportedCNIVersion: config.DefaultMinSupportedCNIVersion, }), + + metadataManager: metadataManager, } dockerTaskEngine.initializeContainerStatusToTransitionFunction() @@ -327,6 +331,14 @@ func (engine *DockerTaskEngine) sweepTask(task *api.Task) { seelog.Errorf("Error removing container reference from image state: %v", err) } } + + // Clean metadata directory for task + if engine.cfg.ContainerMetadataEnabled { + err := engine.metadataManager.Clean(task.Arn) + if err != nil { + seelog.Errorf("Clean task metadata failed for task %s: %v", task, err) + } + } engine.saver.Save() } @@ -647,6 +659,15 @@ func (engine *DockerTaskEngine) createContainer(task *api.Task, container *api.C engine.saver.ForceSave() } + // Create metadata directory and file then populate it with common metadata of all containers of this task + // Afterwards add this directory to the container's mounts if file creation was successful + if engine.cfg.ContainerMetadataEnabled && !container.IsInternal { + mderr := engine.metadataManager.Create(config, hostConfig, task.Arn, container.Name) + if mderr != nil { + seelog.Errorf("Create metadata failed for container %s of task %s: %v", container, task, mderr) + } + } + metadata := client.CreateContainer(config, hostConfig, dockerContainerName, createContainerTimeout) if metadata.DockerID != "" { engine.state.AddContainer(&api.DockerContainer{DockerID: metadata.DockerID, DockerName: dockerContainerName, Container: container}, task) @@ -675,7 +696,23 @@ func (engine *DockerTaskEngine) startContainer(task *api.Task, container *api.Co Error: CannotStartContainerError{errors.Errorf("Container not recorded as created")}, } } - return client.StartContainer(dockerContainer.DockerID, startContainerTimeout) + dockerContainerMD := client.StartContainer(dockerContainer.DockerID, startContainerTimeout) + + // Get metadata through container inspection and available task information then write this to the metadata file + // Performs this in the background to avoid delaying container start + // TODO: Add a state to the api.Container for the status of the metadata file (Whether it needs update) and + // add logic to engine state restoration to do a metadata update for containers that are running after the agent was restarted + if dockerContainerMD.Error == nil && engine.cfg.ContainerMetadataEnabled && !container.IsInternal { + go func() { + err := engine.metadataManager.Update(dockerContainer.DockerID, task.Arn, container.Name) + if err != nil { + seelog.Errorf("Update metadata file failed for container %s of task %s: %v", container, task, err) + } else { + seelog.Debugf("Updated metadata file for container %s of task %s", container, task) + } + }() + } + return dockerContainerMD } func (engine *DockerTaskEngine) provisionContainerResources(task *api.Task, container *api.Container) DockerContainerMetadata { diff --git a/agent/engine/docker_task_engine_test.go b/agent/engine/docker_task_engine_test.go index ffe6cf436d3..04ec6be9920 100644 --- a/agent/engine/docker_task_engine_test.go +++ b/agent/engine/docker_task_engine_test.go @@ -26,6 +26,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/api" "github.com/aws/amazon-ecs-agent/agent/config" + "github.com/aws/amazon-ecs-agent/agent/containermetadata/mocks" "github.com/aws/amazon-ecs-agent/agent/credentials" "github.com/aws/amazon-ecs-agent/agent/credentials/mocks" "github.com/aws/amazon-ecs-agent/agent/ecscni/mocks" @@ -55,7 +56,7 @@ const ( var defaultConfig = config.DefaultConfig() -func mocks(t *testing.T, cfg *config.Config) (*gomock.Controller, *MockDockerClient, *mock_ttime.MockTime, TaskEngine, *mock_credentials.MockManager, *MockImageManager) { +func mocks(t *testing.T, cfg *config.Config) (*gomock.Controller, *MockDockerClient, *mock_ttime.MockTime, TaskEngine, *mock_credentials.MockManager, *MockImageManager, *mock_containermetadata.MockManager) { ctrl := gomock.NewController(t) client := NewMockDockerClient(ctrl) mockTime := mock_ttime.NewMockTime(ctrl) @@ -64,9 +65,11 @@ func mocks(t *testing.T, cfg *config.Config) (*gomock.Controller, *MockDockerCli containerChangeEventStream := eventstream.NewEventStream("TESTTASKENGINE", context.Background()) containerChangeEventStream.StartListening() imageManager := NewMockImageManager(ctrl) - taskEngine := NewTaskEngine(cfg, client, credentialsManager, containerChangeEventStream, imageManager, dockerstate.NewTaskEngineState()) + metadataManager := mock_containermetadata.NewMockManager(ctrl) + taskEngine := NewTaskEngine(cfg, client, credentialsManager, containerChangeEventStream, imageManager, dockerstate.NewTaskEngineState(), metadataManager) taskEngine.(*DockerTaskEngine)._time = mockTime - return ctrl, client, mockTime, taskEngine, credentialsManager, imageManager + + return ctrl, client, mockTime, taskEngine, credentialsManager, imageManager, metadataManager } func createDockerEvent(status api.ContainerStatus) DockerContainerChangeEvent { @@ -77,7 +80,7 @@ func createDockerEvent(status api.ContainerStatus) DockerContainerChangeEvent { } func TestBatchContainerHappyPath(t *testing.T) { - ctrl, client, mockTime, taskEngine, credentialsManager, imageManager := mocks(t, &defaultConfig) + ctrl, client, mockTime, taskEngine, credentialsManager, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() roleCredentials := credentials.TaskIAMRoleCredentials{ @@ -163,7 +166,175 @@ func TestBatchContainerHappyPath(t *testing.T) { steadyStateCheckWait.Add(1) taskEngine.AddTask(sleepTask) + event := <-stateChangeEvents + assert.Equal(t, event.(api.ContainerStateChange).Status, api.ContainerRunning, "Expected container to be RUNNING") + + event = <-stateChangeEvents + assert.Equal(t, event.(api.TaskStateChange).Status, api.TaskRunning, "Expected task to be RUNNING") + + select { + case <-stateChangeEvents: + t.Fatal("Should be out of events") + default: + } + + // Wait for container create and start events to be processed + createStartEventsReported.Wait() + // Wait for steady state check to be invoked + steadyStateCheckWait.Wait() + mockTime.EXPECT().After(gomock.Any()).Return(cleanup).AnyTimes() + client.EXPECT().DescribeContainer(gomock.Any()).AnyTimes() + + // Wait for all events to be consumed prior to moving it towards stopped; we + // don't want to race the below with these or we'll end up with the "going + // backwards in state" stop and we haven't 'expect'd for that + + exitCode := 0 + // And then docker reports that sleep died, as sleep is wont to do + eventStream <- DockerContainerChangeEvent{ + Status: api.ContainerStopped, + DockerContainerMetadata: DockerContainerMetadata{ + DockerID: "containerId", + ExitCode: &exitCode, + }, + } + + event = <-stateChangeEvents + assert.Equal(t, event.(api.ContainerStateChange).Status, api.ContainerStopped, "Expected container to be STOPPED") + + // hold on to container event to verify exit code + contEvent := event.(api.ContainerStateChange) + assert.Equal(t, *contEvent.ExitCode, 0, "Exit code should be present") + + event = <-stateChangeEvents + assert.Equal(t, event.(api.TaskStateChange).Status, api.TaskStopped, "Expected task to be STOPPED") + // This ensures that managedTask.waitForStopReported makes progress + sleepTask.SetSentStatus(api.TaskStopped) + + // Extra events should not block forever; duplicate acs and docker events are possible + go func() { eventStream <- createDockerEvent(api.ContainerStopped) }() + go func() { eventStream <- createDockerEvent(api.ContainerStopped) }() + + sleepTaskStop := testdata.LoadTask("sleep5") + sleepTaskStop.SetCredentialsID(credentialsID) + sleepTaskStop.SetDesiredStatus(api.TaskStopped) + taskEngine.AddTask(sleepTaskStop) + // As above, duplicate events should not be a problem + taskEngine.AddTask(sleepTaskStop) + taskEngine.AddTask(sleepTaskStop) + + // Expect a bunch of steady state 'poll' describes when we trigger cleanup + client.EXPECT().RemoveContainer(gomock.Any(), gomock.Any()).Do( + func(removedContainerName string, timeout time.Duration) { + assert.Equal(t, createdContainerName, removedContainerName, "Container name mismatch") + }).Return(nil) + + imageManager.EXPECT().RemoveContainerReferenceFromImageState(gomock.Any()) + // trigger cleanup + cleanup <- time.Now() + go func() { eventStream <- createDockerEvent(api.ContainerStopped) }() + + // Wait for the task to actually be dead; if we just fallthrough immediately, + // the remove might not have happened (expectation failure) + for { + tasks, _ := taskEngine.(*DockerTaskEngine).ListTasks() + if len(tasks) == 0 { + break + } + time.Sleep(5 * time.Millisecond) + } +} + +// TestContainerMetadataEnabledHappyPath checks case when metadata service is enabled and does not have errors +func TestContainerMetadataEnabledHappyPath(t *testing.T) { + metadataConfig := defaultConfig + metadataConfig.ContainerMetadataEnabled = true + ctrl, client, mockTime, taskEngine, credentialsManager, imageManager, metadataManager := mocks(t, &metadataConfig) + defer ctrl.Finish() + roleCredentials := credentials.TaskIAMRoleCredentials{ + IAMRoleCredentials: credentials.IAMRoleCredentials{CredentialsID: "credsid"}, + } + credentialsManager.EXPECT().GetTaskCredentials(credentialsID).Return(roleCredentials, true).AnyTimes() + credentialsManager.EXPECT().RemoveCredentials(credentialsID) + + sleepTask := testdata.LoadTask("sleep5") + sleepTask.SetCredentialsID(credentialsID) + + eventStream := make(chan DockerContainerChangeEvent) + // createStartEventsReported is used to force the test to wait until the container created and started + // events are processed + createStartEventsReported := sync.WaitGroup{} + + client.EXPECT().Version() + client.EXPECT().ContainerEvents(gomock.Any()).Return(eventStream, nil) + var createdContainerName string + for _, container := range sleepTask.Containers { + imageManager.EXPECT().AddAllImageStates(gomock.Any()).AnyTimes() + client.EXPECT().PullImage(container.Image, nil).Return(DockerContainerMetadata{}) + imageManager.EXPECT().RecordContainerReference(container).Return(nil) + imageManager.EXPECT().GetImageStateFromImageName(gomock.Any()).Return(nil) + dockerConfig, err := sleepTask.DockerConfig(container) + if err != nil { + t.Fatal(err) + } + // Container config should get updated with this during PostUnmarshalTask + credentialsEndpointEnvValue := roleCredentials.IAMRoleCredentials.GenerateCredentialsEndpointRelativeURI() + dockerConfig.Env = append(dockerConfig.Env, "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI="+credentialsEndpointEnvValue) + // Container config should get updated with this during CreateContainer + dockerConfig.Labels["com.amazonaws.ecs.task-arn"] = sleepTask.Arn + dockerConfig.Labels["com.amazonaws.ecs.container-name"] = container.Name + dockerConfig.Labels["com.amazonaws.ecs.task-definition-family"] = sleepTask.Family + dockerConfig.Labels["com.amazonaws.ecs.task-definition-version"] = sleepTask.Version + dockerConfig.Labels["com.amazonaws.ecs.cluster"] = "" + metadataManager.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil) + client.EXPECT().CreateContainer(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Do( + func(config *docker.Config, y interface{}, containerName string, z time.Duration) { + + if !reflect.DeepEqual(dockerConfig, config) { + t.Errorf("Mismatch in container config; expected: %v, got: %v", dockerConfig, config) + } + // sleep5 task contains only one container. Just assign + // the containerName to createdContainerName + createdContainerName = containerName + createStartEventsReported.Add(1) + go func() { + eventStream <- createDockerEvent(api.ContainerCreated) + createStartEventsReported.Done() + }() + }).Return(DockerContainerMetadata{DockerID: "containerId"}) + + client.EXPECT().StartContainer("containerId", startContainerTimeout).Do( + func(id string, timeout time.Duration) { + createStartEventsReported.Add(1) + go func() { + eventStream <- createDockerEvent(api.ContainerRunning) + createStartEventsReported.Done() + }() + }).Return(DockerContainerMetadata{DockerID: "containerId"}) + metadataManager.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil) + } + + // steadyStateCheckWait is used to force the test to wait until the steady-state check + // has been invoked at least once + steadyStateCheckWait := sync.WaitGroup{} + steadyStateVerify := make(chan time.Time, 1) + cleanup := make(chan time.Time, 1) + mockTime.EXPECT().Now().Do(func() time.Time { return time.Now() }).AnyTimes() + gomock.InOrder( + mockTime.EXPECT().After(steadyStateTaskVerifyInterval).Do(func(d time.Duration) { + steadyStateCheckWait.Done() + }).Return(steadyStateVerify), + mockTime.EXPECT().After(steadyStateTaskVerifyInterval).Return(steadyStateVerify).AnyTimes(), + ) + + err := taskEngine.Init(context.TODO()) + assert.NoError(t, err) + + stateChangeEvents := taskEngine.StateChangeEvents() + + steadyStateCheckWait.Add(1) + taskEngine.AddTask(sleepTask) event := <-stateChangeEvents assert.Equal(t, event.(api.ContainerStateChange).Status, api.ContainerRunning, "Expected container to be RUNNING") @@ -228,6 +399,177 @@ func TestBatchContainerHappyPath(t *testing.T) { }).Return(nil) imageManager.EXPECT().RemoveContainerReferenceFromImageState(gomock.Any()) + metadataManager.EXPECT().Clean(gomock.Any()).Return(nil) + // trigger cleanup + cleanup <- time.Now() + go func() { eventStream <- createDockerEvent(api.ContainerStopped) }() + + // Wait for the task to actually be dead; if we just fallthrough immediately, + // the remove might not have happened (expectation failure) + for { + tasks, _ := taskEngine.(*DockerTaskEngine).ListTasks() + if len(tasks) == 0 { + break + } + time.Sleep(5 * time.Millisecond) + } +} + +// TestCotnainerMetadataEnabledErrorPath checks case when metadata service is enabled but calls return errors +func TestContainerMetadataEnabledErrorPath(t *testing.T) { + metadataConfig := defaultConfig + metadataConfig.ContainerMetadataEnabled = true + ctrl, client, mockTime, taskEngine, credentialsManager, imageManager, metadataManager := mocks(t, &metadataConfig) + defer ctrl.Finish() + + roleCredentials := credentials.TaskIAMRoleCredentials{ + IAMRoleCredentials: credentials.IAMRoleCredentials{CredentialsID: "credsid"}, + } + credentialsManager.EXPECT().GetTaskCredentials(credentialsID).Return(roleCredentials, true).AnyTimes() + credentialsManager.EXPECT().RemoveCredentials(credentialsID) + + sleepTask := testdata.LoadTask("sleep5") + sleepTask.SetCredentialsID(credentialsID) + + eventStream := make(chan DockerContainerChangeEvent) + // createStartEventsReported is used to force the test to wait until the container created and started + // events are processed + createStartEventsReported := sync.WaitGroup{} + + client.EXPECT().Version() + client.EXPECT().ContainerEvents(gomock.Any()).Return(eventStream, nil) + var createdContainerName string + for _, container := range sleepTask.Containers { + imageManager.EXPECT().AddAllImageStates(gomock.Any()).AnyTimes() + client.EXPECT().PullImage(container.Image, nil).Return(DockerContainerMetadata{}) + imageManager.EXPECT().RecordContainerReference(container).Return(nil) + imageManager.EXPECT().GetImageStateFromImageName(gomock.Any()).Return(nil) + dockerConfig, err := sleepTask.DockerConfig(container) + if err != nil { + t.Fatal(err) + } + // Container config should get updated with this during PostUnmarshalTask + credentialsEndpointEnvValue := roleCredentials.IAMRoleCredentials.GenerateCredentialsEndpointRelativeURI() + dockerConfig.Env = append(dockerConfig.Env, "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI="+credentialsEndpointEnvValue) + // Container config should get updated with this during CreateContainer + dockerConfig.Labels["com.amazonaws.ecs.task-arn"] = sleepTask.Arn + dockerConfig.Labels["com.amazonaws.ecs.container-name"] = container.Name + dockerConfig.Labels["com.amazonaws.ecs.task-definition-family"] = sleepTask.Family + dockerConfig.Labels["com.amazonaws.ecs.task-definition-version"] = sleepTask.Version + dockerConfig.Labels["com.amazonaws.ecs.cluster"] = "" + metadataManager.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New("create metadata error")) + client.EXPECT().CreateContainer(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Do( + func(config *docker.Config, y interface{}, containerName string, z time.Duration) { + + if !reflect.DeepEqual(dockerConfig, config) { + t.Errorf("Mismatch in container config; expected: %v, got: %v", dockerConfig, config) + } + // sleep5 task contains only one container. Just assign + // the containerName to createdContainerName + createdContainerName = containerName + createStartEventsReported.Add(1) + go func() { + eventStream <- createDockerEvent(api.ContainerCreated) + createStartEventsReported.Done() + }() + }).Return(DockerContainerMetadata{DockerID: "containerId"}) + + client.EXPECT().StartContainer("containerId", startContainerTimeout).Do( + func(id string, timeout time.Duration) { + createStartEventsReported.Add(1) + go func() { + eventStream <- createDockerEvent(api.ContainerRunning) + createStartEventsReported.Done() + }() + }).Return(DockerContainerMetadata{DockerID: "containerId"}) + metadataManager.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New("update metadata error")) + } + + // steadyStateCheckWait is used to force the test to wait until the steady-state check + // has been invoked at least once + steadyStateCheckWait := sync.WaitGroup{} + steadyStateVerify := make(chan time.Time, 1) + cleanup := make(chan time.Time, 1) + mockTime.EXPECT().Now().Do(func() time.Time { return time.Now() }).AnyTimes() + gomock.InOrder( + mockTime.EXPECT().After(steadyStateTaskVerifyInterval).Do(func(d time.Duration) { + steadyStateCheckWait.Done() + }).Return(steadyStateVerify), + mockTime.EXPECT().After(steadyStateTaskVerifyInterval).Return(steadyStateVerify).AnyTimes(), + ) + + err := taskEngine.Init(context.TODO()) + assert.NoError(t, err) + + stateChangeEvents := taskEngine.StateChangeEvents() + + steadyStateCheckWait.Add(1) + taskEngine.AddTask(sleepTask) + event := <-stateChangeEvents + assert.Equal(t, event.(api.ContainerStateChange).Status, api.ContainerRunning, "Expected container to be RUNNING") + + event = <-stateChangeEvents + assert.Equal(t, event.(api.TaskStateChange).Status, api.TaskRunning, "Expected task to be RUNNING") + + select { + case <-stateChangeEvents: + t.Fatal("Should be out of events") + default: + } + + // Wait for container create and start events to be processed + createStartEventsReported.Wait() + // Wait for steady state check to be invoked + steadyStateCheckWait.Wait() + mockTime.EXPECT().After(gomock.Any()).Return(cleanup).AnyTimes() + client.EXPECT().DescribeContainer(gomock.Any()).AnyTimes() + + // Wait for all events to be consumed prior to moving it towards stopped; we + // don't want to race the below with these or we'll end up with the "going + // backwards in state" stop and we haven't 'expect'd for that + + exitCode := 0 + // And then docker reports that sleep died, as sleep is wont to do + eventStream <- DockerContainerChangeEvent{ + Status: api.ContainerStopped, + DockerContainerMetadata: DockerContainerMetadata{ + DockerID: "containerId", + ExitCode: &exitCode, + }, + } + + event = <-stateChangeEvents + assert.Equal(t, event.(api.ContainerStateChange).Status, api.ContainerStopped, "Expected container to be STOPPED") + + // hold on to container event to verify exit code + contEvent := event.(api.ContainerStateChange) + assert.Equal(t, *contEvent.ExitCode, 0, "Exit code should be present") + + event = <-stateChangeEvents + assert.Equal(t, event.(api.TaskStateChange).Status, api.TaskStopped, "Expected task to be STOPPED") + // This ensures that managedTask.waitForStopReported makes progress + sleepTask.SetSentStatus(api.TaskStopped) + + // Extra events should not block forever; duplicate acs and docker events are possible + go func() { eventStream <- createDockerEvent(api.ContainerStopped) }() + go func() { eventStream <- createDockerEvent(api.ContainerStopped) }() + + sleepTaskStop := testdata.LoadTask("sleep5") + sleepTaskStop.SetCredentialsID(credentialsID) + sleepTaskStop.SetDesiredStatus(api.TaskStopped) + taskEngine.AddTask(sleepTaskStop) + // As above, duplicate events should not be a problem + taskEngine.AddTask(sleepTaskStop) + taskEngine.AddTask(sleepTaskStop) + + // Expect a bunch of steady state 'poll' describes when we trigger cleanup + client.EXPECT().RemoveContainer(gomock.Any(), gomock.Any()).Do( + func(removedContainerName string, timeout time.Duration) { + assert.Equal(t, createdContainerName, removedContainerName, "Container name mismatch") + }).Return(nil) + + imageManager.EXPECT().RemoveContainerReferenceFromImageState(gomock.Any()) + metadataManager.EXPECT().Clean(gomock.Any()).Return(errors.New("clean metadata error")) // trigger cleanup cleanup <- time.Now() go func() { eventStream <- createDockerEvent(api.ContainerStopped) }() @@ -427,7 +769,7 @@ func TestTaskWithSteadyStateResourcesProvisioned(t *testing.T) { // cleaned up. This test ensures that there's no regression in the task engine and ensures // there's no deadlock as seen in #313 func TestRemoveEvents(t *testing.T) { - ctrl, client, mockTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, mockTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() sleepTask := testdata.LoadTask("sleep5") @@ -563,7 +905,7 @@ func TestRemoveEvents(t *testing.T) { } func TestStartTimeoutThenStart(t *testing.T) { - ctrl, client, testTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, testTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() sleepTask := testdata.LoadTask("sleep5") @@ -641,7 +983,7 @@ func TestStartTimeoutThenStart(t *testing.T) { } func TestSteadyStatePoll(t *testing.T) { - ctrl, client, testTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, testTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() wait := &sync.WaitGroup{} @@ -770,7 +1112,7 @@ func TestSteadyStatePoll(t *testing.T) { } func TestStopWithPendingStops(t *testing.T) { - ctrl, client, testTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, testTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() testTime.EXPECT().Now().AnyTimes() testTime.EXPECT().After(gomock.Any()).AnyTimes() @@ -824,7 +1166,7 @@ func TestStopWithPendingStops(t *testing.T) { } func TestCreateContainerForceSave(t *testing.T) { - ctrl, client, _, privateTaskEngine, _, _ := mocks(t, &config.Config{}) + ctrl, client, _, privateTaskEngine, _, _, _ := mocks(t, &config.Config{}) saver := mock_statemanager.NewMockStateManager(ctrl) defer ctrl.Finish() taskEngine, _ := privateTaskEngine.(*DockerTaskEngine) @@ -852,7 +1194,7 @@ func TestCreateContainerForceSave(t *testing.T) { } func TestCreateContainerMergesLabels(t *testing.T) { - ctrl, client, _, taskEngine, _, _ := mocks(t, &defaultConfig) + ctrl, client, _, taskEngine, _, _, _ := mocks(t, &defaultConfig) defer ctrl.Finish() testTask := &api.Task{ @@ -888,7 +1230,7 @@ func TestCreateContainerMergesLabels(t *testing.T) { // only when terminal events are recieved from docker event stream when // StopContainer times out func TestTaskTransitionWhenStopContainerTimesout(t *testing.T) { - ctrl, client, mockTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, mockTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() sleepTask := testdata.LoadTask("sleep5") @@ -1005,7 +1347,7 @@ func TestTaskTransitionWhenStopContainerTimesout(t *testing.T) { // stop container call returns an unretriable error from docker, specifically the // ContainerNotRunning error func TestTaskTransitionWhenStopContainerReturnsUnretriableError(t *testing.T) { - ctrl, client, mockTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, mockTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() sleepTask := testdata.LoadTask("sleep5") @@ -1097,7 +1439,7 @@ func TestTaskTransitionWhenStopContainerReturnsUnretriableError(t *testing.T) { // transitions to stopped only after receiving the container stopped event from docker when // the initial stop container call fails with an unknown error. func TestTaskTransitionWhenStopContainerReturnsTransientErrorBeforeSucceeding(t *testing.T) { - ctrl, client, mockTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, mockTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() sleepTask := testdata.LoadTask("sleep5") @@ -1176,7 +1518,7 @@ func TestGetTaskByArn(t *testing.T) { // Need a mock client as AddTask not only adds a task to the engine, but // also causes the engine to progress the task. - ctrl, client, _, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, _, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() client.EXPECT().Version() @@ -1205,7 +1547,7 @@ func TestGetTaskByArn(t *testing.T) { } func TestEngineEnableConcurrentPull(t *testing.T) { - ctrl, client, _, taskEngine, _, _ := mocks(t, &defaultConfig) + ctrl, client, _, taskEngine, _, _, _ := mocks(t, &defaultConfig) defer ctrl.Finish() client.EXPECT().Version().Return("1.11.1", nil) @@ -1222,7 +1564,7 @@ func TestEngineEnableConcurrentPull(t *testing.T) { } func TestEngineDisableConcurrentPull(t *testing.T) { - ctrl, client, _, taskEngine, _, _ := mocks(t, &defaultConfig) + ctrl, client, _, taskEngine, _, _, _ := mocks(t, &defaultConfig) defer ctrl.Finish() client.EXPECT().Version().Return("1.11.0", nil) @@ -1469,7 +1811,7 @@ func TestStopPauseContainerCleanupCalled(t *testing.T) { // TestTaskWithCircularDependency tests the task with containers of which the // dependencies can't be resolved func TestTaskWithCircularDependency(t *testing.T) { - ctrl, client, _, taskEngine, _, _ := mocks(t, &defaultConfig) + ctrl, client, _, taskEngine, _, _, _ := mocks(t, &defaultConfig) defer ctrl.Finish() client.EXPECT().Version().Return("1.12.6", nil) diff --git a/agent/engine/engine_integ_test.go b/agent/engine/engine_integ_test.go index 951a1a102a1..bb6919cae1c 100644 --- a/agent/engine/engine_integ_test.go +++ b/agent/engine/engine_integ_test.go @@ -24,6 +24,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/api" "github.com/aws/amazon-ecs-agent/agent/config" + "github.com/aws/amazon-ecs-agent/agent/containermetadata" "github.com/aws/amazon-ecs-agent/agent/credentials" "github.com/aws/amazon-ecs-agent/agent/ec2" "github.com/aws/amazon-ecs-agent/agent/engine/dockerclient" @@ -81,8 +82,10 @@ func setup(cfg *config.Config, t *testing.T) (TaskEngine, func(), credentials.Ma state := dockerstate.NewTaskEngineState() imageManager := NewImageManager(cfg, dockerClient, state) imageManager.SetSaver(statemanager.NewNoopStateManager()) + metadataManager := containermetadata.NewManager(dockerClient, cfg) + taskEngine := NewDockerTaskEngine(cfg, dockerClient, credentialsManager, - eventstream.NewEventStream("ENGINEINTEGTEST", context.Background()), imageManager, state) + eventstream.NewEventStream("ENGINEINTEGTEST", context.Background()), imageManager, state, metadataManager) taskEngine.Init(context.TODO()) return taskEngine, func() { taskEngine.Shutdown() diff --git a/agent/engine/engine_mocks.go b/agent/engine/engine_mocks.go index 5782d846dcb..b354a5c1f68 100644 --- a/agent/engine/engine_mocks.go +++ b/agent/engine/engine_mocks.go @@ -11,7 +11,7 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/engine (interfaces: TaskEngine,DockerClient,ImageManager) package engine @@ -31,45 +31,64 @@ import ( context0 "golang.org/x/net/context" ) -// Mock of TaskEngine interface +// MockTaskEngine is a mock of TaskEngine interface type MockTaskEngine struct { ctrl *gomock.Controller - recorder *_MockTaskEngineRecorder + recorder *MockTaskEngineMockRecorder } -// Recorder for MockTaskEngine (not exported) -type _MockTaskEngineRecorder struct { +// MockTaskEngineMockRecorder is the mock recorder for MockTaskEngine +type MockTaskEngineMockRecorder struct { mock *MockTaskEngine } +// NewMockTaskEngine creates a new mock instance func NewMockTaskEngine(ctrl *gomock.Controller) *MockTaskEngine { mock := &MockTaskEngine{ctrl: ctrl} - mock.recorder = &_MockTaskEngineRecorder{mock} + mock.recorder = &MockTaskEngineMockRecorder{mock} return mock } -func (_m *MockTaskEngine) EXPECT() *_MockTaskEngineRecorder { +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockTaskEngine) EXPECT() *MockTaskEngineMockRecorder { return _m.recorder } +// AddTask mocks base method func (_m *MockTaskEngine) AddTask(_param0 *api.Task) error { ret := _m.ctrl.Call(_m, "AddTask", _param0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTaskEngineRecorder) AddTask(arg0 interface{}) *gomock.Call { +// AddTask indicates an expected call of AddTask +func (_mr *MockTaskEngineMockRecorder) AddTask(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTask", arg0) } +// Capabilities mocks base method +func (_m *MockTaskEngine) Capabilities() []string { + ret := _m.ctrl.Call(_m, "Capabilities") + ret0, _ := ret[0].([]string) + return ret0 +} + +// Capabilities indicates an expected call of Capabilities +func (_mr *MockTaskEngineMockRecorder) Capabilities() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Capabilities") +} + +// Disable mocks base method func (_m *MockTaskEngine) Disable() { _m.ctrl.Call(_m, "Disable") } -func (_mr *_MockTaskEngineRecorder) Disable() *gomock.Call { +// Disable indicates an expected call of Disable +func (_mr *MockTaskEngineMockRecorder) Disable() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Disable") } +// GetTaskByArn mocks base method func (_m *MockTaskEngine) GetTaskByArn(_param0 string) (*api.Task, bool) { ret := _m.ctrl.Call(_m, "GetTaskByArn", _param0) ret0, _ := ret[0].(*api.Task) @@ -77,7 +96,8 @@ func (_m *MockTaskEngine) GetTaskByArn(_param0 string) (*api.Task, bool) { return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { +// GetTaskByArn indicates an expected call of GetTaskByArn +func (_mr *MockTaskEngineMockRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTaskByArn", arg0) } @@ -87,10 +107,12 @@ func (_m *MockTaskEngine) Init(_param0 context0.Context) error { return ret0 } -func (_mr *_MockTaskEngineRecorder) Init(arg0 interface{}) *gomock.Call { +// Init indicates an expected call of Init +func (_mr *MockTaskEngineMockRecorder) Init(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Init", arg0) } +// ListTasks mocks base method func (_m *MockTaskEngine) ListTasks() ([]*api.Task, error) { ret := _m.ctrl.Call(_m, "ListTasks") ret0, _ := ret[0].([]*api.Task) @@ -98,10 +120,12 @@ func (_m *MockTaskEngine) ListTasks() ([]*api.Task, error) { return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) ListTasks() *gomock.Call { +// ListTasks indicates an expected call of ListTasks +func (_mr *MockTaskEngineMockRecorder) ListTasks() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTasks") } +// MarshalJSON mocks base method func (_m *MockTaskEngine) MarshalJSON() ([]byte, error) { ret := _m.ctrl.Call(_m, "MarshalJSON") ret0, _ := ret[0].([]byte) @@ -109,7 +133,8 @@ func (_m *MockTaskEngine) MarshalJSON() ([]byte, error) { return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) MarshalJSON() *gomock.Call { +// MarshalJSON indicates an expected call of MarshalJSON +func (_mr *MockTaskEngineMockRecorder) MarshalJSON() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "MarshalJSON") } @@ -117,38 +142,46 @@ func (_m *MockTaskEngine) MustInit(_param0 context0.Context) { _m.ctrl.Call(_m, "MustInit", _param0) } -func (_mr *_MockTaskEngineRecorder) MustInit(arg0 interface{}) *gomock.Call { +// MustInit indicates an expected call of MustInit +func (_mr *MockTaskEngineMockRecorder) MustInit(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "MustInit", arg0) } +// SetSaver mocks base method func (_m *MockTaskEngine) SetSaver(_param0 statemanager.Saver) { _m.ctrl.Call(_m, "SetSaver", _param0) } -func (_mr *_MockTaskEngineRecorder) SetSaver(arg0 interface{}) *gomock.Call { +// SetSaver indicates an expected call of SetSaver +func (_mr *MockTaskEngineMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) } +// StateChangeEvents mocks base method func (_m *MockTaskEngine) StateChangeEvents() chan statechange.Event { ret := _m.ctrl.Call(_m, "StateChangeEvents") ret0, _ := ret[0].(chan statechange.Event) return ret0 } -func (_mr *_MockTaskEngineRecorder) StateChangeEvents() *gomock.Call { +// StateChangeEvents indicates an expected call of StateChangeEvents +func (_mr *MockTaskEngineMockRecorder) StateChangeEvents() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StateChangeEvents") } +// UnmarshalJSON mocks base method func (_m *MockTaskEngine) UnmarshalJSON(_param0 []byte) error { ret := _m.ctrl.Call(_m, "UnmarshalJSON", _param0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTaskEngineRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { +// UnmarshalJSON indicates an expected call of UnmarshalJSON +func (_mr *MockTaskEngineMockRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "UnmarshalJSON", arg0) } +// Version mocks base method func (_m *MockTaskEngine) Version() (string, error) { ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(string) @@ -156,28 +189,31 @@ func (_m *MockTaskEngine) Version() (string, error) { return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) Version() *gomock.Call { +// Version indicates an expected call of Version +func (_mr *MockTaskEngineMockRecorder) Version() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } -// Mock of DockerClient interface +// MockDockerClient is a mock of DockerClient interface type MockDockerClient struct { ctrl *gomock.Controller - recorder *_MockDockerClientRecorder + recorder *MockDockerClientMockRecorder } -// Recorder for MockDockerClient (not exported) -type _MockDockerClientRecorder struct { +// MockDockerClientMockRecorder is the mock recorder for MockDockerClient +type MockDockerClientMockRecorder struct { mock *MockDockerClient } +// NewMockDockerClient creates a new mock instance func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient { mock := &MockDockerClient{ctrl: ctrl} - mock.recorder = &_MockDockerClientRecorder{mock} + mock.recorder = &MockDockerClientMockRecorder{mock} return mock } -func (_m *MockDockerClient) EXPECT() *_MockDockerClientRecorder { +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockDockerClient) EXPECT() *MockDockerClientMockRecorder { return _m.recorder } @@ -188,20 +224,24 @@ func (_m *MockDockerClient) ContainerEvents(_param0 context.Context) (<-chan Doc return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { +// ContainerEvents indicates an expected call of ContainerEvents +func (_mr *MockDockerClientMockRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerEvents", arg0) } +// CreateContainer mocks base method func (_m *MockDockerClient) CreateContainer(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 time.Duration) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "CreateContainer", _param0, _param1, _param2, _param3) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +// CreateContainer indicates an expected call of CreateContainer +func (_mr *MockDockerClientMockRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateContainer", arg0, arg1, arg2, arg3) } +// DescribeContainer mocks base method func (_m *MockDockerClient) DescribeContainer(_param0 string) (api.ContainerStatus, DockerContainerMetadata) { ret := _m.ctrl.Call(_m, "DescribeContainer", _param0) ret0, _ := ret[0].(api.ContainerStatus) @@ -209,7 +249,8 @@ func (_m *MockDockerClient) DescribeContainer(_param0 string) (api.ContainerStat return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { +// DescribeContainer indicates an expected call of DescribeContainer +func (_mr *MockDockerClientMockRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeContainer", arg0) } @@ -230,10 +271,12 @@ func (_m *MockDockerClient) InspectContainer(_param0 string, _param1 time.Durati return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { +// InspectContainer indicates an expected call of InspectContainer +func (_mr *MockDockerClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) } +// InspectImage mocks base method func (_m *MockDockerClient) InspectImage(_param0 string) (*go_dockerclient.Image, error) { ret := _m.ctrl.Call(_m, "InspectImage", _param0) ret0, _ := ret[0].(*go_dockerclient.Image) @@ -241,27 +284,32 @@ func (_m *MockDockerClient) InspectImage(_param0 string) (*go_dockerclient.Image return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) InspectImage(arg0 interface{}) *gomock.Call { +// InspectImage indicates an expected call of InspectImage +func (_mr *MockDockerClientMockRecorder) InspectImage(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectImage", arg0) } +// KnownVersions mocks base method func (_m *MockDockerClient) KnownVersions() []dockerclient.DockerVersion { ret := _m.ctrl.Call(_m, "KnownVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -func (_mr *_MockDockerClientRecorder) KnownVersions() *gomock.Call { +// KnownVersions indicates an expected call of KnownVersions +func (_mr *MockDockerClientMockRecorder) KnownVersions() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "KnownVersions") } +// ListContainers mocks base method func (_m *MockDockerClient) ListContainers(_param0 bool, _param1 time.Duration) ListContainersResponse { ret := _m.ctrl.Call(_m, "ListContainers", _param0, _param1) ret0, _ := ret[0].(ListContainersResponse) return ret0 } -func (_mr *_MockDockerClientRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { +// ListContainers indicates an expected call of ListContainers +func (_mr *MockDockerClientMockRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "ListContainers", arg0, arg1) } @@ -275,43 +323,51 @@ func (_mr *_MockDockerClientRecorder) LoadImage(arg0, arg1 interface{}) *gomock. return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0, arg1) } +// PullImage mocks base method func (_m *MockDockerClient) PullImage(_param0 string, _param1 *api.RegistryAuthenticationData) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "PullImage", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { +// PullImage indicates an expected call of PullImage +func (_mr *MockDockerClientMockRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "PullImage", arg0, arg1) } +// RemoveContainer mocks base method func (_m *MockDockerClient) RemoveContainer(_param0 string, _param1 time.Duration) error { ret := _m.ctrl.Call(_m, "RemoveContainer", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockDockerClientRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { +// RemoveContainer indicates an expected call of RemoveContainer +func (_mr *MockDockerClientMockRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainer", arg0, arg1) } +// RemoveImage mocks base method func (_m *MockDockerClient) RemoveImage(_param0 string, _param1 time.Duration) error { ret := _m.ctrl.Call(_m, "RemoveImage", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockDockerClientRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { +// RemoveImage indicates an expected call of RemoveImage +func (_mr *MockDockerClientMockRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImage", arg0, arg1) } +// StartContainer mocks base method func (_m *MockDockerClient) StartContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "StartContainer", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { +// StartContainer indicates an expected call of StartContainer +func (_mr *MockDockerClientMockRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainer", arg0, arg1) } @@ -322,30 +378,36 @@ func (_m *MockDockerClient) Stats(_param0 string, _param1 context.Context) (<-ch return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { +// Stats indicates an expected call of Stats +func (_mr *MockDockerClientMockRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Stats", arg0, arg1) } +// StopContainer mocks base method func (_m *MockDockerClient) StopContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "StopContainer", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { +// StopContainer indicates an expected call of StopContainer +func (_mr *MockDockerClientMockRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainer", arg0, arg1) } +// SupportedVersions mocks base method func (_m *MockDockerClient) SupportedVersions() []dockerclient.DockerVersion { ret := _m.ctrl.Call(_m, "SupportedVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -func (_mr *_MockDockerClientRecorder) SupportedVersions() *gomock.Call { +// SupportedVersions indicates an expected call of SupportedVersions +func (_mr *MockDockerClientMockRecorder) SupportedVersions() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "SupportedVersions") } +// Version mocks base method func (_m *MockDockerClient) Version() (string, error) { ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(string) @@ -353,84 +415,99 @@ func (_m *MockDockerClient) Version() (string, error) { return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) Version() *gomock.Call { +// Version indicates an expected call of Version +func (_mr *MockDockerClientMockRecorder) Version() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } +// WithVersion mocks base method func (_m *MockDockerClient) WithVersion(_param0 dockerclient.DockerVersion) DockerClient { ret := _m.ctrl.Call(_m, "WithVersion", _param0) ret0, _ := ret[0].(DockerClient) return ret0 } -func (_mr *_MockDockerClientRecorder) WithVersion(arg0 interface{}) *gomock.Call { +// WithVersion indicates an expected call of WithVersion +func (_mr *MockDockerClientMockRecorder) WithVersion(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "WithVersion", arg0) } -// Mock of ImageManager interface +// MockImageManager is a mock of ImageManager interface type MockImageManager struct { ctrl *gomock.Controller - recorder *_MockImageManagerRecorder + recorder *MockImageManagerMockRecorder } -// Recorder for MockImageManager (not exported) -type _MockImageManagerRecorder struct { +// MockImageManagerMockRecorder is the mock recorder for MockImageManager +type MockImageManagerMockRecorder struct { mock *MockImageManager } +// NewMockImageManager creates a new mock instance func NewMockImageManager(ctrl *gomock.Controller) *MockImageManager { mock := &MockImageManager{ctrl: ctrl} - mock.recorder = &_MockImageManagerRecorder{mock} + mock.recorder = &MockImageManagerMockRecorder{mock} return mock } -func (_m *MockImageManager) EXPECT() *_MockImageManagerRecorder { +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockImageManager) EXPECT() *MockImageManagerMockRecorder { return _m.recorder } +// AddAllImageStates mocks base method func (_m *MockImageManager) AddAllImageStates(_param0 []*image.ImageState) { _m.ctrl.Call(_m, "AddAllImageStates", _param0) } -func (_mr *_MockImageManagerRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { +// AddAllImageStates indicates an expected call of AddAllImageStates +func (_mr *MockImageManagerMockRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "AddAllImageStates", arg0) } +// GetImageStateFromImageName mocks base method func (_m *MockImageManager) GetImageStateFromImageName(_param0 string) *image.ImageState { ret := _m.ctrl.Call(_m, "GetImageStateFromImageName", _param0) ret0, _ := ret[0].(*image.ImageState) return ret0 } -func (_mr *_MockImageManagerRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { +// GetImageStateFromImageName indicates an expected call of GetImageStateFromImageName +func (_mr *MockImageManagerMockRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "GetImageStateFromImageName", arg0) } +// RecordContainerReference mocks base method func (_m *MockImageManager) RecordContainerReference(_param0 *api.Container) error { ret := _m.ctrl.Call(_m, "RecordContainerReference", _param0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockImageManagerRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { +// RecordContainerReference indicates an expected call of RecordContainerReference +func (_mr *MockImageManagerMockRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RecordContainerReference", arg0) } +// RemoveContainerReferenceFromImageState mocks base method func (_m *MockImageManager) RemoveContainerReferenceFromImageState(_param0 *api.Container) error { ret := _m.ctrl.Call(_m, "RemoveContainerReferenceFromImageState", _param0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockImageManagerRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { +// RemoveContainerReferenceFromImageState indicates an expected call of RemoveContainerReferenceFromImageState +func (_mr *MockImageManagerMockRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainerReferenceFromImageState", arg0) } +// SetSaver mocks base method func (_m *MockImageManager) SetSaver(_param0 statemanager.Saver) { _m.ctrl.Call(_m, "SetSaver", _param0) } -func (_mr *_MockImageManagerRecorder) SetSaver(arg0 interface{}) *gomock.Call { +// SetSaver indicates an expected call of SetSaver +func (_mr *MockImageManagerMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) } @@ -438,6 +515,7 @@ func (_m *MockImageManager) StartImageCleanupProcess(_param0 context0.Context) { _m.ctrl.Call(_m, "StartImageCleanupProcess", _param0) } -func (_mr *_MockImageManagerRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { +// StartImageCleanupProcess indicates an expected call of StartImageCleanupProcess +func (_mr *MockImageManagerMockRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StartImageCleanupProcess", arg0) } diff --git a/agent/engine/task_manager_test.go b/agent/engine/task_manager_test.go index f4950e2ef69..80d1bb35cdb 100644 --- a/agent/engine/task_manager_test.go +++ b/agent/engine/task_manager_test.go @@ -22,6 +22,7 @@ import ( "time" "github.com/aws/amazon-ecs-agent/agent/api" + "github.com/aws/amazon-ecs-agent/agent/config" "github.com/aws/amazon-ecs-agent/agent/engine/dockerstate/mocks" "github.com/aws/amazon-ecs-agent/agent/engine/testdata" "github.com/aws/amazon-ecs-agent/agent/eventstream" @@ -803,6 +804,7 @@ func TestHandleStoppedToSteadyStateTransition(t *testing.T) { } func TestCleanupTask(t *testing.T) { + cfg := config.DefaultConfig() ctrl := gomock.NewController(t) mockTime := mock_ttime.NewMockTime(ctrl) mockState := mock_dockerstate.NewMockTaskEngineState(ctrl) @@ -811,6 +813,7 @@ func TestCleanupTask(t *testing.T) { defer ctrl.Finish() taskEngine := &DockerTaskEngine{ + cfg: &cfg, saver: statemanager.NewNoopStateManager(), state: mockState, client: mockClient, @@ -849,6 +852,7 @@ func TestCleanupTask(t *testing.T) { } func TestCleanupTaskWaitsForStoppedSent(t *testing.T) { + cfg := config.DefaultConfig() ctrl := gomock.NewController(t) mockTime := mock_ttime.NewMockTime(ctrl) mockState := mock_dockerstate.NewMockTaskEngineState(ctrl) @@ -857,6 +861,7 @@ func TestCleanupTaskWaitsForStoppedSent(t *testing.T) { defer ctrl.Finish() taskEngine := &DockerTaskEngine{ + cfg: &cfg, saver: statemanager.NewNoopStateManager(), state: mockState, client: mockClient, diff --git a/agent/statemanager/state_manager_test.go b/agent/statemanager/state_manager_test.go index 69b94fb2898..4ddf5643fc2 100644 --- a/agent/statemanager/state_manager_test.go +++ b/agent/statemanager/state_manager_test.go @@ -38,7 +38,7 @@ func TestLoadsV1DataCorrectly(t *testing.T) { defer cleanup() cfg := &config.Config{DataDir: filepath.Join(".", "testdata", "v1", "1")} - taskEngine := engine.NewTaskEngine(&config.Config{}, nil, nil, nil, nil, dockerstate.NewTaskEngineState()) + taskEngine := engine.NewTaskEngine(&config.Config{}, nil, nil, nil, nil, dockerstate.NewTaskEngineState(), nil) var containerInstanceArn, cluster, savedInstanceID string var sequenceNumber int64 diff --git a/agent/statemanager/state_manager_unix_test.go b/agent/statemanager/state_manager_unix_test.go index 13f1be2eac1..ab5e4210558 100644 --- a/agent/statemanager/state_manager_unix_test.go +++ b/agent/statemanager/state_manager_unix_test.go @@ -43,7 +43,7 @@ func TestStateManager(t *testing.T) { // Now let's make some state to save containerInstanceArn := "" - taskEngine := engine.NewTaskEngine(&config.Config{}, nil, nil, nil, nil, dockerstate.NewTaskEngineState()) + taskEngine := engine.NewTaskEngine(&config.Config{}, nil, nil, nil, nil, dockerstate.NewTaskEngineState(), nil) manager, err = statemanager.NewStateManager(cfg, statemanager.AddSaveable("TaskEngine", taskEngine), statemanager.AddSaveable("ContainerInstanceArn", &containerInstanceArn)) require.Nil(t, err) @@ -59,7 +59,7 @@ func TestStateManager(t *testing.T) { assertFileMode(t, filepath.Join(tmpDir, "ecs_agent_data.json")) // Now make sure we can load that state sanely - loadedTaskEngine := engine.NewTaskEngine(&config.Config{}, nil, nil, nil, nil, dockerstate.NewTaskEngineState()) + loadedTaskEngine := engine.NewTaskEngine(&config.Config{}, nil, nil, nil, nil, dockerstate.NewTaskEngineState(), nil) var loadedContainerInstanceArn string manager, err = statemanager.NewStateManager(cfg, statemanager.AddSaveable("TaskEngine", &loadedTaskEngine), statemanager.AddSaveable("ContainerInstanceArn", &loadedContainerInstanceArn)) diff --git a/agent/stats/engine_integ_test.go b/agent/stats/engine_integ_test.go index abd64212d04..513f45f2ab3 100644 --- a/agent/stats/engine_integ_test.go +++ b/agent/stats/engine_integ_test.go @@ -242,7 +242,7 @@ func TestStatsEngineWithNewContainers(t *testing.T) { func TestStatsEngineWithDockerTaskEngine(t *testing.T) { containerChangeEventStream := eventStream("TestStatsEngineWithDockerTaskEngine") - taskEngine := ecsengine.NewTaskEngine(&config.Config{}, nil, nil, containerChangeEventStream, nil, dockerstate.NewTaskEngineState()) + taskEngine := ecsengine.NewTaskEngine(&config.Config{}, nil, nil, containerChangeEventStream, nil, dockerstate.NewTaskEngineState(), nil) container, err := createGremlin(client) if err != nil { t.Fatalf("Error creating container: %v", err) @@ -370,7 +370,7 @@ func TestStatsEngineWithDockerTaskEngine(t *testing.T) { func TestStatsEngineWithDockerTaskEngineMissingRemoveEvent(t *testing.T) { containerChangeEventStream := eventStream("TestStatsEngineWithDockerTaskEngineMissingRemoveEvent") - taskEngine := ecsengine.NewTaskEngine(&config.Config{}, nil, nil, containerChangeEventStream, nil, dockerstate.NewTaskEngineState()) + taskEngine := ecsengine.NewTaskEngine(&config.Config{}, nil, nil, containerChangeEventStream, nil, dockerstate.NewTaskEngineState(), nil) container, err := createGremlin(client) if err != nil { diff --git a/agent/utils/ioutilwrapper/generate_mocks.go b/agent/utils/ioutilwrapper/generate_mocks.go new file mode 100644 index 00000000000..c63890a99cc --- /dev/null +++ b/agent/utils/ioutilwrapper/generate_mocks.go @@ -0,0 +1,16 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package ioutilwrapper + +//go:generate go run ../../../scripts/generate/mockgen.go github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper IOUtil mocks/ioutilwrapper_mocks.go diff --git a/agent/utils/ioutilwrapper/ioutil.go b/agent/utils/ioutilwrapper/ioutil.go new file mode 100644 index 00000000000..322864ec159 --- /dev/null +++ b/agent/utils/ioutilwrapper/ioutil.go @@ -0,0 +1,37 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package ioutilwrapper + +import ( + "io/ioutil" + + "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" +) + +// IOUtil wraps 'io/util' methods for testing +type IOUtil interface { + TempFile(string, string) (oswrapper.File, error) +} + +type ioUtil struct { +} + +// NewIOUtil creates a new IOUtil object +func NewIOUtil() IOUtil { + return &ioUtil{} +} + +func (*ioUtil) TempFile(dir string, prefix string) (oswrapper.File, error) { + return ioutil.TempFile(dir, prefix) +} diff --git a/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go new file mode 100644 index 00000000000..91291253e29 --- /dev/null +++ b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go @@ -0,0 +1,58 @@ +// Copyright 2015-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper (interfaces: IOUtil) + +package mock_ioutilwrapper + +import ( + oswrapper "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" + gomock "github.com/golang/mock/gomock" +) + +// MockIOUtil is a mock of IOUtil interface +type MockIOUtil struct { + ctrl *gomock.Controller + recorder *MockIOUtilMockRecorder +} + +// MockIOUtilMockRecorder is the mock recorder for MockIOUtil +type MockIOUtilMockRecorder struct { + mock *MockIOUtil +} + +// NewMockIOUtil creates a new mock instance +func NewMockIOUtil(ctrl *gomock.Controller) *MockIOUtil { + mock := &MockIOUtil{ctrl: ctrl} + mock.recorder = &MockIOUtilMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockIOUtil) EXPECT() *MockIOUtilMockRecorder { + return _m.recorder +} + +// TempFile mocks base method +func (_m *MockIOUtil) TempFile(_param0 string, _param1 string) (oswrapper.File, error) { + ret := _m.ctrl.Call(_m, "TempFile", _param0, _param1) + ret0, _ := ret[0].(oswrapper.File) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TempFile indicates an expected call of TempFile +func (_mr *MockIOUtilMockRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "TempFile", arg0, arg1) +} diff --git a/agent/utils/oswrapper/generate_mocks.go b/agent/utils/oswrapper/generate_mocks.go new file mode 100644 index 00000000000..62d845747cd --- /dev/null +++ b/agent/utils/oswrapper/generate_mocks.go @@ -0,0 +1,16 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package oswrapper + +//go:generate go run ../../../scripts/generate/mockgen.go github.com/aws/amazon-ecs-agent/agent/utils/oswrapper File,OS mocks/oswrapper_mocks.go diff --git a/agent/utils/oswrapper/mocks/oswrapper_mocks.go b/agent/utils/oswrapper/mocks/oswrapper_mocks.go new file mode 100644 index 00000000000..bb515da8c67 --- /dev/null +++ b/agent/utils/oswrapper/mocks/oswrapper_mocks.go @@ -0,0 +1,205 @@ +// Copyright 2015-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/amazon-ecs-agent/agent/utils/oswrapper (interfaces: File,OS) + +package mock_oswrapper + +import ( + os "os" + + oswrapper "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" + gomock "github.com/golang/mock/gomock" +) + +// MockFile is a mock of File interface +type MockFile struct { + ctrl *gomock.Controller + recorder *MockFileMockRecorder +} + +// MockFileMockRecorder is the mock recorder for MockFile +type MockFileMockRecorder struct { + mock *MockFile +} + +// NewMockFile creates a new mock instance +func NewMockFile(ctrl *gomock.Controller) *MockFile { + mock := &MockFile{ctrl: ctrl} + mock.recorder = &MockFileMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockFile) EXPECT() *MockFileMockRecorder { + return _m.recorder +} + +// Chmod mocks base method +func (_m *MockFile) Chmod(_param0 os.FileMode) error { + ret := _m.ctrl.Call(_m, "Chmod", _param0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Chmod indicates an expected call of Chmod +func (_mr *MockFileMockRecorder) Chmod(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Chmod", arg0) +} + +// Close mocks base method +func (_m *MockFile) Close() error { + ret := _m.ctrl.Call(_m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close +func (_mr *MockFileMockRecorder) Close() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +} + +// Name mocks base method +func (_m *MockFile) Name() string { + ret := _m.ctrl.Call(_m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name +func (_mr *MockFileMockRecorder) Name() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Name") +} + +// Sync mocks base method +func (_m *MockFile) Sync() error { + ret := _m.ctrl.Call(_m, "Sync") + ret0, _ := ret[0].(error) + return ret0 +} + +// Sync indicates an expected call of Sync +func (_mr *MockFileMockRecorder) Sync() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Sync") +} + +// Write mocks base method +func (_m *MockFile) Write(_param0 []byte) (int, error) { + ret := _m.ctrl.Call(_m, "Write", _param0) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Write indicates an expected call of Write +func (_mr *MockFileMockRecorder) Write(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0) +} + +// MockOS is a mock of OS interface +type MockOS struct { + ctrl *gomock.Controller + recorder *MockOSMockRecorder +} + +// MockOSMockRecorder is the mock recorder for MockOS +type MockOSMockRecorder struct { + mock *MockOS +} + +// NewMockOS creates a new mock instance +func NewMockOS(ctrl *gomock.Controller) *MockOS { + mock := &MockOS{ctrl: ctrl} + mock.recorder = &MockOSMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (_m *MockOS) EXPECT() *MockOSMockRecorder { + return _m.recorder +} + +// Create mocks base method +func (_m *MockOS) Create(_param0 string) (oswrapper.File, error) { + ret := _m.ctrl.Call(_m, "Create", _param0) + ret0, _ := ret[0].(oswrapper.File) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create +func (_mr *MockOSMockRecorder) Create(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0) +} + +// IsNotExist mocks base method +func (_m *MockOS) IsNotExist(_param0 error) bool { + ret := _m.ctrl.Call(_m, "IsNotExist", _param0) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsNotExist indicates an expected call of IsNotExist +func (_mr *MockOSMockRecorder) IsNotExist(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "IsNotExist", arg0) +} + +// MkdirAll mocks base method +func (_m *MockOS) MkdirAll(_param0 string, _param1 os.FileMode) error { + ret := _m.ctrl.Call(_m, "MkdirAll", _param0, _param1) + ret0, _ := ret[0].(error) + return ret0 +} + +// MkdirAll indicates an expected call of MkdirAll +func (_mr *MockOSMockRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "MkdirAll", arg0, arg1) +} + +// OpenFile mocks base method +func (_m *MockOS) OpenFile(_param0 string, _param1 int, _param2 os.FileMode) (oswrapper.File, error) { + ret := _m.ctrl.Call(_m, "OpenFile", _param0, _param1, _param2) + ret0, _ := ret[0].(oswrapper.File) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// OpenFile indicates an expected call of OpenFile +func (_mr *MockOSMockRecorder) OpenFile(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "OpenFile", arg0, arg1, arg2) +} + +// RemoveAll mocks base method +func (_m *MockOS) RemoveAll(_param0 string) error { + ret := _m.ctrl.Call(_m, "RemoveAll", _param0) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAll indicates an expected call of RemoveAll +func (_mr *MockOSMockRecorder) RemoveAll(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveAll", arg0) +} + +// Rename mocks base method +func (_m *MockOS) Rename(_param0 string, _param1 string) error { + ret := _m.ctrl.Call(_m, "Rename", _param0, _param1) + ret0, _ := ret[0].(error) + return ret0 +} + +// Rename indicates an expected call of Rename +func (_mr *MockOSMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Rename", arg0, arg1) +} diff --git a/agent/utils/oswrapper/os.go b/agent/utils/oswrapper/os.go new file mode 100644 index 00000000000..e17c515cb29 --- /dev/null +++ b/agent/utils/oswrapper/os.go @@ -0,0 +1,66 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package oswrapper + +import "os" + +// OS wraps methods from the 'os' package for testing +type OS interface { + Create(string) (File, error) + OpenFile(string, int, os.FileMode) (File, error) + Rename(string, string) error + MkdirAll(string, os.FileMode) error + RemoveAll(string) error + IsNotExist(error) bool +} + +// File wraps methods for os.File type +type File interface { + Name() string + Close() error + Chmod(os.FileMode) error + Write([]byte) (int, error) + Sync() error +} + +type _os struct { +} + +func NewOS() OS { + return &_os{} +} + +func (*_os) Create(name string) (File, error) { + return os.Create(name) +} + +func (*_os) OpenFile(name string, flag int, perm os.FileMode) (File, error) { + return os.OpenFile(name, flag, perm) +} + +func (*_os) Rename(name1 string, name2 string) error { + return os.Rename(name1, name2) +} + +func (*_os) MkdirAll(name string, perm os.FileMode) error { + return os.MkdirAll(name, perm) +} + +func (*_os) RemoveAll(name string) error { + return os.RemoveAll(name) +} + +func (*_os) IsNotExist(err error) bool { + return os.IsNotExist(err) +} From ed6aaef194ed806da03b958b44009557aa2bc62f Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 11 Sep 2017 15:59:15 -0700 Subject: [PATCH 02/58] engine: fixed method call --- agent/engine/docker_task_engine.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/agent/engine/docker_task_engine.go b/agent/engine/docker_task_engine.go index 8ce07345e93..93d1f65c323 100644 --- a/agent/engine/docker_task_engine.go +++ b/agent/engine/docker_task_engine.go @@ -661,7 +661,7 @@ func (engine *DockerTaskEngine) createContainer(task *api.Task, container *api.C // Create metadata directory and file then populate it with common metadata of all containers of this task // Afterwards add this directory to the container's mounts if file creation was successful - if engine.cfg.ContainerMetadataEnabled && !container.IsInternal { + if engine.cfg.ContainerMetadataEnabled && !container.IsInternal() { mderr := engine.metadataManager.Create(config, hostConfig, task.Arn, container.Name) if mderr != nil { seelog.Errorf("Create metadata failed for container %s of task %s: %v", container, task, mderr) @@ -702,7 +702,7 @@ func (engine *DockerTaskEngine) startContainer(task *api.Task, container *api.Co // Performs this in the background to avoid delaying container start // TODO: Add a state to the api.Container for the status of the metadata file (Whether it needs update) and // add logic to engine state restoration to do a metadata update for containers that are running after the agent was restarted - if dockerContainerMD.Error == nil && engine.cfg.ContainerMetadataEnabled && !container.IsInternal { + if dockerContainerMD.Error == nil && engine.cfg.ContainerMetadataEnabled && !container.IsInternal() { go func() { err := engine.metadataManager.Update(dockerContainer.DockerID, task.Arn, container.Name) if err != nil { From 203ec8794387225be1839be8dd2ee1f0481e2367 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 11 Sep 2017 16:05:08 -0700 Subject: [PATCH 03/58] agent: regenerate mocks This commit is fix gomock version mismatch and regenerate all mocks to fix breaking builds with metadata service changes --- .../mocks/containermetadata_mocks.go | 50 ++--- agent/engine/engine_mocks.go | 182 +++++------------- .../mocks/ioutilwrapper_mocks.go | 20 +- .../utils/oswrapper/mocks/oswrapper_mocks.go | 74 +++---- 4 files changed, 102 insertions(+), 224 deletions(-) diff --git a/agent/containermetadata/mocks/containermetadata_mocks.go b/agent/containermetadata/mocks/containermetadata_mocks.go index 3565da9cc3e..13816f41658 100644 --- a/agent/containermetadata/mocks/containermetadata_mocks.go +++ b/agent/containermetadata/mocks/containermetadata_mocks.go @@ -11,7 +11,7 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/containermetadata (interfaces: Manager,DockerMetadataClient) package mock_containermetadata @@ -23,99 +23,86 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockManager is a mock of Manager interface +// Mock of Manager interface type MockManager struct { ctrl *gomock.Controller - recorder *MockManagerMockRecorder + recorder *_MockManagerRecorder } -// MockManagerMockRecorder is the mock recorder for MockManager -type MockManagerMockRecorder struct { +// Recorder for MockManager (not exported) +type _MockManagerRecorder struct { mock *MockManager } -// NewMockManager creates a new mock instance func NewMockManager(ctrl *gomock.Controller) *MockManager { mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} + mock.recorder = &_MockManagerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockManager) EXPECT() *MockManagerMockRecorder { +func (_m *MockManager) EXPECT() *_MockManagerRecorder { return _m.recorder } -// Clean mocks base method func (_m *MockManager) Clean(_param0 string) error { ret := _m.ctrl.Call(_m, "Clean", _param0) ret0, _ := ret[0].(error) return ret0 } -// Clean indicates an expected call of Clean -func (_mr *MockManagerMockRecorder) Clean(arg0 interface{}) *gomock.Call { +func (_mr *_MockManagerRecorder) Clean(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Clean", arg0) } -// Create mocks base method func (_m *MockManager) Create(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 string) error { ret := _m.ctrl.Call(_m, "Create", _param0, _param1, _param2, _param3) ret0, _ := ret[0].(error) return ret0 } -// Create indicates an expected call of Create -func (_mr *MockManagerMockRecorder) Create(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (_mr *_MockManagerRecorder) Create(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2, arg3) } -// SetContainerInstanceARN mocks base method func (_m *MockManager) SetContainerInstanceARN(_param0 string) { _m.ctrl.Call(_m, "SetContainerInstanceARN", _param0) } -// SetContainerInstanceARN indicates an expected call of SetContainerInstanceARN -func (_mr *MockManagerMockRecorder) SetContainerInstanceARN(arg0 interface{}) *gomock.Call { +func (_mr *_MockManagerRecorder) SetContainerInstanceARN(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "SetContainerInstanceARN", arg0) } -// Update mocks base method func (_m *MockManager) Update(_param0 string, _param1 string, _param2 string) error { ret := _m.ctrl.Call(_m, "Update", _param0, _param1, _param2) ret0, _ := ret[0].(error) return ret0 } -// Update indicates an expected call of Update -func (_mr *MockManagerMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { +func (_mr *_MockManagerRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2) } -// MockDockerMetadataClient is a mock of DockerMetadataClient interface +// Mock of DockerMetadataClient interface type MockDockerMetadataClient struct { ctrl *gomock.Controller - recorder *MockDockerMetadataClientMockRecorder + recorder *_MockDockerMetadataClientRecorder } -// MockDockerMetadataClientMockRecorder is the mock recorder for MockDockerMetadataClient -type MockDockerMetadataClientMockRecorder struct { +// Recorder for MockDockerMetadataClient (not exported) +type _MockDockerMetadataClientRecorder struct { mock *MockDockerMetadataClient } -// NewMockDockerMetadataClient creates a new mock instance func NewMockDockerMetadataClient(ctrl *gomock.Controller) *MockDockerMetadataClient { mock := &MockDockerMetadataClient{ctrl: ctrl} - mock.recorder = &MockDockerMetadataClientMockRecorder{mock} + mock.recorder = &_MockDockerMetadataClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockDockerMetadataClient) EXPECT() *MockDockerMetadataClientMockRecorder { +func (_m *MockDockerMetadataClient) EXPECT() *_MockDockerMetadataClientRecorder { return _m.recorder } -// InspectContainer mocks base method func (_m *MockDockerMetadataClient) InspectContainer(_param0 string, _param1 time.Duration) (*go_dockerclient.Container, error) { ret := _m.ctrl.Call(_m, "InspectContainer", _param0, _param1) ret0, _ := ret[0].(*go_dockerclient.Container) @@ -123,7 +110,6 @@ func (_m *MockDockerMetadataClient) InspectContainer(_param0 string, _param1 tim return ret0, ret1 } -// InspectContainer indicates an expected call of InspectContainer -func (_mr *MockDockerMetadataClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerMetadataClientRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) } diff --git a/agent/engine/engine_mocks.go b/agent/engine/engine_mocks.go index b354a5c1f68..5782d846dcb 100644 --- a/agent/engine/engine_mocks.go +++ b/agent/engine/engine_mocks.go @@ -11,7 +11,7 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/engine (interfaces: TaskEngine,DockerClient,ImageManager) package engine @@ -31,64 +31,45 @@ import ( context0 "golang.org/x/net/context" ) -// MockTaskEngine is a mock of TaskEngine interface +// Mock of TaskEngine interface type MockTaskEngine struct { ctrl *gomock.Controller - recorder *MockTaskEngineMockRecorder + recorder *_MockTaskEngineRecorder } -// MockTaskEngineMockRecorder is the mock recorder for MockTaskEngine -type MockTaskEngineMockRecorder struct { +// Recorder for MockTaskEngine (not exported) +type _MockTaskEngineRecorder struct { mock *MockTaskEngine } -// NewMockTaskEngine creates a new mock instance func NewMockTaskEngine(ctrl *gomock.Controller) *MockTaskEngine { mock := &MockTaskEngine{ctrl: ctrl} - mock.recorder = &MockTaskEngineMockRecorder{mock} + mock.recorder = &_MockTaskEngineRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockTaskEngine) EXPECT() *MockTaskEngineMockRecorder { +func (_m *MockTaskEngine) EXPECT() *_MockTaskEngineRecorder { return _m.recorder } -// AddTask mocks base method func (_m *MockTaskEngine) AddTask(_param0 *api.Task) error { ret := _m.ctrl.Call(_m, "AddTask", _param0) ret0, _ := ret[0].(error) return ret0 } -// AddTask indicates an expected call of AddTask -func (_mr *MockTaskEngineMockRecorder) AddTask(arg0 interface{}) *gomock.Call { +func (_mr *_MockTaskEngineRecorder) AddTask(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTask", arg0) } -// Capabilities mocks base method -func (_m *MockTaskEngine) Capabilities() []string { - ret := _m.ctrl.Call(_m, "Capabilities") - ret0, _ := ret[0].([]string) - return ret0 -} - -// Capabilities indicates an expected call of Capabilities -func (_mr *MockTaskEngineMockRecorder) Capabilities() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Capabilities") -} - -// Disable mocks base method func (_m *MockTaskEngine) Disable() { _m.ctrl.Call(_m, "Disable") } -// Disable indicates an expected call of Disable -func (_mr *MockTaskEngineMockRecorder) Disable() *gomock.Call { +func (_mr *_MockTaskEngineRecorder) Disable() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Disable") } -// GetTaskByArn mocks base method func (_m *MockTaskEngine) GetTaskByArn(_param0 string) (*api.Task, bool) { ret := _m.ctrl.Call(_m, "GetTaskByArn", _param0) ret0, _ := ret[0].(*api.Task) @@ -96,8 +77,7 @@ func (_m *MockTaskEngine) GetTaskByArn(_param0 string) (*api.Task, bool) { return ret0, ret1 } -// GetTaskByArn indicates an expected call of GetTaskByArn -func (_mr *MockTaskEngineMockRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { +func (_mr *_MockTaskEngineRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTaskByArn", arg0) } @@ -107,12 +87,10 @@ func (_m *MockTaskEngine) Init(_param0 context0.Context) error { return ret0 } -// Init indicates an expected call of Init -func (_mr *MockTaskEngineMockRecorder) Init(arg0 interface{}) *gomock.Call { +func (_mr *_MockTaskEngineRecorder) Init(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Init", arg0) } -// ListTasks mocks base method func (_m *MockTaskEngine) ListTasks() ([]*api.Task, error) { ret := _m.ctrl.Call(_m, "ListTasks") ret0, _ := ret[0].([]*api.Task) @@ -120,12 +98,10 @@ func (_m *MockTaskEngine) ListTasks() ([]*api.Task, error) { return ret0, ret1 } -// ListTasks indicates an expected call of ListTasks -func (_mr *MockTaskEngineMockRecorder) ListTasks() *gomock.Call { +func (_mr *_MockTaskEngineRecorder) ListTasks() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTasks") } -// MarshalJSON mocks base method func (_m *MockTaskEngine) MarshalJSON() ([]byte, error) { ret := _m.ctrl.Call(_m, "MarshalJSON") ret0, _ := ret[0].([]byte) @@ -133,8 +109,7 @@ func (_m *MockTaskEngine) MarshalJSON() ([]byte, error) { return ret0, ret1 } -// MarshalJSON indicates an expected call of MarshalJSON -func (_mr *MockTaskEngineMockRecorder) MarshalJSON() *gomock.Call { +func (_mr *_MockTaskEngineRecorder) MarshalJSON() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "MarshalJSON") } @@ -142,46 +117,38 @@ func (_m *MockTaskEngine) MustInit(_param0 context0.Context) { _m.ctrl.Call(_m, "MustInit", _param0) } -// MustInit indicates an expected call of MustInit -func (_mr *MockTaskEngineMockRecorder) MustInit(arg0 interface{}) *gomock.Call { +func (_mr *_MockTaskEngineRecorder) MustInit(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "MustInit", arg0) } -// SetSaver mocks base method func (_m *MockTaskEngine) SetSaver(_param0 statemanager.Saver) { _m.ctrl.Call(_m, "SetSaver", _param0) } -// SetSaver indicates an expected call of SetSaver -func (_mr *MockTaskEngineMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { +func (_mr *_MockTaskEngineRecorder) SetSaver(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) } -// StateChangeEvents mocks base method func (_m *MockTaskEngine) StateChangeEvents() chan statechange.Event { ret := _m.ctrl.Call(_m, "StateChangeEvents") ret0, _ := ret[0].(chan statechange.Event) return ret0 } -// StateChangeEvents indicates an expected call of StateChangeEvents -func (_mr *MockTaskEngineMockRecorder) StateChangeEvents() *gomock.Call { +func (_mr *_MockTaskEngineRecorder) StateChangeEvents() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StateChangeEvents") } -// UnmarshalJSON mocks base method func (_m *MockTaskEngine) UnmarshalJSON(_param0 []byte) error { ret := _m.ctrl.Call(_m, "UnmarshalJSON", _param0) ret0, _ := ret[0].(error) return ret0 } -// UnmarshalJSON indicates an expected call of UnmarshalJSON -func (_mr *MockTaskEngineMockRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { +func (_mr *_MockTaskEngineRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "UnmarshalJSON", arg0) } -// Version mocks base method func (_m *MockTaskEngine) Version() (string, error) { ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(string) @@ -189,31 +156,28 @@ func (_m *MockTaskEngine) Version() (string, error) { return ret0, ret1 } -// Version indicates an expected call of Version -func (_mr *MockTaskEngineMockRecorder) Version() *gomock.Call { +func (_mr *_MockTaskEngineRecorder) Version() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } -// MockDockerClient is a mock of DockerClient interface +// Mock of DockerClient interface type MockDockerClient struct { ctrl *gomock.Controller - recorder *MockDockerClientMockRecorder + recorder *_MockDockerClientRecorder } -// MockDockerClientMockRecorder is the mock recorder for MockDockerClient -type MockDockerClientMockRecorder struct { +// Recorder for MockDockerClient (not exported) +type _MockDockerClientRecorder struct { mock *MockDockerClient } -// NewMockDockerClient creates a new mock instance func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient { mock := &MockDockerClient{ctrl: ctrl} - mock.recorder = &MockDockerClientMockRecorder{mock} + mock.recorder = &_MockDockerClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockDockerClient) EXPECT() *MockDockerClientMockRecorder { +func (_m *MockDockerClient) EXPECT() *_MockDockerClientRecorder { return _m.recorder } @@ -224,24 +188,20 @@ func (_m *MockDockerClient) ContainerEvents(_param0 context.Context) (<-chan Doc return ret0, ret1 } -// ContainerEvents indicates an expected call of ContainerEvents -func (_mr *MockDockerClientMockRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerEvents", arg0) } -// CreateContainer mocks base method func (_m *MockDockerClient) CreateContainer(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 time.Duration) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "CreateContainer", _param0, _param1, _param2, _param3) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// CreateContainer indicates an expected call of CreateContainer -func (_mr *MockDockerClientMockRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateContainer", arg0, arg1, arg2, arg3) } -// DescribeContainer mocks base method func (_m *MockDockerClient) DescribeContainer(_param0 string) (api.ContainerStatus, DockerContainerMetadata) { ret := _m.ctrl.Call(_m, "DescribeContainer", _param0) ret0, _ := ret[0].(api.ContainerStatus) @@ -249,8 +209,7 @@ func (_m *MockDockerClient) DescribeContainer(_param0 string) (api.ContainerStat return ret0, ret1 } -// DescribeContainer indicates an expected call of DescribeContainer -func (_mr *MockDockerClientMockRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeContainer", arg0) } @@ -271,12 +230,10 @@ func (_m *MockDockerClient) InspectContainer(_param0 string, _param1 time.Durati return ret0, ret1 } -// InspectContainer indicates an expected call of InspectContainer -func (_mr *MockDockerClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) } -// InspectImage mocks base method func (_m *MockDockerClient) InspectImage(_param0 string) (*go_dockerclient.Image, error) { ret := _m.ctrl.Call(_m, "InspectImage", _param0) ret0, _ := ret[0].(*go_dockerclient.Image) @@ -284,32 +241,27 @@ func (_m *MockDockerClient) InspectImage(_param0 string) (*go_dockerclient.Image return ret0, ret1 } -// InspectImage indicates an expected call of InspectImage -func (_mr *MockDockerClientMockRecorder) InspectImage(arg0 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) InspectImage(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectImage", arg0) } -// KnownVersions mocks base method func (_m *MockDockerClient) KnownVersions() []dockerclient.DockerVersion { ret := _m.ctrl.Call(_m, "KnownVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -// KnownVersions indicates an expected call of KnownVersions -func (_mr *MockDockerClientMockRecorder) KnownVersions() *gomock.Call { +func (_mr *_MockDockerClientRecorder) KnownVersions() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "KnownVersions") } -// ListContainers mocks base method func (_m *MockDockerClient) ListContainers(_param0 bool, _param1 time.Duration) ListContainersResponse { ret := _m.ctrl.Call(_m, "ListContainers", _param0, _param1) ret0, _ := ret[0].(ListContainersResponse) return ret0 } -// ListContainers indicates an expected call of ListContainers -func (_mr *MockDockerClientMockRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "ListContainers", arg0, arg1) } @@ -323,51 +275,43 @@ func (_mr *_MockDockerClientRecorder) LoadImage(arg0, arg1 interface{}) *gomock. return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0, arg1) } -// PullImage mocks base method func (_m *MockDockerClient) PullImage(_param0 string, _param1 *api.RegistryAuthenticationData) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "PullImage", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// PullImage indicates an expected call of PullImage -func (_mr *MockDockerClientMockRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "PullImage", arg0, arg1) } -// RemoveContainer mocks base method func (_m *MockDockerClient) RemoveContainer(_param0 string, _param1 time.Duration) error { ret := _m.ctrl.Call(_m, "RemoveContainer", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// RemoveContainer indicates an expected call of RemoveContainer -func (_mr *MockDockerClientMockRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainer", arg0, arg1) } -// RemoveImage mocks base method func (_m *MockDockerClient) RemoveImage(_param0 string, _param1 time.Duration) error { ret := _m.ctrl.Call(_m, "RemoveImage", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// RemoveImage indicates an expected call of RemoveImage -func (_mr *MockDockerClientMockRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImage", arg0, arg1) } -// StartContainer mocks base method func (_m *MockDockerClient) StartContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "StartContainer", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// StartContainer indicates an expected call of StartContainer -func (_mr *MockDockerClientMockRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainer", arg0, arg1) } @@ -378,36 +322,30 @@ func (_m *MockDockerClient) Stats(_param0 string, _param1 context.Context) (<-ch return ret0, ret1 } -// Stats indicates an expected call of Stats -func (_mr *MockDockerClientMockRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Stats", arg0, arg1) } -// StopContainer mocks base method func (_m *MockDockerClient) StopContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { ret := _m.ctrl.Call(_m, "StopContainer", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// StopContainer indicates an expected call of StopContainer -func (_mr *MockDockerClientMockRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainer", arg0, arg1) } -// SupportedVersions mocks base method func (_m *MockDockerClient) SupportedVersions() []dockerclient.DockerVersion { ret := _m.ctrl.Call(_m, "SupportedVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -// SupportedVersions indicates an expected call of SupportedVersions -func (_mr *MockDockerClientMockRecorder) SupportedVersions() *gomock.Call { +func (_mr *_MockDockerClientRecorder) SupportedVersions() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "SupportedVersions") } -// Version mocks base method func (_m *MockDockerClient) Version() (string, error) { ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(string) @@ -415,99 +353,84 @@ func (_m *MockDockerClient) Version() (string, error) { return ret0, ret1 } -// Version indicates an expected call of Version -func (_mr *MockDockerClientMockRecorder) Version() *gomock.Call { +func (_mr *_MockDockerClientRecorder) Version() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } -// WithVersion mocks base method func (_m *MockDockerClient) WithVersion(_param0 dockerclient.DockerVersion) DockerClient { ret := _m.ctrl.Call(_m, "WithVersion", _param0) ret0, _ := ret[0].(DockerClient) return ret0 } -// WithVersion indicates an expected call of WithVersion -func (_mr *MockDockerClientMockRecorder) WithVersion(arg0 interface{}) *gomock.Call { +func (_mr *_MockDockerClientRecorder) WithVersion(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "WithVersion", arg0) } -// MockImageManager is a mock of ImageManager interface +// Mock of ImageManager interface type MockImageManager struct { ctrl *gomock.Controller - recorder *MockImageManagerMockRecorder + recorder *_MockImageManagerRecorder } -// MockImageManagerMockRecorder is the mock recorder for MockImageManager -type MockImageManagerMockRecorder struct { +// Recorder for MockImageManager (not exported) +type _MockImageManagerRecorder struct { mock *MockImageManager } -// NewMockImageManager creates a new mock instance func NewMockImageManager(ctrl *gomock.Controller) *MockImageManager { mock := &MockImageManager{ctrl: ctrl} - mock.recorder = &MockImageManagerMockRecorder{mock} + mock.recorder = &_MockImageManagerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockImageManager) EXPECT() *MockImageManagerMockRecorder { +func (_m *MockImageManager) EXPECT() *_MockImageManagerRecorder { return _m.recorder } -// AddAllImageStates mocks base method func (_m *MockImageManager) AddAllImageStates(_param0 []*image.ImageState) { _m.ctrl.Call(_m, "AddAllImageStates", _param0) } -// AddAllImageStates indicates an expected call of AddAllImageStates -func (_mr *MockImageManagerMockRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { +func (_mr *_MockImageManagerRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "AddAllImageStates", arg0) } -// GetImageStateFromImageName mocks base method func (_m *MockImageManager) GetImageStateFromImageName(_param0 string) *image.ImageState { ret := _m.ctrl.Call(_m, "GetImageStateFromImageName", _param0) ret0, _ := ret[0].(*image.ImageState) return ret0 } -// GetImageStateFromImageName indicates an expected call of GetImageStateFromImageName -func (_mr *MockImageManagerMockRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { +func (_mr *_MockImageManagerRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "GetImageStateFromImageName", arg0) } -// RecordContainerReference mocks base method func (_m *MockImageManager) RecordContainerReference(_param0 *api.Container) error { ret := _m.ctrl.Call(_m, "RecordContainerReference", _param0) ret0, _ := ret[0].(error) return ret0 } -// RecordContainerReference indicates an expected call of RecordContainerReference -func (_mr *MockImageManagerMockRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { +func (_mr *_MockImageManagerRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RecordContainerReference", arg0) } -// RemoveContainerReferenceFromImageState mocks base method func (_m *MockImageManager) RemoveContainerReferenceFromImageState(_param0 *api.Container) error { ret := _m.ctrl.Call(_m, "RemoveContainerReferenceFromImageState", _param0) ret0, _ := ret[0].(error) return ret0 } -// RemoveContainerReferenceFromImageState indicates an expected call of RemoveContainerReferenceFromImageState -func (_mr *MockImageManagerMockRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { +func (_mr *_MockImageManagerRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainerReferenceFromImageState", arg0) } -// SetSaver mocks base method func (_m *MockImageManager) SetSaver(_param0 statemanager.Saver) { _m.ctrl.Call(_m, "SetSaver", _param0) } -// SetSaver indicates an expected call of SetSaver -func (_mr *MockImageManagerMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { +func (_mr *_MockImageManagerRecorder) SetSaver(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) } @@ -515,7 +438,6 @@ func (_m *MockImageManager) StartImageCleanupProcess(_param0 context0.Context) { _m.ctrl.Call(_m, "StartImageCleanupProcess", _param0) } -// StartImageCleanupProcess indicates an expected call of StartImageCleanupProcess -func (_mr *MockImageManagerMockRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { +func (_mr *_MockImageManagerRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "StartImageCleanupProcess", arg0) } diff --git a/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go index 91291253e29..88e928cd9e7 100644 --- a/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go +++ b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go @@ -11,7 +11,7 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper (interfaces: IOUtil) package mock_ioutilwrapper @@ -21,30 +21,27 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockIOUtil is a mock of IOUtil interface +// Mock of IOUtil interface type MockIOUtil struct { ctrl *gomock.Controller - recorder *MockIOUtilMockRecorder + recorder *_MockIOUtilRecorder } -// MockIOUtilMockRecorder is the mock recorder for MockIOUtil -type MockIOUtilMockRecorder struct { +// Recorder for MockIOUtil (not exported) +type _MockIOUtilRecorder struct { mock *MockIOUtil } -// NewMockIOUtil creates a new mock instance func NewMockIOUtil(ctrl *gomock.Controller) *MockIOUtil { mock := &MockIOUtil{ctrl: ctrl} - mock.recorder = &MockIOUtilMockRecorder{mock} + mock.recorder = &_MockIOUtilRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockIOUtil) EXPECT() *MockIOUtilMockRecorder { +func (_m *MockIOUtil) EXPECT() *_MockIOUtilRecorder { return _m.recorder } -// TempFile mocks base method func (_m *MockIOUtil) TempFile(_param0 string, _param1 string) (oswrapper.File, error) { ret := _m.ctrl.Call(_m, "TempFile", _param0, _param1) ret0, _ := ret[0].(oswrapper.File) @@ -52,7 +49,6 @@ func (_m *MockIOUtil) TempFile(_param0 string, _param1 string) (oswrapper.File, return ret0, ret1 } -// TempFile indicates an expected call of TempFile -func (_mr *MockIOUtilMockRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockIOUtilRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "TempFile", arg0, arg1) } diff --git a/agent/utils/oswrapper/mocks/oswrapper_mocks.go b/agent/utils/oswrapper/mocks/oswrapper_mocks.go index bb515da8c67..d567e39566d 100644 --- a/agent/utils/oswrapper/mocks/oswrapper_mocks.go +++ b/agent/utils/oswrapper/mocks/oswrapper_mocks.go @@ -11,7 +11,7 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/utils/oswrapper (interfaces: File,OS) package mock_oswrapper @@ -23,78 +23,67 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockFile is a mock of File interface +// Mock of File interface type MockFile struct { ctrl *gomock.Controller - recorder *MockFileMockRecorder + recorder *_MockFileRecorder } -// MockFileMockRecorder is the mock recorder for MockFile -type MockFileMockRecorder struct { +// Recorder for MockFile (not exported) +type _MockFileRecorder struct { mock *MockFile } -// NewMockFile creates a new mock instance func NewMockFile(ctrl *gomock.Controller) *MockFile { mock := &MockFile{ctrl: ctrl} - mock.recorder = &MockFileMockRecorder{mock} + mock.recorder = &_MockFileRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockFile) EXPECT() *MockFileMockRecorder { +func (_m *MockFile) EXPECT() *_MockFileRecorder { return _m.recorder } -// Chmod mocks base method func (_m *MockFile) Chmod(_param0 os.FileMode) error { ret := _m.ctrl.Call(_m, "Chmod", _param0) ret0, _ := ret[0].(error) return ret0 } -// Chmod indicates an expected call of Chmod -func (_mr *MockFileMockRecorder) Chmod(arg0 interface{}) *gomock.Call { +func (_mr *_MockFileRecorder) Chmod(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Chmod", arg0) } -// Close mocks base method func (_m *MockFile) Close() error { ret := _m.ctrl.Call(_m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close -func (_mr *MockFileMockRecorder) Close() *gomock.Call { +func (_mr *_MockFileRecorder) Close() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") } -// Name mocks base method func (_m *MockFile) Name() string { ret := _m.ctrl.Call(_m, "Name") ret0, _ := ret[0].(string) return ret0 } -// Name indicates an expected call of Name -func (_mr *MockFileMockRecorder) Name() *gomock.Call { +func (_mr *_MockFileRecorder) Name() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Name") } -// Sync mocks base method func (_m *MockFile) Sync() error { ret := _m.ctrl.Call(_m, "Sync") ret0, _ := ret[0].(error) return ret0 } -// Sync indicates an expected call of Sync -func (_mr *MockFileMockRecorder) Sync() *gomock.Call { +func (_mr *_MockFileRecorder) Sync() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Sync") } -// Write mocks base method func (_m *MockFile) Write(_param0 []byte) (int, error) { ret := _m.ctrl.Call(_m, "Write", _param0) ret0, _ := ret[0].(int) @@ -102,35 +91,31 @@ func (_m *MockFile) Write(_param0 []byte) (int, error) { return ret0, ret1 } -// Write indicates an expected call of Write -func (_mr *MockFileMockRecorder) Write(arg0 interface{}) *gomock.Call { +func (_mr *_MockFileRecorder) Write(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0) } -// MockOS is a mock of OS interface +// Mock of OS interface type MockOS struct { ctrl *gomock.Controller - recorder *MockOSMockRecorder + recorder *_MockOSRecorder } -// MockOSMockRecorder is the mock recorder for MockOS -type MockOSMockRecorder struct { +// Recorder for MockOS (not exported) +type _MockOSRecorder struct { mock *MockOS } -// NewMockOS creates a new mock instance func NewMockOS(ctrl *gomock.Controller) *MockOS { mock := &MockOS{ctrl: ctrl} - mock.recorder = &MockOSMockRecorder{mock} + mock.recorder = &_MockOSRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (_m *MockOS) EXPECT() *MockOSMockRecorder { +func (_m *MockOS) EXPECT() *_MockOSRecorder { return _m.recorder } -// Create mocks base method func (_m *MockOS) Create(_param0 string) (oswrapper.File, error) { ret := _m.ctrl.Call(_m, "Create", _param0) ret0, _ := ret[0].(oswrapper.File) @@ -138,36 +123,30 @@ func (_m *MockOS) Create(_param0 string) (oswrapper.File, error) { return ret0, ret1 } -// Create indicates an expected call of Create -func (_mr *MockOSMockRecorder) Create(arg0 interface{}) *gomock.Call { +func (_mr *_MockOSRecorder) Create(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0) } -// IsNotExist mocks base method func (_m *MockOS) IsNotExist(_param0 error) bool { ret := _m.ctrl.Call(_m, "IsNotExist", _param0) ret0, _ := ret[0].(bool) return ret0 } -// IsNotExist indicates an expected call of IsNotExist -func (_mr *MockOSMockRecorder) IsNotExist(arg0 interface{}) *gomock.Call { +func (_mr *_MockOSRecorder) IsNotExist(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "IsNotExist", arg0) } -// MkdirAll mocks base method func (_m *MockOS) MkdirAll(_param0 string, _param1 os.FileMode) error { ret := _m.ctrl.Call(_m, "MkdirAll", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// MkdirAll indicates an expected call of MkdirAll -func (_mr *MockOSMockRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockOSRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "MkdirAll", arg0, arg1) } -// OpenFile mocks base method func (_m *MockOS) OpenFile(_param0 string, _param1 int, _param2 os.FileMode) (oswrapper.File, error) { ret := _m.ctrl.Call(_m, "OpenFile", _param0, _param1, _param2) ret0, _ := ret[0].(oswrapper.File) @@ -175,31 +154,26 @@ func (_m *MockOS) OpenFile(_param0 string, _param1 int, _param2 os.FileMode) (os return ret0, ret1 } -// OpenFile indicates an expected call of OpenFile -func (_mr *MockOSMockRecorder) OpenFile(arg0, arg1, arg2 interface{}) *gomock.Call { +func (_mr *_MockOSRecorder) OpenFile(arg0, arg1, arg2 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "OpenFile", arg0, arg1, arg2) } -// RemoveAll mocks base method func (_m *MockOS) RemoveAll(_param0 string) error { ret := _m.ctrl.Call(_m, "RemoveAll", _param0) ret0, _ := ret[0].(error) return ret0 } -// RemoveAll indicates an expected call of RemoveAll -func (_mr *MockOSMockRecorder) RemoveAll(arg0 interface{}) *gomock.Call { +func (_mr *_MockOSRecorder) RemoveAll(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveAll", arg0) } -// Rename mocks base method func (_m *MockOS) Rename(_param0 string, _param1 string) error { ret := _m.ctrl.Call(_m, "Rename", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// Rename indicates an expected call of Rename -func (_mr *MockOSMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockOSRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Rename", arg0, arg1) } From d04bb67fa10d3bf6cef8f2dd9867d287b1af8443 Mon Sep 17 00:00:00 2001 From: Derek Petersen Date: Fri, 8 Sep 2017 09:47:12 -0700 Subject: [PATCH 04/58] vendor: updating gomock --- agent/Godeps/Godeps.json | 3 +- .../github.com/golang/mock/gomock/call.go | 98 +++++++++++-------- .../github.com/golang/mock/gomock/callset.go | 25 +++-- .../golang/mock/gomock/controller.go | 36 ++++++- .../github.com/golang/mock/gomock/matchers.go | 4 +- 5 files changed, 110 insertions(+), 56 deletions(-) diff --git a/agent/Godeps/Godeps.json b/agent/Godeps/Godeps.json index 75604dbc9ae..d926a37ffd4 100644 --- a/agent/Godeps/Godeps.json +++ b/agent/Godeps/Godeps.json @@ -334,7 +334,8 @@ }, { "ImportPath": "github.com/golang/mock/gomock", - "Rev": "bd3c8e81be01eef76d4b503f5e687d2d1354d2d9" + "Comment": "v1.0.0-17-g18f6dd1", + "Rev": "18f6dd13ccdd227b8ebc546ca95cd62a02f3970c" }, { "ImportPath": "github.com/gorilla/websocket", diff --git a/agent/vendor/github.com/golang/mock/gomock/call.go b/agent/vendor/github.com/golang/mock/gomock/call.go index c5601970e1e..dc2a479d112 100644 --- a/agent/vendor/github.com/golang/mock/gomock/call.go +++ b/agent/vendor/github.com/golang/mock/gomock/call.go @@ -17,6 +17,7 @@ package gomock import ( "fmt" "reflect" + "strconv" "strings" ) @@ -24,10 +25,12 @@ import ( type Call struct { t TestReporter // for triggering test failures on invalid call setup - receiver interface{} // the receiver of the method call - method string // the name of the method - args []Matcher // the args - rets []interface{} // the return values (if any) + receiver interface{} // the receiver of the method call + method string // the name of the method + methodType reflect.Type // the type of the method + args []Matcher // the args + rets []interface{} // the return values (if any) + origin string // file and line number of call setup preReqs []*Call // prerequisite calls @@ -76,10 +79,10 @@ func (c *Call) Do(f interface{}) *Call { } func (c *Call) Return(rets ...interface{}) *Call { - mt := c.methodType() + mt := c.methodType if len(rets) != mt.NumOut() { - c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d", - c.receiver, c.method, len(rets), mt.NumOut()) + c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d [%s]", + c.receiver, c.method, len(rets), mt.NumOut(), c.origin) } for i, ret := range rets { if got, want := reflect.TypeOf(ret), mt.Out(i); got == want { @@ -90,8 +93,8 @@ func (c *Call) Return(rets ...interface{}) *Call { case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: // ok default: - c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable", - i, c.receiver, c.method, want) + c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable [%s]", + i, c.receiver, c.method, want, c.origin) } } else if got.AssignableTo(want) { // Assignable type relation. Make the assignment now so that the generated code @@ -100,8 +103,8 @@ func (c *Call) Return(rets ...interface{}) *Call { v.Set(reflect.ValueOf(ret)) rets[i] = v.Interface() } else { - c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v", - i, c.receiver, c.method, got, want) + c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v [%s]", + i, c.receiver, c.method, got, want, c.origin) } } @@ -115,16 +118,18 @@ func (c *Call) Times(n int) *Call { } // SetArg declares an action that will set the nth argument's value, -// indirected through a pointer. +// indirected through a pointer. Or, in the case of a slice, SetArg +// will copy value's elements into the nth argument. func (c *Call) SetArg(n int, value interface{}) *Call { if c.setArgs == nil { c.setArgs = make(map[int]reflect.Value) } - mt := c.methodType() + mt := c.methodType // TODO: This will break on variadic methods. // We will need to check those at invocation time. if n < 0 || n >= mt.NumIn() { - c.t.Fatalf("SetArg(%d, ...) called for a method with %d args", n, mt.NumIn()) + c.t.Fatalf("SetArg(%d, ...) called for a method with %d args [%s]", + n, mt.NumIn(), c.origin) } // Permit setting argument through an interface. // In the interface case, we don't (nay, can't) check the type here. @@ -133,12 +138,16 @@ func (c *Call) SetArg(n int, value interface{}) *Call { case reflect.Ptr: dt := at.Elem() if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) { - c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v", n, vt, dt) + c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v [%s]", + n, vt, dt, c.origin) } case reflect.Interface: // nothing to do + case reflect.Slice: + // nothing to do default: - c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface type %v", n, at) + c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface non-slice type %v", + n, at, c.origin) } c.setArgs[n] = reflect.ValueOf(value) return c @@ -156,19 +165,18 @@ func (c *Call) isPreReq(other *Call) bool { // After declares that the call may only match after preReq has been exhausted. func (c *Call) After(preReq *Call) *Call { + if c == preReq { + c.t.Fatalf("A call isn't allowed to be its own prerequisite") + } if preReq.isPreReq(c) { - msg := fmt.Sprintf( - "Loop in call order: %v is a prerequisite to %v (possibly indirectly).", - c, preReq, - ) - panic(msg) + c.t.Fatalf("Loop in call order: %v is a prerequisite to %v (possibly indirectly).", c, preReq) } c.preReqs = append(c.preReqs, preReq) return c } -// Returns true iff the minimum number of calls have been made. +// Returns true if the minimum number of calls have been made. func (c *Call) satisfied() bool { return c.numCalls >= c.minCalls } @@ -184,31 +192,35 @@ func (c *Call) String() string { args[i] = arg.String() } arguments := strings.Join(args, ", ") - return fmt.Sprintf("%T.%v(%s)", c.receiver, c.method, arguments) + return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin) } // Tests if the given call matches the expected call. -func (c *Call) matches(args []interface{}) bool { +// If yes, returns nil. If no, returns error with message explaining why it does not match. +func (c *Call) matches(args []interface{}) error { if len(args) != len(c.args) { - return false + return fmt.Errorf("Expected call at %s has the wrong number of arguments. Got: %s, want: %s", + c.origin, strconv.Itoa(len(args)), strconv.Itoa(len(c.args))) } for i, m := range c.args { if !m.Matches(args[i]) { - return false + return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v\n", + c.origin, strconv.Itoa(i), args[i], m) } } // Check that all prerequisite calls have been satisfied. for _, preReqCall := range c.preReqs { if !preReqCall.satisfied() { - return false + return fmt.Errorf("Expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v", + c.origin, preReqCall, c) } } - return true + return nil } -// dropPrereqs tells the expected Call to not re-check prerequite calls any +// dropPrereqs tells the expected Call to not re-check prerequisite calls any // longer, and to return its current set. func (c *Call) dropPrereqs() (preReqs []*Call) { preReqs = c.preReqs @@ -223,7 +235,7 @@ func (c *Call) call(args []interface{}) (rets []interface{}, action func()) { if c.doFunc.IsValid() { doArgs := make([]reflect.Value, len(args)) ft := c.doFunc.Type() - for i := 0; i < ft.NumIn(); i++ { + for i := 0; i < len(args); i++ { if args[i] != nil { doArgs[i] = reflect.ValueOf(args[i]) } else { @@ -234,13 +246,18 @@ func (c *Call) call(args []interface{}) (rets []interface{}, action func()) { action = func() { c.doFunc.Call(doArgs) } } for n, v := range c.setArgs { - reflect.ValueOf(args[n]).Elem().Set(v) + switch reflect.TypeOf(args[n]).Kind() { + case reflect.Slice: + setSlice(args[n], v) + default: + reflect.ValueOf(args[n]).Elem().Set(v) + } } rets = c.rets if rets == nil { // Synthesize the zero value for each of the return args' types. - mt := c.methodType() + mt := c.methodType rets = make([]interface{}, mt.NumOut()) for i := 0; i < mt.NumOut(); i++ { rets[i] = reflect.Zero(mt.Out(i)).Interface() @@ -250,19 +267,16 @@ func (c *Call) call(args []interface{}) (rets []interface{}, action func()) { return } -func (c *Call) methodType() reflect.Type { - recv := reflect.ValueOf(c.receiver) - for i := 0; i < recv.Type().NumMethod(); i++ { - if recv.Type().Method(i).Name == c.method { - return recv.Method(i).Type() - } - } - panic(fmt.Sprintf("gomock: failed finding method %s on %T", c.method, c.receiver)) -} - // InOrder declares that the given calls should occur in order. func InOrder(calls ...*Call) { for i := 1; i < len(calls); i++ { calls[i].After(calls[i-1]) } } + +func setSlice(arg interface{}, v reflect.Value) { + va := reflect.ValueOf(arg) + for i := 0; i < v.Len(); i++ { + va.Index(i).Set(v.Index(i)) + } +} diff --git a/agent/vendor/github.com/golang/mock/gomock/callset.go b/agent/vendor/github.com/golang/mock/gomock/callset.go index 1b7de4c0b32..7f3f6d1de5d 100644 --- a/agent/vendor/github.com/golang/mock/gomock/callset.go +++ b/agent/vendor/github.com/golang/mock/gomock/callset.go @@ -14,6 +14,12 @@ package gomock +import ( + "bytes" + "errors" + "fmt" +) + // callSet represents a set of expected calls, indexed by receiver and method // name. type callSet map[interface{}]map[string][]*Call @@ -47,30 +53,35 @@ func (cs callSet) Remove(call *Call) { } } -// FindMatch searches for a matching call. Returns nil if no call matched. -func (cs callSet) FindMatch(receiver interface{}, method string, args []interface{}) *Call { +// FindMatch searches for a matching call. Returns error with explanation message if no call matched. +func (cs callSet) FindMatch(receiver interface{}, method string, args []interface{}) (*Call, error) { methodMap, ok := cs[receiver] if !ok { - return nil + return nil, errors.New("there are no expected method calls for that receiver") } calls, ok := methodMap[method] if !ok { - return nil + return nil, fmt.Errorf("there are no expected calls of the method: %s for that receiver", method) } // Search through the unordered set of calls expected on a method on a // receiver. + var callsErrors bytes.Buffer for _, call := range calls { // A call should not normally still be here if exhausted, // but it can happen if, for instance, .Times(0) was used. // Pretend the call doesn't match. if call.exhausted() { + callsErrors.WriteString("\nThe call was exhausted.") continue } - if call.matches(args) { - return call + err := call.matches(args) + if err != nil { + fmt.Fprintf(&callsErrors, "\n%v", err) + } else { + return call, nil } } - return nil + return nil, fmt.Errorf(callsErrors.String()) } diff --git a/agent/vendor/github.com/golang/mock/gomock/controller.go b/agent/vendor/github.com/golang/mock/gomock/controller.go index 6ca952803c0..d06dfbbe852 100644 --- a/agent/vendor/github.com/golang/mock/gomock/controller.go +++ b/agent/vendor/github.com/golang/mock/gomock/controller.go @@ -55,7 +55,12 @@ // - Handle different argument/return types (e.g. ..., chan, map, interface). package gomock -import "sync" +import ( + "fmt" + "reflect" + "runtime" + "sync" +) // A TestReporter is something that can be used to report test failures. // It is satisfied by the standard library's *testing.T. @@ -81,6 +86,18 @@ func NewController(t TestReporter) *Controller { } func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call { + recv := reflect.ValueOf(receiver) + for i := 0; i < recv.Type().NumMethod(); i++ { + if recv.Type().Method(i).Name == method { + return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...) + } + } + ctrl.t.Fatalf("gomock: failed finding method %s on %T", method, receiver) + // In case t.Fatalf does not panic. + panic(fmt.Sprintf("gomock: failed finding method %s on %T", method, receiver)) +} + +func (ctrl *Controller) RecordCallWithMethodType(receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call { // TODO: check arity, types. margs := make([]Matcher, len(args)) for i, arg := range args { @@ -98,7 +115,8 @@ func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ... ctrl.mu.Lock() defer ctrl.mu.Unlock() - call := &Call{t: ctrl.t, receiver: receiver, method: method, args: margs, minCalls: 1, maxCalls: 1} + origin := callerInfo(2) + call := &Call{t: ctrl.t, receiver: receiver, method: method, methodType: methodType, args: margs, origin: origin, minCalls: 1, maxCalls: 1} ctrl.expectedCalls.Add(call) return call @@ -108,9 +126,10 @@ func (ctrl *Controller) Call(receiver interface{}, method string, args ...interf ctrl.mu.Lock() defer ctrl.mu.Unlock() - expected := ctrl.expectedCalls.FindMatch(receiver, method, args) - if expected == nil { - ctrl.t.Fatalf("no matching expected call: %T.%v(%v)", receiver, method, args) + expected, err := ctrl.expectedCalls.FindMatch(receiver, method, args) + if err != nil { + origin := callerInfo(2) + ctrl.t.Fatalf("Unexpected call to %T.%v(%v) at %s because: %s", receiver, method, args, origin, err) } // Two things happen here: @@ -165,3 +184,10 @@ func (ctrl *Controller) Finish() { ctrl.t.Fatalf("aborting test due to missing call(s)") } } + +func callerInfo(skip int) string { + if _, file, line, ok := runtime.Caller(skip + 1); ok { + return fmt.Sprintf("%s:%d", file, line) + } + return "unknown file" +} diff --git a/agent/vendor/github.com/golang/mock/gomock/matchers.go b/agent/vendor/github.com/golang/mock/gomock/matchers.go index 32628ae8cbd..e8b1ddccf03 100644 --- a/agent/vendor/github.com/golang/mock/gomock/matchers.go +++ b/agent/vendor/github.com/golang/mock/gomock/matchers.go @@ -1,3 +1,5 @@ +//go:generate mockgen -destination mock_matcher/mock_matcher.go github.com/golang/mock/gomock Matcher + // Copyright 2010 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -22,7 +24,7 @@ import ( // A Matcher is a representation of a class of values. // It is used to represent the valid or expected arguments to a mocked method. type Matcher interface { - // Matches returns whether y is a match. + // Matches returns whether x is a match. Matches(x interface{}) bool // String describes what the matcher matches. From 14274b327e75f0893314967ca49b8f70f547b9df Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 11 Sep 2017 16:09:06 -0700 Subject: [PATCH 05/58] agent: ran 'make gogenerate' --- .../acs/update_handler/os/mock/filesystem.go | 130 +++--- agent/api/mocks/api_mocks.go | 153 ++++--- agent/app/factory/mocks/factory_mocks.go | 65 +-- agent/app/mocks/credentials_mocks.go | 41 +- agent/app/oswrapper/mocks/oswrapper_mocks.go | 31 +- agent/async/mocks/async_mocks.go | 41 +- .../mocks/containermetadata_mocks.go | 86 ++-- agent/credentials/mocks/credentials_mocks.go | 51 ++- agent/ec2/http/mocks/http_mocks.go | 30 +- agent/ec2/mocks/ec2_mocks.go | 137 ++++--- agent/ecr/mocks/ecr_mocks.go | 103 +++-- agent/ecscni/mocks/ecscni_mocks.go | 56 +-- agent/ecscni/mocks_cnitypes/result_mocks.go | 61 +-- agent/ecscni/mocks_libcni/libcni_mocks.go | 61 +-- .../dockerclient/mocks/dockerclient_mocks.go | 61 +-- .../dockeriface/mocks/dockeriface_mocks.go | 211 ++++++---- .../dockerstate/mocks/dockerstate_mocks.go | 211 ++++++---- agent/engine/engine_mocks.go | 372 +++++++++++------- .../mocks/mock_netlinkwrapper_linux.go | 41 +- agent/eni/pause/mocks/load_mocks.go | 31 +- .../mocks/mock_udevwrapper_linux.go | 41 +- agent/handlers/mocks/handlers_mocks.go | 31 +- agent/handlers/mocks/http/handlers_mocks.go | 50 ++- agent/httpclient/mock/httpclient.go | 30 +- agent/logger/audit/mocks/audit_log_mocks.go | 83 ++-- .../statemanager/mocks/statemanager_mocks.go | 51 ++- agent/stats/mock/engine.go | 31 +- agent/stats/resolver/mock/resolver.go | 41 +- .../mocks/ioutilwrapper_mocks.go | 31 +- agent/utils/mocks/utils_mocks.go | 66 ++-- .../utils/oswrapper/mocks/oswrapper_mocks.go | 146 ++++--- agent/utils/ttime/mocks/time_mocks.go | 96 +++-- agent/wsclient/mock/client.go | 162 ++++---- 33 files changed, 1697 insertions(+), 1135 deletions(-) diff --git a/agent/acs/update_handler/os/mock/filesystem.go b/agent/acs/update_handler/os/mock/filesystem.go index e3041e74628..125fe9fe8f7 100644 --- a/agent/acs/update_handler/os/mock/filesystem.go +++ b/agent/acs/update_handler/os/mock/filesystem.go @@ -11,146 +11,172 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/acs/update_handler/os (interfaces: FileSystem) +// Package mock_os is a generated GoMock package. package mock_os import ( io "io" os "os" + reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// Mock of FileSystem interface +// MockFileSystem is a mock of FileSystem interface type MockFileSystem struct { ctrl *gomock.Controller - recorder *_MockFileSystemRecorder + recorder *MockFileSystemMockRecorder } -// Recorder for MockFileSystem (not exported) -type _MockFileSystemRecorder struct { +// MockFileSystemMockRecorder is the mock recorder for MockFileSystem +type MockFileSystemMockRecorder struct { mock *MockFileSystem } +// NewMockFileSystem creates a new mock instance func NewMockFileSystem(ctrl *gomock.Controller) *MockFileSystem { mock := &MockFileSystem{ctrl: ctrl} - mock.recorder = &_MockFileSystemRecorder{mock} + mock.recorder = &MockFileSystemMockRecorder{mock} return mock } -func (_m *MockFileSystem) EXPECT() *_MockFileSystemRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockFileSystem) EXPECT() *MockFileSystemMockRecorder { + return m.recorder } -func (_m *MockFileSystem) Copy(_param0 io.Writer, _param1 io.Reader) (int64, error) { - ret := _m.ctrl.Call(_m, "Copy", _param0, _param1) +// Copy mocks base method +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 } -func (_mr *_MockFileSystemRecorder) Copy(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Copy", arg0, arg1) +// Copy indicates an expected call of Copy +func (mr *MockFileSystemMockRecorder) Copy(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockFileSystem)(nil).Copy), arg0, arg1) } -func (_m *MockFileSystem) Create(_param0 string) (io.ReadWriteCloser, error) { - ret := _m.ctrl.Call(_m, "Create", _param0) +// Create mocks base method +func (m *MockFileSystem) Create(arg0 string) (io.ReadWriteCloser, error) { + ret := m.ctrl.Call(m, "Create", arg0) ret0, _ := ret[0].(io.ReadWriteCloser) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockFileSystemRecorder) Create(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0) +// Create indicates an expected call of Create +func (mr *MockFileSystemMockRecorder) Create(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFileSystem)(nil).Create), arg0) } -func (_m *MockFileSystem) Exit(_param0 int) { - _m.ctrl.Call(_m, "Exit", _param0) +// Exit mocks base method +func (m *MockFileSystem) Exit(arg0 int) { + m.ctrl.Call(m, "Exit", arg0) } -func (_mr *_MockFileSystemRecorder) Exit(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Exit", arg0) +// Exit indicates an expected call of Exit +func (mr *MockFileSystemMockRecorder) Exit(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exit", reflect.TypeOf((*MockFileSystem)(nil).Exit), arg0) } -func (_m *MockFileSystem) MkdirAll(_param0 string, _param1 os.FileMode) error { - ret := _m.ctrl.Call(_m, "MkdirAll", _param0, _param1) +// MkdirAll mocks base method +func (m *MockFileSystem) MkdirAll(arg0 string, arg1 os.FileMode) error { + ret := m.ctrl.Call(m, "MkdirAll", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockFileSystemRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "MkdirAll", arg0, arg1) +// MkdirAll indicates an expected call of MkdirAll +func (mr *MockFileSystemMockRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockFileSystem)(nil).MkdirAll), arg0, arg1) } -func (_m *MockFileSystem) Open(_param0 string) (io.ReadWriteCloser, error) { - ret := _m.ctrl.Call(_m, "Open", _param0) +// Open mocks base method +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 } -func (_mr *_MockFileSystemRecorder) Open(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Open", arg0) +// Open indicates an expected call of Open +func (mr *MockFileSystemMockRecorder) Open(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockFileSystem)(nil).Open), arg0) } -func (_m *MockFileSystem) ReadAll(_param0 io.Reader) ([]byte, error) { - ret := _m.ctrl.Call(_m, "ReadAll", _param0) +// ReadAll mocks base method +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 } -func (_mr *_MockFileSystemRecorder) ReadAll(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadAll", arg0) +// ReadAll indicates an expected call of ReadAll +func (mr *MockFileSystemMockRecorder) ReadAll(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAll", reflect.TypeOf((*MockFileSystem)(nil).ReadAll), arg0) } -func (_m *MockFileSystem) Remove(_param0 string) { - _m.ctrl.Call(_m, "Remove", _param0) +// Remove mocks base method +func (m *MockFileSystem) Remove(arg0 string) { + m.ctrl.Call(m, "Remove", arg0) } -func (_mr *_MockFileSystemRecorder) Remove(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Remove", arg0) +// Remove indicates an expected call of Remove +func (mr *MockFileSystemMockRecorder) Remove(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockFileSystem)(nil).Remove), arg0) } -func (_m *MockFileSystem) Rename(_param0 string, _param1 string) error { - ret := _m.ctrl.Call(_m, "Rename", _param0, _param1) +// Rename mocks base method +func (m *MockFileSystem) Rename(arg0, arg1 string) error { + ret := m.ctrl.Call(m, "Rename", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockFileSystemRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Rename", arg0, arg1) +// Rename indicates an expected call of Rename +func (mr *MockFileSystemMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockFileSystem)(nil).Rename), arg0, arg1) } -func (_m *MockFileSystem) TeeReader(_param0 io.Reader, _param1 io.Writer) io.Reader { - ret := _m.ctrl.Call(_m, "TeeReader", _param0, _param1) +// TeeReader mocks base method +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 } -func (_mr *_MockFileSystemRecorder) TeeReader(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TeeReader", arg0, arg1) +// TeeReader indicates an expected call of TeeReader +func (mr *MockFileSystemMockRecorder) TeeReader(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TeeReader", reflect.TypeOf((*MockFileSystem)(nil).TeeReader), arg0, arg1) } -func (_m *MockFileSystem) TempFile(_param0 string, _param1 string) (*os.File, error) { - ret := _m.ctrl.Call(_m, "TempFile", _param0, _param1) +// TempFile mocks base method +func (m *MockFileSystem) TempFile(arg0, arg1 string) (*os.File, error) { + ret := m.ctrl.Call(m, "TempFile", arg0, arg1) ret0, _ := ret[0].(*os.File) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockFileSystemRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TempFile", arg0, arg1) +// TempFile indicates an expected call of TempFile +func (mr *MockFileSystemMockRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TempFile", reflect.TypeOf((*MockFileSystem)(nil).TempFile), arg0, arg1) } -func (_m *MockFileSystem) WriteFile(_param0 string, _param1 []byte, _param2 os.FileMode) error { - ret := _m.ctrl.Call(_m, "WriteFile", _param0, _param1, _param2) +// WriteFile mocks base method +func (m *MockFileSystem) WriteFile(arg0 string, arg1 []byte, arg2 os.FileMode) error { + ret := m.ctrl.Call(m, "WriteFile", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockFileSystemRecorder) WriteFile(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFile", arg0, arg1, arg2) +// WriteFile indicates an expected call of WriteFile +func (mr *MockFileSystemMockRecorder) WriteFile(arg0, arg1, arg2 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFile", reflect.TypeOf((*MockFileSystem)(nil).WriteFile), arg0, arg1, arg2) } diff --git a/agent/api/mocks/api_mocks.go b/agent/api/mocks/api_mocks.go index 709ff7b9ccb..71762acc89c 100644 --- a/agent/api/mocks/api_mocks.go +++ b/agent/api/mocks/api_mocks.go @@ -11,184 +11,213 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/api (interfaces: ECSSDK,ECSSubmitStateSDK,ECSClient) +// Package mock_api is a generated GoMock package. package mock_api import ( + reflect "reflect" + api "github.com/aws/amazon-ecs-agent/agent/api" ecs "github.com/aws/amazon-ecs-agent/agent/ecs_client/model/ecs" gomock "github.com/golang/mock/gomock" ) -// Mock of ECSSDK interface +// MockECSSDK is a mock of ECSSDK interface type MockECSSDK struct { ctrl *gomock.Controller - recorder *_MockECSSDKRecorder + recorder *MockECSSDKMockRecorder } -// Recorder for MockECSSDK (not exported) -type _MockECSSDKRecorder struct { +// MockECSSDKMockRecorder is the mock recorder for MockECSSDK +type MockECSSDKMockRecorder struct { mock *MockECSSDK } +// NewMockECSSDK creates a new mock instance func NewMockECSSDK(ctrl *gomock.Controller) *MockECSSDK { mock := &MockECSSDK{ctrl: ctrl} - mock.recorder = &_MockECSSDKRecorder{mock} + mock.recorder = &MockECSSDKMockRecorder{mock} return mock } -func (_m *MockECSSDK) EXPECT() *_MockECSSDKRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockECSSDK) EXPECT() *MockECSSDKMockRecorder { + return m.recorder } -func (_m *MockECSSDK) CreateCluster(_param0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) { - ret := _m.ctrl.Call(_m, "CreateCluster", _param0) +// CreateCluster mocks base method +func (m *MockECSSDK) CreateCluster(arg0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) { + ret := m.ctrl.Call(m, "CreateCluster", arg0) ret0, _ := ret[0].(*ecs.CreateClusterOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSSDKRecorder) CreateCluster(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateCluster", arg0) +// CreateCluster indicates an expected call of CreateCluster +func (mr *MockECSSDKMockRecorder) CreateCluster(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockECSSDK)(nil).CreateCluster), arg0) } -func (_m *MockECSSDK) DiscoverPollEndpoint(_param0 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error) { - ret := _m.ctrl.Call(_m, "DiscoverPollEndpoint", _param0) +// DiscoverPollEndpoint mocks base method +func (m *MockECSSDK) DiscoverPollEndpoint(arg0 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error) { + ret := m.ctrl.Call(m, "DiscoverPollEndpoint", arg0) ret0, _ := ret[0].(*ecs.DiscoverPollEndpointOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSSDKRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoverPollEndpoint", arg0) +// DiscoverPollEndpoint indicates an expected call of DiscoverPollEndpoint +func (mr *MockECSSDKMockRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSSDK)(nil).DiscoverPollEndpoint), arg0) } -func (_m *MockECSSDK) RegisterContainerInstance(_param0 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error) { - ret := _m.ctrl.Call(_m, "RegisterContainerInstance", _param0) +// RegisterContainerInstance mocks base method +func (m *MockECSSDK) RegisterContainerInstance(arg0 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error) { + ret := m.ctrl.Call(m, "RegisterContainerInstance", arg0) ret0, _ := ret[0].(*ecs.RegisterContainerInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSSDKRecorder) RegisterContainerInstance(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RegisterContainerInstance", arg0) +// RegisterContainerInstance indicates an expected call of RegisterContainerInstance +func (mr *MockECSSDKMockRecorder) RegisterContainerInstance(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstance", reflect.TypeOf((*MockECSSDK)(nil).RegisterContainerInstance), arg0) } -// Mock of ECSSubmitStateSDK interface +// MockECSSubmitStateSDK is a mock of ECSSubmitStateSDK interface type MockECSSubmitStateSDK struct { ctrl *gomock.Controller - recorder *_MockECSSubmitStateSDKRecorder + recorder *MockECSSubmitStateSDKMockRecorder } -// Recorder for MockECSSubmitStateSDK (not exported) -type _MockECSSubmitStateSDKRecorder struct { +// MockECSSubmitStateSDKMockRecorder is the mock recorder for MockECSSubmitStateSDK +type MockECSSubmitStateSDKMockRecorder struct { mock *MockECSSubmitStateSDK } +// NewMockECSSubmitStateSDK creates a new mock instance func NewMockECSSubmitStateSDK(ctrl *gomock.Controller) *MockECSSubmitStateSDK { mock := &MockECSSubmitStateSDK{ctrl: ctrl} - mock.recorder = &_MockECSSubmitStateSDKRecorder{mock} + mock.recorder = &MockECSSubmitStateSDKMockRecorder{mock} return mock } -func (_m *MockECSSubmitStateSDK) EXPECT() *_MockECSSubmitStateSDKRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockECSSubmitStateSDK) EXPECT() *MockECSSubmitStateSDKMockRecorder { + return m.recorder } -func (_m *MockECSSubmitStateSDK) SubmitContainerStateChange(_param0 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error) { - ret := _m.ctrl.Call(_m, "SubmitContainerStateChange", _param0) +// SubmitContainerStateChange mocks base method +func (m *MockECSSubmitStateSDK) SubmitContainerStateChange(arg0 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error) { + ret := m.ctrl.Call(m, "SubmitContainerStateChange", arg0) ret0, _ := ret[0].(*ecs.SubmitContainerStateChangeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSSubmitStateSDKRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitContainerStateChange", arg0) +// SubmitContainerStateChange indicates an expected call of SubmitContainerStateChange +func (mr *MockECSSubmitStateSDKMockRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChange", reflect.TypeOf((*MockECSSubmitStateSDK)(nil).SubmitContainerStateChange), arg0) } -func (_m *MockECSSubmitStateSDK) SubmitTaskStateChange(_param0 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error) { - ret := _m.ctrl.Call(_m, "SubmitTaskStateChange", _param0) +// SubmitTaskStateChange mocks base method +func (m *MockECSSubmitStateSDK) SubmitTaskStateChange(arg0 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error) { + ret := m.ctrl.Call(m, "SubmitTaskStateChange", arg0) ret0, _ := ret[0].(*ecs.SubmitTaskStateChangeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSSubmitStateSDKRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitTaskStateChange", arg0) +// SubmitTaskStateChange indicates an expected call of SubmitTaskStateChange +func (mr *MockECSSubmitStateSDKMockRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChange", reflect.TypeOf((*MockECSSubmitStateSDK)(nil).SubmitTaskStateChange), arg0) } -// Mock of ECSClient interface +// MockECSClient is a mock of ECSClient interface type MockECSClient struct { ctrl *gomock.Controller - recorder *_MockECSClientRecorder + recorder *MockECSClientMockRecorder } -// Recorder for MockECSClient (not exported) -type _MockECSClientRecorder struct { +// MockECSClientMockRecorder is the mock recorder for MockECSClient +type MockECSClientMockRecorder struct { mock *MockECSClient } +// NewMockECSClient creates a new mock instance func NewMockECSClient(ctrl *gomock.Controller) *MockECSClient { mock := &MockECSClient{ctrl: ctrl} - mock.recorder = &_MockECSClientRecorder{mock} + mock.recorder = &MockECSClientMockRecorder{mock} return mock } -func (_m *MockECSClient) EXPECT() *_MockECSClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockECSClient) EXPECT() *MockECSClientMockRecorder { + return m.recorder } -func (_m *MockECSClient) DiscoverPollEndpoint(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "DiscoverPollEndpoint", _param0) +// DiscoverPollEndpoint mocks base method +func (m *MockECSClient) DiscoverPollEndpoint(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "DiscoverPollEndpoint", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSClientRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoverPollEndpoint", arg0) +// DiscoverPollEndpoint indicates an expected call of DiscoverPollEndpoint +func (mr *MockECSClientMockRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSClient)(nil).DiscoverPollEndpoint), arg0) } -func (_m *MockECSClient) DiscoverTelemetryEndpoint(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "DiscoverTelemetryEndpoint", _param0) +// DiscoverTelemetryEndpoint mocks base method +func (m *MockECSClient) DiscoverTelemetryEndpoint(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "DiscoverTelemetryEndpoint", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSClientRecorder) DiscoverTelemetryEndpoint(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoverTelemetryEndpoint", arg0) +// DiscoverTelemetryEndpoint indicates an expected call of DiscoverTelemetryEndpoint +func (mr *MockECSClientMockRecorder) DiscoverTelemetryEndpoint(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverTelemetryEndpoint", reflect.TypeOf((*MockECSClient)(nil).DiscoverTelemetryEndpoint), arg0) } -func (_m *MockECSClient) RegisterContainerInstance(_param0 string, _param1 []*ecs.Attribute) (string, error) { - ret := _m.ctrl.Call(_m, "RegisterContainerInstance", _param0, _param1) +// RegisterContainerInstance mocks base method +func (m *MockECSClient) RegisterContainerInstance(arg0 string, arg1 []*ecs.Attribute) (string, error) { + ret := m.ctrl.Call(m, "RegisterContainerInstance", arg0, arg1) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECSClientRecorder) RegisterContainerInstance(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RegisterContainerInstance", arg0, arg1) +// RegisterContainerInstance indicates an expected call of RegisterContainerInstance +func (mr *MockECSClientMockRecorder) RegisterContainerInstance(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstance", reflect.TypeOf((*MockECSClient)(nil).RegisterContainerInstance), arg0, arg1) } -func (_m *MockECSClient) SubmitContainerStateChange(_param0 api.ContainerStateChange) error { - ret := _m.ctrl.Call(_m, "SubmitContainerStateChange", _param0) +// SubmitContainerStateChange mocks base method +func (m *MockECSClient) SubmitContainerStateChange(arg0 api.ContainerStateChange) error { + ret := m.ctrl.Call(m, "SubmitContainerStateChange", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockECSClientRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitContainerStateChange", arg0) +// SubmitContainerStateChange indicates an expected call of SubmitContainerStateChange +func (mr *MockECSClientMockRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChange", reflect.TypeOf((*MockECSClient)(nil).SubmitContainerStateChange), arg0) } -func (_m *MockECSClient) SubmitTaskStateChange(_param0 api.TaskStateChange) error { - ret := _m.ctrl.Call(_m, "SubmitTaskStateChange", _param0) +// SubmitTaskStateChange mocks base method +func (m *MockECSClient) SubmitTaskStateChange(arg0 api.TaskStateChange) error { + ret := m.ctrl.Call(m, "SubmitTaskStateChange", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockECSClientRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitTaskStateChange", arg0) +// SubmitTaskStateChange indicates an expected call of SubmitTaskStateChange +func (mr *MockECSClientMockRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChange", reflect.TypeOf((*MockECSClient)(nil).SubmitTaskStateChange), arg0) } diff --git a/agent/app/factory/mocks/factory_mocks.go b/agent/app/factory/mocks/factory_mocks.go index 46e1b421d23..a89cad5e675 100644 --- a/agent/app/factory/mocks/factory_mocks.go +++ b/agent/app/factory/mocks/factory_mocks.go @@ -11,81 +11,92 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/app/factory (interfaces: StateManager,SaveableOption) +// Package mock_factory is a generated GoMock package. package mock_factory import ( + reflect "reflect" + config "github.com/aws/amazon-ecs-agent/agent/config" statemanager "github.com/aws/amazon-ecs-agent/agent/statemanager" gomock "github.com/golang/mock/gomock" ) -// Mock of StateManager interface +// MockStateManager is a mock of StateManager interface type MockStateManager struct { ctrl *gomock.Controller - recorder *_MockStateManagerRecorder + recorder *MockStateManagerMockRecorder } -// Recorder for MockStateManager (not exported) -type _MockStateManagerRecorder struct { +// MockStateManagerMockRecorder is the mock recorder for MockStateManager +type MockStateManagerMockRecorder struct { mock *MockStateManager } +// NewMockStateManager creates a new mock instance func NewMockStateManager(ctrl *gomock.Controller) *MockStateManager { mock := &MockStateManager{ctrl: ctrl} - mock.recorder = &_MockStateManagerRecorder{mock} + mock.recorder = &MockStateManagerMockRecorder{mock} return mock } -func (_m *MockStateManager) EXPECT() *_MockStateManagerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockStateManager) EXPECT() *MockStateManagerMockRecorder { + return m.recorder } -func (_m *MockStateManager) NewStateManager(_param0 *config.Config, _param1 ...statemanager.Option) (statemanager.StateManager, error) { - _s := []interface{}{_param0} - for _, _x := range _param1 { - _s = append(_s, _x) +// NewStateManager mocks base method +func (m *MockStateManager) NewStateManager(arg0 *config.Config, arg1 ...statemanager.Option) (statemanager.StateManager, error) { + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "NewStateManager", _s...) + ret := m.ctrl.Call(m, "NewStateManager", varargs...) ret0, _ := ret[0].(statemanager.StateManager) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockStateManagerRecorder) NewStateManager(arg0 interface{}, arg1 ...interface{}) *gomock.Call { - _s := append([]interface{}{arg0}, arg1...) - return _mr.mock.ctrl.RecordCall(_mr.mock, "NewStateManager", _s...) +// NewStateManager indicates an expected call of NewStateManager +func (mr *MockStateManagerMockRecorder) NewStateManager(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStateManager", reflect.TypeOf((*MockStateManager)(nil).NewStateManager), varargs...) } -// Mock of SaveableOption interface +// MockSaveableOption is a mock of SaveableOption interface type MockSaveableOption struct { ctrl *gomock.Controller - recorder *_MockSaveableOptionRecorder + recorder *MockSaveableOptionMockRecorder } -// Recorder for MockSaveableOption (not exported) -type _MockSaveableOptionRecorder struct { +// MockSaveableOptionMockRecorder is the mock recorder for MockSaveableOption +type MockSaveableOptionMockRecorder struct { mock *MockSaveableOption } +// NewMockSaveableOption creates a new mock instance func NewMockSaveableOption(ctrl *gomock.Controller) *MockSaveableOption { mock := &MockSaveableOption{ctrl: ctrl} - mock.recorder = &_MockSaveableOptionRecorder{mock} + mock.recorder = &MockSaveableOptionMockRecorder{mock} return mock } -func (_m *MockSaveableOption) EXPECT() *_MockSaveableOptionRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockSaveableOption) EXPECT() *MockSaveableOptionMockRecorder { + return m.recorder } -func (_m *MockSaveableOption) AddSaveable(_param0 string, _param1 statemanager.Saveable) statemanager.Option { - ret := _m.ctrl.Call(_m, "AddSaveable", _param0, _param1) +// AddSaveable mocks base method +func (m *MockSaveableOption) AddSaveable(arg0 string, arg1 statemanager.Saveable) statemanager.Option { + ret := m.ctrl.Call(m, "AddSaveable", arg0, arg1) ret0, _ := ret[0].(statemanager.Option) return ret0 } -func (_mr *_MockSaveableOptionRecorder) AddSaveable(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddSaveable", arg0, arg1) +// AddSaveable indicates an expected call of AddSaveable +func (mr *MockSaveableOptionMockRecorder) AddSaveable(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSaveable", reflect.TypeOf((*MockSaveableOption)(nil).AddSaveable), arg0, arg1) } diff --git a/agent/app/mocks/credentials_mocks.go b/agent/app/mocks/credentials_mocks.go index ee2294343f7..b401e67dc30 100644 --- a/agent/app/mocks/credentials_mocks.go +++ b/agent/app/mocks/credentials_mocks.go @@ -11,54 +11,63 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/aws-sdk-go/aws/credentials (interfaces: Provider) +// Package mock_credentials is a generated GoMock package. package mock_credentials import ( + reflect "reflect" + credentials "github.com/aws/aws-sdk-go/aws/credentials" gomock "github.com/golang/mock/gomock" ) -// Mock of Provider interface +// MockProvider is a mock of Provider interface type MockProvider struct { ctrl *gomock.Controller - recorder *_MockProviderRecorder + recorder *MockProviderMockRecorder } -// Recorder for MockProvider (not exported) -type _MockProviderRecorder struct { +// MockProviderMockRecorder is the mock recorder for MockProvider +type MockProviderMockRecorder struct { mock *MockProvider } +// NewMockProvider creates a new mock instance func NewMockProvider(ctrl *gomock.Controller) *MockProvider { mock := &MockProvider{ctrl: ctrl} - mock.recorder = &_MockProviderRecorder{mock} + mock.recorder = &MockProviderMockRecorder{mock} return mock } -func (_m *MockProvider) EXPECT() *_MockProviderRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockProvider) EXPECT() *MockProviderMockRecorder { + return m.recorder } -func (_m *MockProvider) IsExpired() bool { - ret := _m.ctrl.Call(_m, "IsExpired") +// IsExpired mocks base method +func (m *MockProvider) IsExpired() bool { + ret := m.ctrl.Call(m, "IsExpired") ret0, _ := ret[0].(bool) return ret0 } -func (_mr *_MockProviderRecorder) IsExpired() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "IsExpired") +// IsExpired indicates an expected call of IsExpired +func (mr *MockProviderMockRecorder) IsExpired() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExpired", reflect.TypeOf((*MockProvider)(nil).IsExpired)) } -func (_m *MockProvider) Retrieve() (credentials.Value, error) { - ret := _m.ctrl.Call(_m, "Retrieve") +// Retrieve mocks base method +func (m *MockProvider) Retrieve() (credentials.Value, error) { + ret := m.ctrl.Call(m, "Retrieve") ret0, _ := ret[0].(credentials.Value) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockProviderRecorder) Retrieve() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Retrieve") +// Retrieve indicates an expected call of Retrieve +func (mr *MockProviderMockRecorder) Retrieve() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retrieve", reflect.TypeOf((*MockProvider)(nil).Retrieve)) } diff --git a/agent/app/oswrapper/mocks/oswrapper_mocks.go b/agent/app/oswrapper/mocks/oswrapper_mocks.go index 002e07710f1..bff4b6963a7 100644 --- a/agent/app/oswrapper/mocks/oswrapper_mocks.go +++ b/agent/app/oswrapper/mocks/oswrapper_mocks.go @@ -11,42 +11,49 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/app/oswrapper (interfaces: OS) +// Package mock_oswrapper is a generated GoMock package. package mock_oswrapper import ( + reflect "reflect" + gomock "github.com/golang/mock/gomock" ) -// Mock of OS interface +// MockOS is a mock of OS interface type MockOS struct { ctrl *gomock.Controller - recorder *_MockOSRecorder + recorder *MockOSMockRecorder } -// Recorder for MockOS (not exported) -type _MockOSRecorder struct { +// MockOSMockRecorder is the mock recorder for MockOS +type MockOSMockRecorder struct { mock *MockOS } +// NewMockOS creates a new mock instance func NewMockOS(ctrl *gomock.Controller) *MockOS { mock := &MockOS{ctrl: ctrl} - mock.recorder = &_MockOSRecorder{mock} + mock.recorder = &MockOSMockRecorder{mock} return mock } -func (_m *MockOS) EXPECT() *_MockOSRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockOS) EXPECT() *MockOSMockRecorder { + return m.recorder } -func (_m *MockOS) Getpid() int { - ret := _m.ctrl.Call(_m, "Getpid") +// Getpid mocks base method +func (m *MockOS) Getpid() int { + ret := m.ctrl.Call(m, "Getpid") ret0, _ := ret[0].(int) return ret0 } -func (_mr *_MockOSRecorder) Getpid() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Getpid") +// Getpid indicates an expected call of Getpid +func (mr *MockOSMockRecorder) Getpid() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getpid", reflect.TypeOf((*MockOS)(nil).Getpid)) } diff --git a/agent/async/mocks/async_mocks.go b/agent/async/mocks/async_mocks.go index 157f1111dae..00067531d3a 100644 --- a/agent/async/mocks/async_mocks.go +++ b/agent/async/mocks/async_mocks.go @@ -11,52 +11,61 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/async (interfaces: Cache) +// Package mock_async is a generated GoMock package. package mock_async import ( + reflect "reflect" + async "github.com/aws/amazon-ecs-agent/agent/async" gomock "github.com/golang/mock/gomock" ) -// Mock of Cache interface +// MockCache is a mock of Cache interface type MockCache struct { ctrl *gomock.Controller - recorder *_MockCacheRecorder + recorder *MockCacheMockRecorder } -// Recorder for MockCache (not exported) -type _MockCacheRecorder struct { +// MockCacheMockRecorder is the mock recorder for MockCache +type MockCacheMockRecorder struct { mock *MockCache } +// NewMockCache creates a new mock instance func NewMockCache(ctrl *gomock.Controller) *MockCache { mock := &MockCache{ctrl: ctrl} - mock.recorder = &_MockCacheRecorder{mock} + mock.recorder = &MockCacheMockRecorder{mock} return mock } -func (_m *MockCache) EXPECT() *_MockCacheRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockCache) EXPECT() *MockCacheMockRecorder { + return m.recorder } -func (_m *MockCache) Get(_param0 string) (async.Value, bool) { - ret := _m.ctrl.Call(_m, "Get", _param0) +// Get mocks base method +func (m *MockCache) Get(arg0 string) (async.Value, bool) { + ret := m.ctrl.Call(m, "Get", arg0) ret0, _ := ret[0].(async.Value) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockCacheRecorder) Get(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0) +// Get indicates an expected call of Get +func (mr *MockCacheMockRecorder) Get(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCache)(nil).Get), arg0) } -func (_m *MockCache) Set(_param0 string, _param1 async.Value) { - _m.ctrl.Call(_m, "Set", _param0, _param1) +// Set mocks base method +func (m *MockCache) Set(arg0 string, arg1 async.Value) { + m.ctrl.Call(m, "Set", arg0, arg1) } -func (_mr *_MockCacheRecorder) Set(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Set", arg0, arg1) +// Set indicates an expected call of Set +func (mr *MockCacheMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCache)(nil).Set), arg0, arg1) } diff --git a/agent/containermetadata/mocks/containermetadata_mocks.go b/agent/containermetadata/mocks/containermetadata_mocks.go index 13816f41658..5dbbd804c6a 100644 --- a/agent/containermetadata/mocks/containermetadata_mocks.go +++ b/agent/containermetadata/mocks/containermetadata_mocks.go @@ -11,105 +11,121 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/containermetadata (interfaces: Manager,DockerMetadataClient) +// Package mock_containermetadata is a generated GoMock package. package mock_containermetadata import ( + reflect "reflect" time "time" go_dockerclient "github.com/fsouza/go-dockerclient" gomock "github.com/golang/mock/gomock" ) -// Mock of Manager interface +// MockManager is a mock of Manager interface type MockManager struct { ctrl *gomock.Controller - recorder *_MockManagerRecorder + recorder *MockManagerMockRecorder } -// Recorder for MockManager (not exported) -type _MockManagerRecorder struct { +// MockManagerMockRecorder is the mock recorder for MockManager +type MockManagerMockRecorder struct { mock *MockManager } +// NewMockManager creates a new mock instance func NewMockManager(ctrl *gomock.Controller) *MockManager { mock := &MockManager{ctrl: ctrl} - mock.recorder = &_MockManagerRecorder{mock} + mock.recorder = &MockManagerMockRecorder{mock} return mock } -func (_m *MockManager) EXPECT() *_MockManagerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockManager) EXPECT() *MockManagerMockRecorder { + return m.recorder } -func (_m *MockManager) Clean(_param0 string) error { - ret := _m.ctrl.Call(_m, "Clean", _param0) +// Clean mocks base method +func (m *MockManager) Clean(arg0 string) error { + ret := m.ctrl.Call(m, "Clean", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockManagerRecorder) Clean(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Clean", arg0) +// Clean indicates an expected call of Clean +func (mr *MockManagerMockRecorder) Clean(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clean", reflect.TypeOf((*MockManager)(nil).Clean), arg0) } -func (_m *MockManager) Create(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 string) error { - ret := _m.ctrl.Call(_m, "Create", _param0, _param1, _param2, _param3) +// Create mocks base method +func (m *MockManager) Create(arg0 *go_dockerclient.Config, arg1 *go_dockerclient.HostConfig, arg2, arg3 string) error { + ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockManagerRecorder) Create(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2, arg3) +// Create indicates an expected call of Create +func (mr *MockManagerMockRecorder) Create(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockManager)(nil).Create), arg0, arg1, arg2, arg3) } -func (_m *MockManager) SetContainerInstanceARN(_param0 string) { - _m.ctrl.Call(_m, "SetContainerInstanceARN", _param0) +// SetContainerInstanceARN mocks base method +func (m *MockManager) SetContainerInstanceARN(arg0 string) { + m.ctrl.Call(m, "SetContainerInstanceARN", arg0) } -func (_mr *_MockManagerRecorder) SetContainerInstanceARN(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SetContainerInstanceARN", arg0) +// SetContainerInstanceARN indicates an expected call of SetContainerInstanceARN +func (mr *MockManagerMockRecorder) SetContainerInstanceARN(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerInstanceARN", reflect.TypeOf((*MockManager)(nil).SetContainerInstanceARN), arg0) } -func (_m *MockManager) Update(_param0 string, _param1 string, _param2 string) error { - ret := _m.ctrl.Call(_m, "Update", _param0, _param1, _param2) +// Update mocks base method +func (m *MockManager) Update(arg0, arg1, arg2 string) error { + ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockManagerRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2) +// Update indicates an expected call of Update +func (mr *MockManagerMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockManager)(nil).Update), arg0, arg1, arg2) } -// Mock of DockerMetadataClient interface +// MockDockerMetadataClient is a mock of DockerMetadataClient interface type MockDockerMetadataClient struct { ctrl *gomock.Controller - recorder *_MockDockerMetadataClientRecorder + recorder *MockDockerMetadataClientMockRecorder } -// Recorder for MockDockerMetadataClient (not exported) -type _MockDockerMetadataClientRecorder struct { +// MockDockerMetadataClientMockRecorder is the mock recorder for MockDockerMetadataClient +type MockDockerMetadataClientMockRecorder struct { mock *MockDockerMetadataClient } +// NewMockDockerMetadataClient creates a new mock instance func NewMockDockerMetadataClient(ctrl *gomock.Controller) *MockDockerMetadataClient { mock := &MockDockerMetadataClient{ctrl: ctrl} - mock.recorder = &_MockDockerMetadataClientRecorder{mock} + mock.recorder = &MockDockerMetadataClientMockRecorder{mock} return mock } -func (_m *MockDockerMetadataClient) EXPECT() *_MockDockerMetadataClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockDockerMetadataClient) EXPECT() *MockDockerMetadataClientMockRecorder { + return m.recorder } -func (_m *MockDockerMetadataClient) InspectContainer(_param0 string, _param1 time.Duration) (*go_dockerclient.Container, error) { - ret := _m.ctrl.Call(_m, "InspectContainer", _param0, _param1) +// InspectContainer mocks base method +func (m *MockDockerMetadataClient) InspectContainer(arg0 string, arg1 time.Duration) (*go_dockerclient.Container, error) { + ret := m.ctrl.Call(m, "InspectContainer", arg0, arg1) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockDockerMetadataClientRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) +// InspectContainer indicates an expected call of InspectContainer +func (mr *MockDockerMetadataClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockDockerMetadataClient)(nil).InspectContainer), arg0, arg1) } diff --git a/agent/credentials/mocks/credentials_mocks.go b/agent/credentials/mocks/credentials_mocks.go index dd34c181783..ba7096a24b6 100644 --- a/agent/credentials/mocks/credentials_mocks.go +++ b/agent/credentials/mocks/credentials_mocks.go @@ -11,62 +11,73 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/credentials (interfaces: Manager) +// Package mock_credentials is a generated GoMock package. package mock_credentials import ( + reflect "reflect" + credentials "github.com/aws/amazon-ecs-agent/agent/credentials" gomock "github.com/golang/mock/gomock" ) -// Mock of Manager interface +// MockManager is a mock of Manager interface type MockManager struct { ctrl *gomock.Controller - recorder *_MockManagerRecorder + recorder *MockManagerMockRecorder } -// Recorder for MockManager (not exported) -type _MockManagerRecorder struct { +// MockManagerMockRecorder is the mock recorder for MockManager +type MockManagerMockRecorder struct { mock *MockManager } +// NewMockManager creates a new mock instance func NewMockManager(ctrl *gomock.Controller) *MockManager { mock := &MockManager{ctrl: ctrl} - mock.recorder = &_MockManagerRecorder{mock} + mock.recorder = &MockManagerMockRecorder{mock} return mock } -func (_m *MockManager) EXPECT() *_MockManagerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockManager) EXPECT() *MockManagerMockRecorder { + return m.recorder } -func (_m *MockManager) GetTaskCredentials(_param0 string) (credentials.TaskIAMRoleCredentials, bool) { - ret := _m.ctrl.Call(_m, "GetTaskCredentials", _param0) +// GetTaskCredentials mocks base method +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 } -func (_mr *_MockManagerRecorder) GetTaskCredentials(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTaskCredentials", arg0) +// GetTaskCredentials indicates an expected call of GetTaskCredentials +func (mr *MockManagerMockRecorder) GetTaskCredentials(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskCredentials", reflect.TypeOf((*MockManager)(nil).GetTaskCredentials), arg0) } -func (_m *MockManager) RemoveCredentials(_param0 string) { - _m.ctrl.Call(_m, "RemoveCredentials", _param0) +// RemoveCredentials mocks base method +func (m *MockManager) RemoveCredentials(arg0 string) { + m.ctrl.Call(m, "RemoveCredentials", arg0) } -func (_mr *_MockManagerRecorder) RemoveCredentials(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveCredentials", arg0) +// RemoveCredentials indicates an expected call of RemoveCredentials +func (mr *MockManagerMockRecorder) RemoveCredentials(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCredentials", reflect.TypeOf((*MockManager)(nil).RemoveCredentials), arg0) } -func (_m *MockManager) SetTaskCredentials(_param0 credentials.TaskIAMRoleCredentials) error { - ret := _m.ctrl.Call(_m, "SetTaskCredentials", _param0) +// SetTaskCredentials mocks base method +func (m *MockManager) SetTaskCredentials(arg0 credentials.TaskIAMRoleCredentials) error { + ret := m.ctrl.Call(m, "SetTaskCredentials", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockManagerRecorder) SetTaskCredentials(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SetTaskCredentials", arg0) +// SetTaskCredentials indicates an expected call of SetTaskCredentials +func (mr *MockManagerMockRecorder) SetTaskCredentials(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTaskCredentials", reflect.TypeOf((*MockManager)(nil).SetTaskCredentials), arg0) } diff --git a/agent/ec2/http/mocks/http_mocks.go b/agent/ec2/http/mocks/http_mocks.go index 6f7fe7b1642..abf1394e497 100644 --- a/agent/ec2/http/mocks/http_mocks.go +++ b/agent/ec2/http/mocks/http_mocks.go @@ -11,45 +11,51 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/ec2/http (interfaces: Client) +// Package mock_http is a generated GoMock package. package mock_http import ( http "net/http" + reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// Mock of Client interface +// MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller - recorder *_MockClientRecorder + recorder *MockClientMockRecorder } -// Recorder for MockClient (not exported) -type _MockClientRecorder struct { +// MockClientMockRecorder is the mock recorder for MockClient +type MockClientMockRecorder struct { mock *MockClient } +// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} - mock.recorder = &_MockClientRecorder{mock} + mock.recorder = &MockClientMockRecorder{mock} return mock } -func (_m *MockClient) EXPECT() *_MockClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder } -func (_m *MockClient) Get(_param0 string) (*http.Response, error) { - ret := _m.ctrl.Call(_m, "Get", _param0) +// Get mocks base method +func (m *MockClient) Get(arg0 string) (*http.Response, error) { + ret := m.ctrl.Call(m, "Get", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockClientRecorder) Get(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0) +// Get indicates an expected call of Get +func (mr *MockClientMockRecorder) Get(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0) } diff --git a/agent/ec2/mocks/ec2_mocks.go b/agent/ec2/mocks/ec2_mocks.go index b7e2c42c02a..38bdead4836 100644 --- a/agent/ec2/mocks/ec2_mocks.go +++ b/agent/ec2/mocks/ec2_mocks.go @@ -11,165 +11,192 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/ec2 (interfaces: EC2MetadataClient,HttpClient) +// Package mock_ec2 is a generated GoMock package. package mock_ec2 import ( + reflect "reflect" + ec2 "github.com/aws/amazon-ecs-agent/agent/ec2" ec2metadata "github.com/aws/aws-sdk-go/aws/ec2metadata" gomock "github.com/golang/mock/gomock" ) -// Mock of EC2MetadataClient interface +// MockEC2MetadataClient is a mock of EC2MetadataClient interface type MockEC2MetadataClient struct { ctrl *gomock.Controller - recorder *_MockEC2MetadataClientRecorder + recorder *MockEC2MetadataClientMockRecorder } -// Recorder for MockEC2MetadataClient (not exported) -type _MockEC2MetadataClientRecorder struct { +// MockEC2MetadataClientMockRecorder is the mock recorder for MockEC2MetadataClient +type MockEC2MetadataClientMockRecorder struct { mock *MockEC2MetadataClient } +// NewMockEC2MetadataClient creates a new mock instance func NewMockEC2MetadataClient(ctrl *gomock.Controller) *MockEC2MetadataClient { mock := &MockEC2MetadataClient{ctrl: ctrl} - mock.recorder = &_MockEC2MetadataClientRecorder{mock} + mock.recorder = &MockEC2MetadataClientMockRecorder{mock} return mock } -func (_m *MockEC2MetadataClient) EXPECT() *_MockEC2MetadataClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockEC2MetadataClient) EXPECT() *MockEC2MetadataClientMockRecorder { + return m.recorder } -func (_m *MockEC2MetadataClient) DefaultCredentials() (*ec2.RoleCredentials, error) { - ret := _m.ctrl.Call(_m, "DefaultCredentials") +// DefaultCredentials mocks base method +func (m *MockEC2MetadataClient) DefaultCredentials() (*ec2.RoleCredentials, error) { + ret := m.ctrl.Call(m, "DefaultCredentials") ret0, _ := ret[0].(*ec2.RoleCredentials) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockEC2MetadataClientRecorder) DefaultCredentials() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DefaultCredentials") +// DefaultCredentials indicates an expected call of DefaultCredentials +func (mr *MockEC2MetadataClientMockRecorder) DefaultCredentials() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultCredentials", reflect.TypeOf((*MockEC2MetadataClient)(nil).DefaultCredentials)) } -func (_m *MockEC2MetadataClient) GetDynamicData(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "GetDynamicData", _param0) +// GetDynamicData mocks base method +func (m *MockEC2MetadataClient) GetDynamicData(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "GetDynamicData", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockEC2MetadataClientRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDynamicData", arg0) +// GetDynamicData indicates an expected call of GetDynamicData +func (mr *MockEC2MetadataClientMockRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicData", reflect.TypeOf((*MockEC2MetadataClient)(nil).GetDynamicData), arg0) } -func (_m *MockEC2MetadataClient) GetMetadata(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "GetMetadata", _param0) +// GetMetadata mocks base method +func (m *MockEC2MetadataClient) GetMetadata(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "GetMetadata", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockEC2MetadataClientRecorder) GetMetadata(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetMetadata", arg0) +// GetMetadata indicates an expected call of GetMetadata +func (mr *MockEC2MetadataClientMockRecorder) GetMetadata(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockEC2MetadataClient)(nil).GetMetadata), arg0) } -func (_m *MockEC2MetadataClient) InstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { - ret := _m.ctrl.Call(_m, "InstanceIdentityDocument") +// InstanceIdentityDocument mocks base method +func (m *MockEC2MetadataClient) InstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { + ret := m.ctrl.Call(m, "InstanceIdentityDocument") ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockEC2MetadataClientRecorder) InstanceIdentityDocument() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InstanceIdentityDocument") +// InstanceIdentityDocument indicates an expected call of InstanceIdentityDocument +func (mr *MockEC2MetadataClientMockRecorder) InstanceIdentityDocument() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIdentityDocument", reflect.TypeOf((*MockEC2MetadataClient)(nil).InstanceIdentityDocument)) } -func (_m *MockEC2MetadataClient) PrimaryENIMAC() (string, error) { - ret := _m.ctrl.Call(_m, "PrimaryENIMAC") +// PrimaryENIMAC mocks base method +func (m *MockEC2MetadataClient) PrimaryENIMAC() (string, error) { + ret := m.ctrl.Call(m, "PrimaryENIMAC") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockEC2MetadataClientRecorder) PrimaryENIMAC() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "PrimaryENIMAC") +// PrimaryENIMAC indicates an expected call of PrimaryENIMAC +func (mr *MockEC2MetadataClientMockRecorder) PrimaryENIMAC() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryENIMAC", reflect.TypeOf((*MockEC2MetadataClient)(nil).PrimaryENIMAC)) } -func (_m *MockEC2MetadataClient) SubnetID(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "SubnetID", _param0) +// SubnetID mocks base method +func (m *MockEC2MetadataClient) SubnetID(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "SubnetID", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockEC2MetadataClientRecorder) SubnetID(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SubnetID", arg0) +// SubnetID indicates an expected call of SubnetID +func (mr *MockEC2MetadataClientMockRecorder) SubnetID(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubnetID", reflect.TypeOf((*MockEC2MetadataClient)(nil).SubnetID), arg0) } -func (_m *MockEC2MetadataClient) VPCID(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "VPCID", _param0) +// VPCID mocks base method +func (m *MockEC2MetadataClient) VPCID(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "VPCID", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockEC2MetadataClientRecorder) VPCID(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "VPCID", arg0) +// VPCID indicates an expected call of VPCID +func (mr *MockEC2MetadataClientMockRecorder) VPCID(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VPCID", reflect.TypeOf((*MockEC2MetadataClient)(nil).VPCID), arg0) } -// Mock of HttpClient interface +// MockHttpClient is a mock of HttpClient interface type MockHttpClient struct { ctrl *gomock.Controller - recorder *_MockHttpClientRecorder + recorder *MockHttpClientMockRecorder } -// Recorder for MockHttpClient (not exported) -type _MockHttpClientRecorder struct { +// MockHttpClientMockRecorder is the mock recorder for MockHttpClient +type MockHttpClientMockRecorder struct { mock *MockHttpClient } +// NewMockHttpClient creates a new mock instance func NewMockHttpClient(ctrl *gomock.Controller) *MockHttpClient { mock := &MockHttpClient{ctrl: ctrl} - mock.recorder = &_MockHttpClientRecorder{mock} + mock.recorder = &MockHttpClientMockRecorder{mock} return mock } -func (_m *MockHttpClient) EXPECT() *_MockHttpClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockHttpClient) EXPECT() *MockHttpClientMockRecorder { + return m.recorder } -func (_m *MockHttpClient) GetDynamicData(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "GetDynamicData", _param0) +// GetDynamicData mocks base method +func (m *MockHttpClient) GetDynamicData(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "GetDynamicData", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockHttpClientRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDynamicData", arg0) +// GetDynamicData indicates an expected call of GetDynamicData +func (mr *MockHttpClientMockRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicData", reflect.TypeOf((*MockHttpClient)(nil).GetDynamicData), arg0) } -func (_m *MockHttpClient) GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { - ret := _m.ctrl.Call(_m, "GetInstanceIdentityDocument") +// GetInstanceIdentityDocument mocks base method +func (m *MockHttpClient) GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { + ret := m.ctrl.Call(m, "GetInstanceIdentityDocument") ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockHttpClientRecorder) GetInstanceIdentityDocument() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetInstanceIdentityDocument") +// GetInstanceIdentityDocument indicates an expected call of GetInstanceIdentityDocument +func (mr *MockHttpClientMockRecorder) GetInstanceIdentityDocument() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceIdentityDocument", reflect.TypeOf((*MockHttpClient)(nil).GetInstanceIdentityDocument)) } -func (_m *MockHttpClient) GetMetadata(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "GetMetadata", _param0) +// GetMetadata mocks base method +func (m *MockHttpClient) GetMetadata(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "GetMetadata", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockHttpClientRecorder) GetMetadata(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetMetadata", arg0) +// GetMetadata indicates an expected call of GetMetadata +func (mr *MockHttpClientMockRecorder) GetMetadata(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockHttpClient)(nil).GetMetadata), arg0) } diff --git a/agent/ecr/mocks/ecr_mocks.go b/agent/ecr/mocks/ecr_mocks.go index a79a9c55788..3b70637ec00 100644 --- a/agent/ecr/mocks/ecr_mocks.go +++ b/agent/ecr/mocks/ecr_mocks.go @@ -11,118 +11,135 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/ecr (interfaces: ECRSDK,ECRFactory,ECRClient) +// Package mock_ecr is a generated GoMock package. package mock_ecr import ( - ecr0 "github.com/aws/amazon-ecs-agent/agent/ecr" - ecr "github.com/aws/amazon-ecs-agent/agent/ecr/model/ecr" + reflect "reflect" + + ecr "github.com/aws/amazon-ecs-agent/agent/ecr" + ecr0 "github.com/aws/amazon-ecs-agent/agent/ecr/model/ecr" gomock "github.com/golang/mock/gomock" ) -// Mock of ECRSDK interface +// MockECRSDK is a mock of ECRSDK interface type MockECRSDK struct { ctrl *gomock.Controller - recorder *_MockECRSDKRecorder + recorder *MockECRSDKMockRecorder } -// Recorder for MockECRSDK (not exported) -type _MockECRSDKRecorder struct { +// MockECRSDKMockRecorder is the mock recorder for MockECRSDK +type MockECRSDKMockRecorder struct { mock *MockECRSDK } +// NewMockECRSDK creates a new mock instance func NewMockECRSDK(ctrl *gomock.Controller) *MockECRSDK { mock := &MockECRSDK{ctrl: ctrl} - mock.recorder = &_MockECRSDKRecorder{mock} + mock.recorder = &MockECRSDKMockRecorder{mock} return mock } -func (_m *MockECRSDK) EXPECT() *_MockECRSDKRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockECRSDK) EXPECT() *MockECRSDKMockRecorder { + return m.recorder } -func (_m *MockECRSDK) GetAuthorizationToken(_param0 *ecr.GetAuthorizationTokenInput) (*ecr.GetAuthorizationTokenOutput, error) { - ret := _m.ctrl.Call(_m, "GetAuthorizationToken", _param0) - ret0, _ := ret[0].(*ecr.GetAuthorizationTokenOutput) +// GetAuthorizationToken mocks base method +func (m *MockECRSDK) GetAuthorizationToken(arg0 *ecr0.GetAuthorizationTokenInput) (*ecr0.GetAuthorizationTokenOutput, error) { + ret := m.ctrl.Call(m, "GetAuthorizationToken", arg0) + ret0, _ := ret[0].(*ecr0.GetAuthorizationTokenOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECRSDKRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAuthorizationToken", arg0) +// GetAuthorizationToken indicates an expected call of GetAuthorizationToken +func (mr *MockECRSDKMockRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizationToken", reflect.TypeOf((*MockECRSDK)(nil).GetAuthorizationToken), arg0) } -// Mock of ECRFactory interface +// MockECRFactory is a mock of ECRFactory interface type MockECRFactory struct { ctrl *gomock.Controller - recorder *_MockECRFactoryRecorder + recorder *MockECRFactoryMockRecorder } -// Recorder for MockECRFactory (not exported) -type _MockECRFactoryRecorder struct { +// MockECRFactoryMockRecorder is the mock recorder for MockECRFactory +type MockECRFactoryMockRecorder struct { mock *MockECRFactory } +// NewMockECRFactory creates a new mock instance func NewMockECRFactory(ctrl *gomock.Controller) *MockECRFactory { mock := &MockECRFactory{ctrl: ctrl} - mock.recorder = &_MockECRFactoryRecorder{mock} + mock.recorder = &MockECRFactoryMockRecorder{mock} return mock } -func (_m *MockECRFactory) EXPECT() *_MockECRFactoryRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockECRFactory) EXPECT() *MockECRFactoryMockRecorder { + return m.recorder } -func (_m *MockECRFactory) GetClient(_param0 string, _param1 string) ecr0.ECRClient { - ret := _m.ctrl.Call(_m, "GetClient", _param0, _param1) - ret0, _ := ret[0].(ecr0.ECRClient) +// GetClient mocks base method +func (m *MockECRFactory) GetClient(arg0, arg1 string) ecr.ECRClient { + ret := m.ctrl.Call(m, "GetClient", arg0, arg1) + ret0, _ := ret[0].(ecr.ECRClient) return ret0 } -func (_mr *_MockECRFactoryRecorder) GetClient(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetClient", arg0, arg1) +// GetClient indicates an expected call of GetClient +func (mr *MockECRFactoryMockRecorder) GetClient(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockECRFactory)(nil).GetClient), arg0, arg1) } -// Mock of ECRClient interface +// MockECRClient is a mock of ECRClient interface type MockECRClient struct { ctrl *gomock.Controller - recorder *_MockECRClientRecorder + recorder *MockECRClientMockRecorder } -// Recorder for MockECRClient (not exported) -type _MockECRClientRecorder struct { +// MockECRClientMockRecorder is the mock recorder for MockECRClient +type MockECRClientMockRecorder struct { mock *MockECRClient } +// NewMockECRClient creates a new mock instance func NewMockECRClient(ctrl *gomock.Controller) *MockECRClient { mock := &MockECRClient{ctrl: ctrl} - mock.recorder = &_MockECRClientRecorder{mock} + mock.recorder = &MockECRClientMockRecorder{mock} return mock } -func (_m *MockECRClient) EXPECT() *_MockECRClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockECRClient) EXPECT() *MockECRClientMockRecorder { + return m.recorder } -func (_m *MockECRClient) GetAuthorizationToken(_param0 string) (*ecr.AuthorizationData, error) { - ret := _m.ctrl.Call(_m, "GetAuthorizationToken", _param0) - ret0, _ := ret[0].(*ecr.AuthorizationData) +// GetAuthorizationToken mocks base method +func (m *MockECRClient) GetAuthorizationToken(arg0 string) (*ecr0.AuthorizationData, error) { + ret := m.ctrl.Call(m, "GetAuthorizationToken", arg0) + ret0, _ := ret[0].(*ecr0.AuthorizationData) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockECRClientRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAuthorizationToken", arg0) +// GetAuthorizationToken indicates an expected call of GetAuthorizationToken +func (mr *MockECRClientMockRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizationToken", reflect.TypeOf((*MockECRClient)(nil).GetAuthorizationToken), arg0) } -func (_m *MockECRClient) IsTokenValid(_param0 *ecr.AuthorizationData) bool { - ret := _m.ctrl.Call(_m, "IsTokenValid", _param0) +// IsTokenValid mocks base method +func (m *MockECRClient) IsTokenValid(arg0 *ecr0.AuthorizationData) bool { + ret := m.ctrl.Call(m, "IsTokenValid", arg0) ret0, _ := ret[0].(bool) return ret0 } -func (_mr *_MockECRClientRecorder) IsTokenValid(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "IsTokenValid", arg0) +// IsTokenValid indicates an expected call of IsTokenValid +func (mr *MockECRClientMockRecorder) IsTokenValid(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTokenValid", reflect.TypeOf((*MockECRClient)(nil).IsTokenValid), arg0) } diff --git a/agent/ecscni/mocks/ecscni_mocks.go b/agent/ecscni/mocks/ecscni_mocks.go index 3d39e70f98c..e50b9a20163 100644 --- a/agent/ecscni/mocks/ecscni_mocks.go +++ b/agent/ecscni/mocks/ecscni_mocks.go @@ -11,56 +11,65 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/ecscni (interfaces: CNIClient) +// Package mock_ecscni is a generated GoMock package. package mock_ecscni import ( + reflect "reflect" + ecscni "github.com/aws/amazon-ecs-agent/agent/ecscni" gomock "github.com/golang/mock/gomock" ) -// Mock of CNIClient interface +// MockCNIClient is a mock of CNIClient interface type MockCNIClient struct { ctrl *gomock.Controller - recorder *_MockCNIClientRecorder + recorder *MockCNIClientMockRecorder } -// Recorder for MockCNIClient (not exported) -type _MockCNIClientRecorder struct { +// MockCNIClientMockRecorder is the mock recorder for MockCNIClient +type MockCNIClientMockRecorder struct { mock *MockCNIClient } +// NewMockCNIClient creates a new mock instance func NewMockCNIClient(ctrl *gomock.Controller) *MockCNIClient { mock := &MockCNIClient{ctrl: ctrl} - mock.recorder = &_MockCNIClientRecorder{mock} + mock.recorder = &MockCNIClientMockRecorder{mock} return mock } -func (_m *MockCNIClient) EXPECT() *_MockCNIClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockCNIClient) EXPECT() *MockCNIClientMockRecorder { + return m.recorder } -func (_m *MockCNIClient) Capabilities(_param0 string) ([]string, error) { - ret := _m.ctrl.Call(_m, "Capabilities", _param0) +// Capabilities mocks base method +func (m *MockCNIClient) Capabilities(arg0 string) ([]string, error) { + ret := m.ctrl.Call(m, "Capabilities", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockCNIClientRecorder) Capabilities(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Capabilities", arg0) +// Capabilities indicates an expected call of Capabilities +func (mr *MockCNIClientMockRecorder) Capabilities(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Capabilities", reflect.TypeOf((*MockCNIClient)(nil).Capabilities), arg0) } -func (_m *MockCNIClient) CleanupNS(_param0 *ecscni.Config) error { - ret := _m.ctrl.Call(_m, "CleanupNS", _param0) +// CleanupNS mocks base method +func (m *MockCNIClient) CleanupNS(arg0 *ecscni.Config) error { + ret := m.ctrl.Call(m, "CleanupNS", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockCNIClientRecorder) CleanupNS(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CleanupNS", arg0) +// CleanupNS indicates an expected call of CleanupNS +func (mr *MockCNIClientMockRecorder) CleanupNS(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanupNS", reflect.TypeOf((*MockCNIClient)(nil).CleanupNS), arg0) } func (_m *MockCNIClient) ReleaseIPResource(_param0 *ecscni.Config) error { @@ -79,17 +88,20 @@ func (_m *MockCNIClient) SetupNS(_param0 *ecscni.Config) error { return ret0 } -func (_mr *_MockCNIClientRecorder) SetupNS(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SetupNS", arg0) +// SetupNS indicates an expected call of SetupNS +func (mr *MockCNIClientMockRecorder) SetupNS(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupNS", reflect.TypeOf((*MockCNIClient)(nil).SetupNS), arg0) } -func (_m *MockCNIClient) Version(_param0 string) (string, error) { - ret := _m.ctrl.Call(_m, "Version", _param0) +// Version mocks base method +func (m *MockCNIClient) Version(arg0 string) (string, error) { + ret := m.ctrl.Call(m, "Version", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockCNIClientRecorder) Version(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Version", arg0) +// Version indicates an expected call of Version +func (mr *MockCNIClientMockRecorder) Version(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockCNIClient)(nil).Version), arg0) } diff --git a/agent/ecscni/mocks_cnitypes/result_mocks.go b/agent/ecscni/mocks_cnitypes/result_mocks.go index c0dffa7bd99..6b008168c0b 100644 --- a/agent/ecscni/mocks_cnitypes/result_mocks.go +++ b/agent/ecscni/mocks_cnitypes/result_mocks.go @@ -11,74 +11,87 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/containernetworking/cni/pkg/types (interfaces: Result) +// Package mock_types is a generated GoMock package. package mock_types import ( + reflect "reflect" + types "github.com/containernetworking/cni/pkg/types" gomock "github.com/golang/mock/gomock" ) -// Mock of Result interface +// MockResult is a mock of Result interface type MockResult struct { ctrl *gomock.Controller - recorder *_MockResultRecorder + recorder *MockResultMockRecorder } -// Recorder for MockResult (not exported) -type _MockResultRecorder struct { +// MockResultMockRecorder is the mock recorder for MockResult +type MockResultMockRecorder struct { mock *MockResult } +// NewMockResult creates a new mock instance func NewMockResult(ctrl *gomock.Controller) *MockResult { mock := &MockResult{ctrl: ctrl} - mock.recorder = &_MockResultRecorder{mock} + mock.recorder = &MockResultMockRecorder{mock} return mock } -func (_m *MockResult) EXPECT() *_MockResultRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockResult) EXPECT() *MockResultMockRecorder { + return m.recorder } -func (_m *MockResult) GetAsVersion(_param0 string) (types.Result, error) { - ret := _m.ctrl.Call(_m, "GetAsVersion", _param0) +// GetAsVersion mocks base method +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 } -func (_mr *_MockResultRecorder) GetAsVersion(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAsVersion", arg0) +// GetAsVersion indicates an expected call of GetAsVersion +func (mr *MockResultMockRecorder) GetAsVersion(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAsVersion", reflect.TypeOf((*MockResult)(nil).GetAsVersion), arg0) } -func (_m *MockResult) Print() error { - ret := _m.ctrl.Call(_m, "Print") +// Print mocks base method +func (m *MockResult) Print() error { + ret := m.ctrl.Call(m, "Print") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockResultRecorder) Print() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Print") +// Print indicates an expected call of Print +func (mr *MockResultMockRecorder) Print() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Print", reflect.TypeOf((*MockResult)(nil).Print)) } -func (_m *MockResult) String() string { - ret := _m.ctrl.Call(_m, "String") +// String mocks base method +func (m *MockResult) String() string { + ret := m.ctrl.Call(m, "String") ret0, _ := ret[0].(string) return ret0 } -func (_mr *_MockResultRecorder) String() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "String") +// String indicates an expected call of String +func (mr *MockResultMockRecorder) String() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockResult)(nil).String)) } -func (_m *MockResult) Version() string { - ret := _m.ctrl.Call(_m, "Version") +// Version mocks base method +func (m *MockResult) Version() string { + ret := m.ctrl.Call(m, "Version") ret0, _ := ret[0].(string) return ret0 } -func (_mr *_MockResultRecorder) Version() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") +// Version indicates an expected call of Version +func (mr *MockResultMockRecorder) Version() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockResult)(nil).Version)) } diff --git a/agent/ecscni/mocks_libcni/libcni_mocks.go b/agent/ecscni/mocks_libcni/libcni_mocks.go index f4190d4bf00..d9f15e9592d 100644 --- a/agent/ecscni/mocks_libcni/libcni_mocks.go +++ b/agent/ecscni/mocks_libcni/libcni_mocks.go @@ -11,76 +11,89 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/containernetworking/cni/libcni (interfaces: CNI) +// Package mock_libcni is a generated GoMock package. package mock_libcni import ( + reflect "reflect" + libcni "github.com/containernetworking/cni/libcni" types "github.com/containernetworking/cni/pkg/types" gomock "github.com/golang/mock/gomock" ) -// Mock of CNI interface +// MockCNI is a mock of CNI interface type MockCNI struct { ctrl *gomock.Controller - recorder *_MockCNIRecorder + recorder *MockCNIMockRecorder } -// Recorder for MockCNI (not exported) -type _MockCNIRecorder struct { +// MockCNIMockRecorder is the mock recorder for MockCNI +type MockCNIMockRecorder struct { mock *MockCNI } +// NewMockCNI creates a new mock instance func NewMockCNI(ctrl *gomock.Controller) *MockCNI { mock := &MockCNI{ctrl: ctrl} - mock.recorder = &_MockCNIRecorder{mock} + mock.recorder = &MockCNIMockRecorder{mock} return mock } -func (_m *MockCNI) EXPECT() *_MockCNIRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockCNI) EXPECT() *MockCNIMockRecorder { + return m.recorder } -func (_m *MockCNI) AddNetwork(_param0 *libcni.NetworkConfig, _param1 *libcni.RuntimeConf) (types.Result, error) { - ret := _m.ctrl.Call(_m, "AddNetwork", _param0, _param1) +// AddNetwork mocks base method +func (m *MockCNI) AddNetwork(arg0 *libcni.NetworkConfig, arg1 *libcni.RuntimeConf) (types.Result, error) { + ret := m.ctrl.Call(m, "AddNetwork", arg0, arg1) ret0, _ := ret[0].(types.Result) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockCNIRecorder) AddNetwork(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddNetwork", arg0, arg1) +// AddNetwork indicates an expected call of AddNetwork +func (mr *MockCNIMockRecorder) AddNetwork(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetwork", reflect.TypeOf((*MockCNI)(nil).AddNetwork), arg0, arg1) } -func (_m *MockCNI) AddNetworkList(_param0 *libcni.NetworkConfigList, _param1 *libcni.RuntimeConf) (types.Result, error) { - ret := _m.ctrl.Call(_m, "AddNetworkList", _param0, _param1) +// AddNetworkList mocks base method +func (m *MockCNI) AddNetworkList(arg0 *libcni.NetworkConfigList, arg1 *libcni.RuntimeConf) (types.Result, error) { + ret := m.ctrl.Call(m, "AddNetworkList", arg0, arg1) ret0, _ := ret[0].(types.Result) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockCNIRecorder) AddNetworkList(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddNetworkList", arg0, arg1) +// AddNetworkList indicates an expected call of AddNetworkList +func (mr *MockCNIMockRecorder) AddNetworkList(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetworkList", reflect.TypeOf((*MockCNI)(nil).AddNetworkList), arg0, arg1) } -func (_m *MockCNI) DelNetwork(_param0 *libcni.NetworkConfig, _param1 *libcni.RuntimeConf) error { - ret := _m.ctrl.Call(_m, "DelNetwork", _param0, _param1) +// DelNetwork mocks base method +func (m *MockCNI) DelNetwork(arg0 *libcni.NetworkConfig, arg1 *libcni.RuntimeConf) error { + ret := m.ctrl.Call(m, "DelNetwork", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockCNIRecorder) DelNetwork(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNetwork", arg0, arg1) +// DelNetwork indicates an expected call of DelNetwork +func (mr *MockCNIMockRecorder) DelNetwork(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelNetwork", reflect.TypeOf((*MockCNI)(nil).DelNetwork), arg0, arg1) } -func (_m *MockCNI) DelNetworkList(_param0 *libcni.NetworkConfigList, _param1 *libcni.RuntimeConf) error { - ret := _m.ctrl.Call(_m, "DelNetworkList", _param0, _param1) +// DelNetworkList mocks base method +func (m *MockCNI) DelNetworkList(arg0 *libcni.NetworkConfigList, arg1 *libcni.RuntimeConf) error { + ret := m.ctrl.Call(m, "DelNetworkList", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockCNIRecorder) DelNetworkList(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNetworkList", arg0, arg1) +// DelNetworkList indicates an expected call of DelNetworkList +func (mr *MockCNIMockRecorder) DelNetworkList(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelNetworkList", reflect.TypeOf((*MockCNI)(nil).DelNetworkList), arg0, arg1) } diff --git a/agent/engine/dockerclient/mocks/dockerclient_mocks.go b/agent/engine/dockerclient/mocks/dockerclient_mocks.go index 475e1b99b4d..6b0e422465a 100644 --- a/agent/engine/dockerclient/mocks/dockerclient_mocks.go +++ b/agent/engine/dockerclient/mocks/dockerclient_mocks.go @@ -11,76 +11,89 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/engine/dockerclient (interfaces: Factory) +// Package mock_dockerclient is a generated GoMock package. package mock_dockerclient import ( + reflect "reflect" + dockerclient "github.com/aws/amazon-ecs-agent/agent/engine/dockerclient" dockeriface "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface" gomock "github.com/golang/mock/gomock" ) -// Mock of Factory interface +// MockFactory is a mock of Factory interface type MockFactory struct { ctrl *gomock.Controller - recorder *_MockFactoryRecorder + recorder *MockFactoryMockRecorder } -// Recorder for MockFactory (not exported) -type _MockFactoryRecorder struct { +// MockFactoryMockRecorder is the mock recorder for MockFactory +type MockFactoryMockRecorder struct { mock *MockFactory } +// NewMockFactory creates a new mock instance func NewMockFactory(ctrl *gomock.Controller) *MockFactory { mock := &MockFactory{ctrl: ctrl} - mock.recorder = &_MockFactoryRecorder{mock} + mock.recorder = &MockFactoryMockRecorder{mock} return mock } -func (_m *MockFactory) EXPECT() *_MockFactoryRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockFactory) EXPECT() *MockFactoryMockRecorder { + return m.recorder } -func (_m *MockFactory) FindKnownAPIVersions() []dockerclient.DockerVersion { - ret := _m.ctrl.Call(_m, "FindKnownAPIVersions") +// FindKnownAPIVersions mocks base method +func (m *MockFactory) FindKnownAPIVersions() []dockerclient.DockerVersion { + ret := m.ctrl.Call(m, "FindKnownAPIVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -func (_mr *_MockFactoryRecorder) FindKnownAPIVersions() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "FindKnownAPIVersions") +// FindKnownAPIVersions indicates an expected call of FindKnownAPIVersions +func (mr *MockFactoryMockRecorder) FindKnownAPIVersions() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindKnownAPIVersions", reflect.TypeOf((*MockFactory)(nil).FindKnownAPIVersions)) } -func (_m *MockFactory) FindSupportedAPIVersions() []dockerclient.DockerVersion { - ret := _m.ctrl.Call(_m, "FindSupportedAPIVersions") +// FindSupportedAPIVersions mocks base method +func (m *MockFactory) FindSupportedAPIVersions() []dockerclient.DockerVersion { + ret := m.ctrl.Call(m, "FindSupportedAPIVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -func (_mr *_MockFactoryRecorder) FindSupportedAPIVersions() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "FindSupportedAPIVersions") +// FindSupportedAPIVersions indicates an expected call of FindSupportedAPIVersions +func (mr *MockFactoryMockRecorder) FindSupportedAPIVersions() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindSupportedAPIVersions", reflect.TypeOf((*MockFactory)(nil).FindSupportedAPIVersions)) } -func (_m *MockFactory) GetClient(_param0 dockerclient.DockerVersion) (dockeriface.Client, error) { - ret := _m.ctrl.Call(_m, "GetClient", _param0) +// GetClient mocks base method +func (m *MockFactory) GetClient(arg0 dockerclient.DockerVersion) (dockeriface.Client, error) { + ret := m.ctrl.Call(m, "GetClient", arg0) ret0, _ := ret[0].(dockeriface.Client) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockFactoryRecorder) GetClient(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetClient", arg0) +// GetClient indicates an expected call of GetClient +func (mr *MockFactoryMockRecorder) GetClient(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockFactory)(nil).GetClient), arg0) } -func (_m *MockFactory) GetDefaultClient() (dockeriface.Client, error) { - ret := _m.ctrl.Call(_m, "GetDefaultClient") +// GetDefaultClient mocks base method +func (m *MockFactory) GetDefaultClient() (dockeriface.Client, error) { + ret := m.ctrl.Call(m, "GetDefaultClient") ret0, _ := ret[0].(dockeriface.Client) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockFactoryRecorder) GetDefaultClient() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultClient") +// GetDefaultClient indicates an expected call of GetDefaultClient +func (mr *MockFactoryMockRecorder) GetDefaultClient() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultClient", reflect.TypeOf((*MockFactory)(nil).GetDefaultClient)) } diff --git a/agent/engine/dockeriface/mocks/dockeriface_mocks.go b/agent/engine/dockeriface/mocks/dockeriface_mocks.go index f22f4122f9f..d36dfd0e7d6 100644 --- a/agent/engine/dockeriface/mocks/dockeriface_mocks.go +++ b/agent/engine/dockeriface/mocks/dockeriface_mocks.go @@ -11,230 +11,273 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/engine/dockeriface (interfaces: Client) +// Package mock_dockeriface is a generated GoMock package. package mock_dockeriface import ( + reflect "reflect" + go_dockerclient "github.com/fsouza/go-dockerclient" gomock "github.com/golang/mock/gomock" context "golang.org/x/net/context" ) -// Mock of Client interface +// MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller - recorder *_MockClientRecorder + recorder *MockClientMockRecorder } -// Recorder for MockClient (not exported) -type _MockClientRecorder struct { +// MockClientMockRecorder is the mock recorder for MockClient +type MockClientMockRecorder struct { mock *MockClient } +// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} - mock.recorder = &_MockClientRecorder{mock} + mock.recorder = &MockClientMockRecorder{mock} return mock } -func (_m *MockClient) EXPECT() *_MockClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder } -func (_m *MockClient) AddEventListener(_param0 chan<- *go_dockerclient.APIEvents) error { - ret := _m.ctrl.Call(_m, "AddEventListener", _param0) +// AddEventListener mocks base method +func (m *MockClient) AddEventListener(arg0 chan<- *go_dockerclient.APIEvents) error { + ret := m.ctrl.Call(m, "AddEventListener", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) AddEventListener(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddEventListener", arg0) +// AddEventListener indicates an expected call of AddEventListener +func (mr *MockClientMockRecorder) AddEventListener(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventListener", reflect.TypeOf((*MockClient)(nil).AddEventListener), arg0) } -func (_m *MockClient) CreateContainer(_param0 go_dockerclient.CreateContainerOptions) (*go_dockerclient.Container, error) { - ret := _m.ctrl.Call(_m, "CreateContainer", _param0) +// CreateContainer mocks base method +func (m *MockClient) CreateContainer(arg0 go_dockerclient.CreateContainerOptions) (*go_dockerclient.Container, error) { + ret := m.ctrl.Call(m, "CreateContainer", arg0) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockClientRecorder) CreateContainer(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateContainer", arg0) +// CreateContainer indicates an expected call of CreateContainer +func (mr *MockClientMockRecorder) CreateContainer(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockClient)(nil).CreateContainer), arg0) } -func (_m *MockClient) ImportImage(_param0 go_dockerclient.ImportImageOptions) error { - ret := _m.ctrl.Call(_m, "ImportImage", _param0) +// ImportImage mocks base method +func (m *MockClient) ImportImage(arg0 go_dockerclient.ImportImageOptions) error { + ret := m.ctrl.Call(m, "ImportImage", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) ImportImage(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ImportImage", arg0) +// ImportImage indicates an expected call of ImportImage +func (mr *MockClientMockRecorder) ImportImage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockClient)(nil).ImportImage), arg0) } -func (_m *MockClient) InspectContainer(_param0 string) (*go_dockerclient.Container, error) { - ret := _m.ctrl.Call(_m, "InspectContainer", _param0) +// InspectContainer mocks base method +func (m *MockClient) InspectContainer(arg0 string) (*go_dockerclient.Container, error) { + ret := m.ctrl.Call(m, "InspectContainer", arg0) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockClientRecorder) InspectContainer(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0) +// InspectContainer indicates an expected call of InspectContainer +func (mr *MockClientMockRecorder) InspectContainer(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockClient)(nil).InspectContainer), arg0) } -func (_m *MockClient) InspectContainerWithContext(_param0 string, _param1 context.Context) (*go_dockerclient.Container, error) { - ret := _m.ctrl.Call(_m, "InspectContainerWithContext", _param0, _param1) +// InspectContainerWithContext mocks base method +func (m *MockClient) InspectContainerWithContext(arg0 string, arg1 context.Context) (*go_dockerclient.Container, error) { + ret := m.ctrl.Call(m, "InspectContainerWithContext", arg0, arg1) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockClientRecorder) InspectContainerWithContext(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainerWithContext", arg0, arg1) +// InspectContainerWithContext indicates an expected call of InspectContainerWithContext +func (mr *MockClientMockRecorder) InspectContainerWithContext(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainerWithContext", reflect.TypeOf((*MockClient)(nil).InspectContainerWithContext), arg0, arg1) } -func (_m *MockClient) InspectImage(_param0 string) (*go_dockerclient.Image, error) { - ret := _m.ctrl.Call(_m, "InspectImage", _param0) +// InspectImage mocks base method +func (m *MockClient) InspectImage(arg0 string) (*go_dockerclient.Image, error) { + ret := m.ctrl.Call(m, "InspectImage", arg0) ret0, _ := ret[0].(*go_dockerclient.Image) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockClientRecorder) InspectImage(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectImage", arg0) +// InspectImage indicates an expected call of InspectImage +func (mr *MockClientMockRecorder) InspectImage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImage", reflect.TypeOf((*MockClient)(nil).InspectImage), arg0) } -func (_m *MockClient) ListContainers(_param0 go_dockerclient.ListContainersOptions) ([]go_dockerclient.APIContainers, error) { - ret := _m.ctrl.Call(_m, "ListContainers", _param0) +// ListContainers mocks base method +func (m *MockClient) ListContainers(arg0 go_dockerclient.ListContainersOptions) ([]go_dockerclient.APIContainers, error) { + ret := m.ctrl.Call(m, "ListContainers", arg0) ret0, _ := ret[0].([]go_dockerclient.APIContainers) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockClientRecorder) ListContainers(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListContainers", arg0) +// ListContainers indicates an expected call of ListContainers +func (mr *MockClientMockRecorder) ListContainers(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockClient)(nil).ListContainers), arg0) } -func (_m *MockClient) LoadImage(_param0 go_dockerclient.LoadImageOptions) error { - ret := _m.ctrl.Call(_m, "LoadImage", _param0) +// LoadImage mocks base method +func (m *MockClient) LoadImage(arg0 go_dockerclient.LoadImageOptions) error { + ret := m.ctrl.Call(m, "LoadImage", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) LoadImage(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0) +// LoadImage indicates an expected call of LoadImage +func (mr *MockClientMockRecorder) LoadImage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadImage", reflect.TypeOf((*MockClient)(nil).LoadImage), arg0) } -func (_m *MockClient) Ping() error { - ret := _m.ctrl.Call(_m, "Ping") +// Ping mocks base method +func (m *MockClient) Ping() error { + ret := m.ctrl.Call(m, "Ping") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) Ping() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Ping") +// Ping indicates an expected call of Ping +func (mr *MockClientMockRecorder) Ping() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockClient)(nil).Ping)) } -func (_m *MockClient) PullImage(_param0 go_dockerclient.PullImageOptions, _param1 go_dockerclient.AuthConfiguration) error { - ret := _m.ctrl.Call(_m, "PullImage", _param0, _param1) +// PullImage mocks base method +func (m *MockClient) PullImage(arg0 go_dockerclient.PullImageOptions, arg1 go_dockerclient.AuthConfiguration) error { + ret := m.ctrl.Call(m, "PullImage", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "PullImage", arg0, arg1) +// PullImage indicates an expected call of PullImage +func (mr *MockClientMockRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockClient)(nil).PullImage), arg0, arg1) } -func (_m *MockClient) RemoveContainer(_param0 go_dockerclient.RemoveContainerOptions) error { - ret := _m.ctrl.Call(_m, "RemoveContainer", _param0) +// RemoveContainer mocks base method +func (m *MockClient) RemoveContainer(arg0 go_dockerclient.RemoveContainerOptions) error { + ret := m.ctrl.Call(m, "RemoveContainer", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) RemoveContainer(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainer", arg0) +// RemoveContainer indicates an expected call of RemoveContainer +func (mr *MockClientMockRecorder) RemoveContainer(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockClient)(nil).RemoveContainer), arg0) } -func (_m *MockClient) RemoveEventListener(_param0 chan *go_dockerclient.APIEvents) error { - ret := _m.ctrl.Call(_m, "RemoveEventListener", _param0) +// RemoveEventListener mocks base method +func (m *MockClient) RemoveEventListener(arg0 chan *go_dockerclient.APIEvents) error { + ret := m.ctrl.Call(m, "RemoveEventListener", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) RemoveEventListener(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveEventListener", arg0) +// RemoveEventListener indicates an expected call of RemoveEventListener +func (mr *MockClientMockRecorder) RemoveEventListener(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveEventListener", reflect.TypeOf((*MockClient)(nil).RemoveEventListener), arg0) } -func (_m *MockClient) RemoveImage(_param0 string) error { - ret := _m.ctrl.Call(_m, "RemoveImage", _param0) +// RemoveImage mocks base method +func (m *MockClient) RemoveImage(arg0 string) error { + ret := m.ctrl.Call(m, "RemoveImage", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) RemoveImage(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImage", arg0) +// RemoveImage indicates an expected call of RemoveImage +func (mr *MockClientMockRecorder) RemoveImage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockClient)(nil).RemoveImage), arg0) } -func (_m *MockClient) StartContainer(_param0 string, _param1 *go_dockerclient.HostConfig) error { - ret := _m.ctrl.Call(_m, "StartContainer", _param0, _param1) +// StartContainer mocks base method +func (m *MockClient) StartContainer(arg0 string, arg1 *go_dockerclient.HostConfig) error { + ret := m.ctrl.Call(m, "StartContainer", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainer", arg0, arg1) +// StartContainer indicates an expected call of StartContainer +func (mr *MockClientMockRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockClient)(nil).StartContainer), arg0, arg1) } -func (_m *MockClient) StartContainerWithContext(_param0 string, _param1 *go_dockerclient.HostConfig, _param2 context.Context) error { - ret := _m.ctrl.Call(_m, "StartContainerWithContext", _param0, _param1, _param2) +// StartContainerWithContext mocks base method +func (m *MockClient) StartContainerWithContext(arg0 string, arg1 *go_dockerclient.HostConfig, arg2 context.Context) error { + ret := m.ctrl.Call(m, "StartContainerWithContext", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) StartContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainerWithContext", arg0, arg1, arg2) +// StartContainerWithContext indicates an expected call of StartContainerWithContext +func (mr *MockClientMockRecorder) StartContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainerWithContext", reflect.TypeOf((*MockClient)(nil).StartContainerWithContext), arg0, arg1, arg2) } -func (_m *MockClient) Stats(_param0 go_dockerclient.StatsOptions) error { - ret := _m.ctrl.Call(_m, "Stats", _param0) +// Stats mocks base method +func (m *MockClient) Stats(arg0 go_dockerclient.StatsOptions) error { + ret := m.ctrl.Call(m, "Stats", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) Stats(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Stats", arg0) +// Stats indicates an expected call of Stats +func (mr *MockClientMockRecorder) Stats(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockClient)(nil).Stats), arg0) } -func (_m *MockClient) StopContainer(_param0 string, _param1 uint) error { - ret := _m.ctrl.Call(_m, "StopContainer", _param0, _param1) +// StopContainer mocks base method +func (m *MockClient) StopContainer(arg0 string, arg1 uint) error { + ret := m.ctrl.Call(m, "StopContainer", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainer", arg0, arg1) +// StopContainer indicates an expected call of StopContainer +func (mr *MockClientMockRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockClient)(nil).StopContainer), arg0, arg1) } -func (_m *MockClient) StopContainerWithContext(_param0 string, _param1 uint, _param2 context.Context) error { - ret := _m.ctrl.Call(_m, "StopContainerWithContext", _param0, _param1, _param2) +// StopContainerWithContext mocks base method +func (m *MockClient) StopContainerWithContext(arg0 string, arg1 uint, arg2 context.Context) error { + ret := m.ctrl.Call(m, "StopContainerWithContext", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientRecorder) StopContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainerWithContext", arg0, arg1, arg2) +// StopContainerWithContext indicates an expected call of StopContainerWithContext +func (mr *MockClientMockRecorder) StopContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainerWithContext", reflect.TypeOf((*MockClient)(nil).StopContainerWithContext), arg0, arg1, arg2) } -func (_m *MockClient) Version() (*go_dockerclient.Env, error) { - ret := _m.ctrl.Call(_m, "Version") +// Version mocks base method +func (m *MockClient) Version() (*go_dockerclient.Env, error) { + ret := m.ctrl.Call(m, "Version") ret0, _ := ret[0].(*go_dockerclient.Env) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockClientRecorder) Version() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") +// Version indicates an expected call of Version +func (mr *MockClientMockRecorder) Version() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockClient)(nil).Version)) } diff --git a/agent/engine/dockerstate/mocks/dockerstate_mocks.go b/agent/engine/dockerstate/mocks/dockerstate_mocks.go index aa8fb1daccd..a21cb86954b 100644 --- a/agent/engine/dockerstate/mocks/dockerstate_mocks.go +++ b/agent/engine/dockerstate/mocks/dockerstate_mocks.go @@ -11,215 +11,258 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/engine/dockerstate (interfaces: TaskEngineState) +// Package mock_dockerstate is a generated GoMock package. package mock_dockerstate import ( + reflect "reflect" + api "github.com/aws/amazon-ecs-agent/agent/api" image "github.com/aws/amazon-ecs-agent/agent/engine/image" gomock "github.com/golang/mock/gomock" ) -// Mock of TaskEngineState interface +// MockTaskEngineState is a mock of TaskEngineState interface type MockTaskEngineState struct { ctrl *gomock.Controller - recorder *_MockTaskEngineStateRecorder + recorder *MockTaskEngineStateMockRecorder } -// Recorder for MockTaskEngineState (not exported) -type _MockTaskEngineStateRecorder struct { +// MockTaskEngineStateMockRecorder is the mock recorder for MockTaskEngineState +type MockTaskEngineStateMockRecorder struct { mock *MockTaskEngineState } +// NewMockTaskEngineState creates a new mock instance func NewMockTaskEngineState(ctrl *gomock.Controller) *MockTaskEngineState { mock := &MockTaskEngineState{ctrl: ctrl} - mock.recorder = &_MockTaskEngineStateRecorder{mock} + mock.recorder = &MockTaskEngineStateMockRecorder{mock} return mock } -func (_m *MockTaskEngineState) EXPECT() *_MockTaskEngineStateRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTaskEngineState) EXPECT() *MockTaskEngineStateMockRecorder { + return m.recorder } -func (_m *MockTaskEngineState) AddContainer(_param0 *api.DockerContainer, _param1 *api.Task) { - _m.ctrl.Call(_m, "AddContainer", _param0, _param1) +// AddContainer mocks base method +func (m *MockTaskEngineState) AddContainer(arg0 *api.DockerContainer, arg1 *api.Task) { + m.ctrl.Call(m, "AddContainer", arg0, arg1) } -func (_mr *_MockTaskEngineStateRecorder) AddContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddContainer", arg0, arg1) +// AddContainer indicates an expected call of AddContainer +func (mr *MockTaskEngineStateMockRecorder) AddContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContainer", reflect.TypeOf((*MockTaskEngineState)(nil).AddContainer), arg0, arg1) } -func (_m *MockTaskEngineState) AddENIAttachment(_param0 *api.ENIAttachment) { - _m.ctrl.Call(_m, "AddENIAttachment", _param0) +// AddENIAttachment mocks base method +func (m *MockTaskEngineState) AddENIAttachment(arg0 *api.ENIAttachment) { + m.ctrl.Call(m, "AddENIAttachment", arg0) } -func (_mr *_MockTaskEngineStateRecorder) AddENIAttachment(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddENIAttachment", arg0) +// AddENIAttachment indicates an expected call of AddENIAttachment +func (mr *MockTaskEngineStateMockRecorder) AddENIAttachment(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddENIAttachment", reflect.TypeOf((*MockTaskEngineState)(nil).AddENIAttachment), arg0) } -func (_m *MockTaskEngineState) AddImageState(_param0 *image.ImageState) { - _m.ctrl.Call(_m, "AddImageState", _param0) +// AddImageState mocks base method +func (m *MockTaskEngineState) AddImageState(arg0 *image.ImageState) { + m.ctrl.Call(m, "AddImageState", arg0) } -func (_mr *_MockTaskEngineStateRecorder) AddImageState(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddImageState", arg0) +// AddImageState indicates an expected call of AddImageState +func (mr *MockTaskEngineStateMockRecorder) AddImageState(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddImageState", reflect.TypeOf((*MockTaskEngineState)(nil).AddImageState), arg0) } -func (_m *MockTaskEngineState) AddTask(_param0 *api.Task) { - _m.ctrl.Call(_m, "AddTask", _param0) +// AddTask mocks base method +func (m *MockTaskEngineState) AddTask(arg0 *api.Task) { + m.ctrl.Call(m, "AddTask", arg0) } -func (_mr *_MockTaskEngineStateRecorder) AddTask(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTask", arg0) +// AddTask indicates an expected call of AddTask +func (mr *MockTaskEngineStateMockRecorder) AddTask(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTask", reflect.TypeOf((*MockTaskEngineState)(nil).AddTask), arg0) } -func (_m *MockTaskEngineState) AllImageStates() []*image.ImageState { - ret := _m.ctrl.Call(_m, "AllImageStates") +// AllImageStates mocks base method +func (m *MockTaskEngineState) AllImageStates() []*image.ImageState { + ret := m.ctrl.Call(m, "AllImageStates") ret0, _ := ret[0].([]*image.ImageState) return ret0 } -func (_mr *_MockTaskEngineStateRecorder) AllImageStates() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AllImageStates") +// AllImageStates indicates an expected call of AllImageStates +func (mr *MockTaskEngineStateMockRecorder) AllImageStates() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllImageStates", reflect.TypeOf((*MockTaskEngineState)(nil).AllImageStates)) } -func (_m *MockTaskEngineState) AllTasks() []*api.Task { - ret := _m.ctrl.Call(_m, "AllTasks") +// AllTasks mocks base method +func (m *MockTaskEngineState) AllTasks() []*api.Task { + ret := m.ctrl.Call(m, "AllTasks") ret0, _ := ret[0].([]*api.Task) return ret0 } -func (_mr *_MockTaskEngineStateRecorder) AllTasks() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AllTasks") +// AllTasks indicates an expected call of AllTasks +func (mr *MockTaskEngineStateMockRecorder) AllTasks() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllTasks", reflect.TypeOf((*MockTaskEngineState)(nil).AllTasks)) } -func (_m *MockTaskEngineState) ContainerByID(_param0 string) (*api.DockerContainer, bool) { - ret := _m.ctrl.Call(_m, "ContainerByID", _param0) +// ContainerByID mocks base method +func (m *MockTaskEngineState) ContainerByID(arg0 string) (*api.DockerContainer, bool) { + ret := m.ctrl.Call(m, "ContainerByID", arg0) ret0, _ := ret[0].(*api.DockerContainer) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockTaskEngineStateRecorder) ContainerByID(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerByID", arg0) +// ContainerByID indicates an expected call of ContainerByID +func (mr *MockTaskEngineStateMockRecorder) ContainerByID(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerByID", reflect.TypeOf((*MockTaskEngineState)(nil).ContainerByID), arg0) } -func (_m *MockTaskEngineState) ContainerMapByArn(_param0 string) (map[string]*api.DockerContainer, bool) { - ret := _m.ctrl.Call(_m, "ContainerMapByArn", _param0) +// ContainerMapByArn mocks base method +func (m *MockTaskEngineState) ContainerMapByArn(arg0 string) (map[string]*api.DockerContainer, bool) { + ret := m.ctrl.Call(m, "ContainerMapByArn", arg0) ret0, _ := ret[0].(map[string]*api.DockerContainer) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockTaskEngineStateRecorder) ContainerMapByArn(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerMapByArn", arg0) +// ContainerMapByArn indicates an expected call of ContainerMapByArn +func (mr *MockTaskEngineStateMockRecorder) ContainerMapByArn(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerMapByArn", reflect.TypeOf((*MockTaskEngineState)(nil).ContainerMapByArn), arg0) } -func (_m *MockTaskEngineState) ENIByMac(_param0 string) (*api.ENIAttachment, bool) { - ret := _m.ctrl.Call(_m, "ENIByMac", _param0) +// ENIByMac mocks base method +func (m *MockTaskEngineState) ENIByMac(arg0 string) (*api.ENIAttachment, bool) { + ret := m.ctrl.Call(m, "ENIByMac", arg0) ret0, _ := ret[0].(*api.ENIAttachment) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockTaskEngineStateRecorder) ENIByMac(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ENIByMac", arg0) +// ENIByMac indicates an expected call of ENIByMac +func (mr *MockTaskEngineStateMockRecorder) ENIByMac(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ENIByMac", reflect.TypeOf((*MockTaskEngineState)(nil).ENIByMac), arg0) } -func (_m *MockTaskEngineState) GetAllContainerIDs() []string { - ret := _m.ctrl.Call(_m, "GetAllContainerIDs") +// GetAllContainerIDs mocks base method +func (m *MockTaskEngineState) GetAllContainerIDs() []string { + ret := m.ctrl.Call(m, "GetAllContainerIDs") ret0, _ := ret[0].([]string) return ret0 } -func (_mr *_MockTaskEngineStateRecorder) GetAllContainerIDs() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllContainerIDs") +// GetAllContainerIDs indicates an expected call of GetAllContainerIDs +func (mr *MockTaskEngineStateMockRecorder) GetAllContainerIDs() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllContainerIDs", reflect.TypeOf((*MockTaskEngineState)(nil).GetAllContainerIDs)) } -func (_m *MockTaskEngineState) MarshalJSON() ([]byte, error) { - ret := _m.ctrl.Call(_m, "MarshalJSON") +// MarshalJSON mocks base method +func (m *MockTaskEngineState) MarshalJSON() ([]byte, error) { + ret := m.ctrl.Call(m, "MarshalJSON") ret0, _ := ret[0].([]byte) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockTaskEngineStateRecorder) MarshalJSON() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "MarshalJSON") +// MarshalJSON indicates an expected call of MarshalJSON +func (mr *MockTaskEngineStateMockRecorder) MarshalJSON() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalJSON", reflect.TypeOf((*MockTaskEngineState)(nil).MarshalJSON)) } -func (_m *MockTaskEngineState) RemoveENIAttachment(_param0 string) { - _m.ctrl.Call(_m, "RemoveENIAttachment", _param0) +// RemoveENIAttachment mocks base method +func (m *MockTaskEngineState) RemoveENIAttachment(arg0 string) { + m.ctrl.Call(m, "RemoveENIAttachment", arg0) } -func (_mr *_MockTaskEngineStateRecorder) RemoveENIAttachment(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveENIAttachment", arg0) +// RemoveENIAttachment indicates an expected call of RemoveENIAttachment +func (mr *MockTaskEngineStateMockRecorder) RemoveENIAttachment(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveENIAttachment", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveENIAttachment), arg0) } -func (_m *MockTaskEngineState) RemoveImageState(_param0 *image.ImageState) { - _m.ctrl.Call(_m, "RemoveImageState", _param0) +// RemoveImageState mocks base method +func (m *MockTaskEngineState) RemoveImageState(arg0 *image.ImageState) { + m.ctrl.Call(m, "RemoveImageState", arg0) } -func (_mr *_MockTaskEngineStateRecorder) RemoveImageState(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImageState", arg0) +// RemoveImageState indicates an expected call of RemoveImageState +func (mr *MockTaskEngineStateMockRecorder) RemoveImageState(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImageState", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveImageState), arg0) } -func (_m *MockTaskEngineState) RemoveTask(_param0 *api.Task) { - _m.ctrl.Call(_m, "RemoveTask", _param0) +// RemoveTask mocks base method +func (m *MockTaskEngineState) RemoveTask(arg0 *api.Task) { + m.ctrl.Call(m, "RemoveTask", arg0) } -func (_mr *_MockTaskEngineStateRecorder) RemoveTask(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveTask", arg0) +// RemoveTask indicates an expected call of RemoveTask +func (mr *MockTaskEngineStateMockRecorder) RemoveTask(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTask", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveTask), arg0) } -func (_m *MockTaskEngineState) Reset() { - _m.ctrl.Call(_m, "Reset") +// Reset mocks base method +func (m *MockTaskEngineState) Reset() { + m.ctrl.Call(m, "Reset") } -func (_mr *_MockTaskEngineStateRecorder) Reset() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset") +// Reset indicates an expected call of Reset +func (mr *MockTaskEngineStateMockRecorder) Reset() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTaskEngineState)(nil).Reset)) } -func (_m *MockTaskEngineState) TaskByArn(_param0 string) (*api.Task, bool) { - ret := _m.ctrl.Call(_m, "TaskByArn", _param0) +// TaskByArn mocks base method +func (m *MockTaskEngineState) TaskByArn(arg0 string) (*api.Task, bool) { + ret := m.ctrl.Call(m, "TaskByArn", arg0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockTaskEngineStateRecorder) TaskByArn(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TaskByArn", arg0) +// TaskByArn indicates an expected call of TaskByArn +func (mr *MockTaskEngineStateMockRecorder) TaskByArn(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskByArn", reflect.TypeOf((*MockTaskEngineState)(nil).TaskByArn), arg0) } -func (_m *MockTaskEngineState) TaskByID(_param0 string) (*api.Task, bool) { - ret := _m.ctrl.Call(_m, "TaskByID", _param0) +// TaskByID mocks base method +func (m *MockTaskEngineState) TaskByID(arg0 string) (*api.Task, bool) { + ret := m.ctrl.Call(m, "TaskByID", arg0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockTaskEngineStateRecorder) TaskByID(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TaskByID", arg0) +// TaskByID indicates an expected call of TaskByID +func (mr *MockTaskEngineStateMockRecorder) TaskByID(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskByID", reflect.TypeOf((*MockTaskEngineState)(nil).TaskByID), arg0) } -func (_m *MockTaskEngineState) TaskByShortID(_param0 string) ([]*api.Task, bool) { - ret := _m.ctrl.Call(_m, "TaskByShortID", _param0) +// TaskByShortID mocks base method +func (m *MockTaskEngineState) TaskByShortID(arg0 string) ([]*api.Task, bool) { + ret := m.ctrl.Call(m, "TaskByShortID", arg0) ret0, _ := ret[0].([]*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockTaskEngineStateRecorder) TaskByShortID(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TaskByShortID", arg0) +// TaskByShortID indicates an expected call of TaskByShortID +func (mr *MockTaskEngineStateMockRecorder) TaskByShortID(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskByShortID", reflect.TypeOf((*MockTaskEngineState)(nil).TaskByShortID), arg0) } -func (_m *MockTaskEngineState) UnmarshalJSON(_param0 []byte) error { - ret := _m.ctrl.Call(_m, "UnmarshalJSON", _param0) +// UnmarshalJSON mocks base method +func (m *MockTaskEngineState) UnmarshalJSON(arg0 []byte) error { + ret := m.ctrl.Call(m, "UnmarshalJSON", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTaskEngineStateRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UnmarshalJSON", arg0) +// UnmarshalJSON indicates an expected call of UnmarshalJSON +func (mr *MockTaskEngineStateMockRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalJSON", reflect.TypeOf((*MockTaskEngineState)(nil).UnmarshalJSON), arg0) } diff --git a/agent/engine/engine_mocks.go b/agent/engine/engine_mocks.go index 5782d846dcb..ce3ffeb9523 100644 --- a/agent/engine/engine_mocks.go +++ b/agent/engine/engine_mocks.go @@ -11,14 +11,16 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/engine (interfaces: TaskEngine,DockerClient,ImageManager) +// Package engine is a generated GoMock package. package engine import ( context "context" io "io" + reflect "reflect" time "time" api "github.com/aws/amazon-ecs-agent/agent/api" @@ -31,54 +33,62 @@ import ( context0 "golang.org/x/net/context" ) -// Mock of TaskEngine interface +// MockTaskEngine is a mock of TaskEngine interface type MockTaskEngine struct { ctrl *gomock.Controller - recorder *_MockTaskEngineRecorder + recorder *MockTaskEngineMockRecorder } -// Recorder for MockTaskEngine (not exported) -type _MockTaskEngineRecorder struct { +// MockTaskEngineMockRecorder is the mock recorder for MockTaskEngine +type MockTaskEngineMockRecorder struct { mock *MockTaskEngine } +// NewMockTaskEngine creates a new mock instance func NewMockTaskEngine(ctrl *gomock.Controller) *MockTaskEngine { mock := &MockTaskEngine{ctrl: ctrl} - mock.recorder = &_MockTaskEngineRecorder{mock} + mock.recorder = &MockTaskEngineMockRecorder{mock} return mock } -func (_m *MockTaskEngine) EXPECT() *_MockTaskEngineRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTaskEngine) EXPECT() *MockTaskEngineMockRecorder { + return m.recorder } -func (_m *MockTaskEngine) AddTask(_param0 *api.Task) error { - ret := _m.ctrl.Call(_m, "AddTask", _param0) +// AddTask mocks base method +func (m *MockTaskEngine) AddTask(arg0 *api.Task) error { + ret := m.ctrl.Call(m, "AddTask", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTaskEngineRecorder) AddTask(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTask", arg0) +// AddTask indicates an expected call of AddTask +func (mr *MockTaskEngineMockRecorder) AddTask(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTask", reflect.TypeOf((*MockTaskEngine)(nil).AddTask), arg0) } -func (_m *MockTaskEngine) Disable() { - _m.ctrl.Call(_m, "Disable") +// Disable mocks base method +func (m *MockTaskEngine) Disable() { + m.ctrl.Call(m, "Disable") } -func (_mr *_MockTaskEngineRecorder) Disable() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Disable") +// Disable indicates an expected call of Disable +func (mr *MockTaskEngineMockRecorder) Disable() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disable", reflect.TypeOf((*MockTaskEngine)(nil).Disable)) } -func (_m *MockTaskEngine) GetTaskByArn(_param0 string) (*api.Task, bool) { - ret := _m.ctrl.Call(_m, "GetTaskByArn", _param0) +// GetTaskByArn mocks base method +func (m *MockTaskEngine) GetTaskByArn(arg0 string) (*api.Task, bool) { + ret := m.ctrl.Call(m, "GetTaskByArn", arg0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTaskByArn", arg0) +// GetTaskByArn indicates an expected call of GetTaskByArn +func (mr *MockTaskEngineMockRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskByArn", reflect.TypeOf((*MockTaskEngine)(nil).GetTaskByArn), arg0) } func (_m *MockTaskEngine) Init(_param0 context0.Context) error { @@ -87,130 +97,152 @@ func (_m *MockTaskEngine) Init(_param0 context0.Context) error { return ret0 } -func (_mr *_MockTaskEngineRecorder) Init(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Init", arg0) +// Init indicates an expected call of Init +func (mr *MockTaskEngineMockRecorder) Init(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTaskEngine)(nil).Init), arg0) } -func (_m *MockTaskEngine) ListTasks() ([]*api.Task, error) { - ret := _m.ctrl.Call(_m, "ListTasks") +// ListTasks mocks base method +func (m *MockTaskEngine) ListTasks() ([]*api.Task, error) { + ret := m.ctrl.Call(m, "ListTasks") ret0, _ := ret[0].([]*api.Task) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) ListTasks() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTasks") +// ListTasks indicates an expected call of ListTasks +func (mr *MockTaskEngineMockRecorder) ListTasks() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasks", reflect.TypeOf((*MockTaskEngine)(nil).ListTasks)) } -func (_m *MockTaskEngine) MarshalJSON() ([]byte, error) { - ret := _m.ctrl.Call(_m, "MarshalJSON") +// MarshalJSON mocks base method +func (m *MockTaskEngine) MarshalJSON() ([]byte, error) { + ret := m.ctrl.Call(m, "MarshalJSON") ret0, _ := ret[0].([]byte) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) MarshalJSON() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "MarshalJSON") +// MarshalJSON indicates an expected call of MarshalJSON +func (mr *MockTaskEngineMockRecorder) MarshalJSON() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalJSON", reflect.TypeOf((*MockTaskEngine)(nil).MarshalJSON)) } func (_m *MockTaskEngine) MustInit(_param0 context0.Context) { _m.ctrl.Call(_m, "MustInit", _param0) } -func (_mr *_MockTaskEngineRecorder) MustInit(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "MustInit", arg0) +// MustInit indicates an expected call of MustInit +func (mr *MockTaskEngineMockRecorder) MustInit(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MustInit", reflect.TypeOf((*MockTaskEngine)(nil).MustInit), arg0) } -func (_m *MockTaskEngine) SetSaver(_param0 statemanager.Saver) { - _m.ctrl.Call(_m, "SetSaver", _param0) +// SetSaver mocks base method +func (m *MockTaskEngine) SetSaver(arg0 statemanager.Saver) { + m.ctrl.Call(m, "SetSaver", arg0) } -func (_mr *_MockTaskEngineRecorder) SetSaver(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) +// SetSaver indicates an expected call of SetSaver +func (mr *MockTaskEngineMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSaver", reflect.TypeOf((*MockTaskEngine)(nil).SetSaver), arg0) } -func (_m *MockTaskEngine) StateChangeEvents() chan statechange.Event { - ret := _m.ctrl.Call(_m, "StateChangeEvents") +// StateChangeEvents mocks base method +func (m *MockTaskEngine) StateChangeEvents() chan statechange.Event { + ret := m.ctrl.Call(m, "StateChangeEvents") ret0, _ := ret[0].(chan statechange.Event) return ret0 } -func (_mr *_MockTaskEngineRecorder) StateChangeEvents() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StateChangeEvents") +// StateChangeEvents indicates an expected call of StateChangeEvents +func (mr *MockTaskEngineMockRecorder) StateChangeEvents() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateChangeEvents", reflect.TypeOf((*MockTaskEngine)(nil).StateChangeEvents)) } -func (_m *MockTaskEngine) UnmarshalJSON(_param0 []byte) error { - ret := _m.ctrl.Call(_m, "UnmarshalJSON", _param0) +// UnmarshalJSON mocks base method +func (m *MockTaskEngine) UnmarshalJSON(arg0 []byte) error { + ret := m.ctrl.Call(m, "UnmarshalJSON", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockTaskEngineRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "UnmarshalJSON", arg0) +// UnmarshalJSON indicates an expected call of UnmarshalJSON +func (mr *MockTaskEngineMockRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalJSON", reflect.TypeOf((*MockTaskEngine)(nil).UnmarshalJSON), arg0) } -func (_m *MockTaskEngine) Version() (string, error) { - ret := _m.ctrl.Call(_m, "Version") +// Version mocks base method +func (m *MockTaskEngine) Version() (string, error) { + ret := m.ctrl.Call(m, "Version") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockTaskEngineRecorder) Version() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") +// Version indicates an expected call of Version +func (mr *MockTaskEngineMockRecorder) Version() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockTaskEngine)(nil).Version)) } -// Mock of DockerClient interface +// MockDockerClient is a mock of DockerClient interface type MockDockerClient struct { ctrl *gomock.Controller - recorder *_MockDockerClientRecorder + recorder *MockDockerClientMockRecorder } -// Recorder for MockDockerClient (not exported) -type _MockDockerClientRecorder struct { +// MockDockerClientMockRecorder is the mock recorder for MockDockerClient +type MockDockerClientMockRecorder struct { mock *MockDockerClient } +// NewMockDockerClient creates a new mock instance func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient { mock := &MockDockerClient{ctrl: ctrl} - mock.recorder = &_MockDockerClientRecorder{mock} + mock.recorder = &MockDockerClientMockRecorder{mock} return mock } -func (_m *MockDockerClient) EXPECT() *_MockDockerClientRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockDockerClient) EXPECT() *MockDockerClientMockRecorder { + return m.recorder } -func (_m *MockDockerClient) ContainerEvents(_param0 context.Context) (<-chan DockerContainerChangeEvent, error) { - ret := _m.ctrl.Call(_m, "ContainerEvents", _param0) +// ContainerEvents mocks base method +func (m *MockDockerClient) ContainerEvents(arg0 context.Context) (<-chan DockerContainerChangeEvent, error) { + ret := m.ctrl.Call(m, "ContainerEvents", arg0) ret0, _ := ret[0].(<-chan DockerContainerChangeEvent) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerEvents", arg0) +// ContainerEvents indicates an expected call of ContainerEvents +func (mr *MockDockerClientMockRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerEvents", reflect.TypeOf((*MockDockerClient)(nil).ContainerEvents), arg0) } -func (_m *MockDockerClient) CreateContainer(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 time.Duration) DockerContainerMetadata { - ret := _m.ctrl.Call(_m, "CreateContainer", _param0, _param1, _param2, _param3) +// CreateContainer mocks base method +func (m *MockDockerClient) CreateContainer(arg0 *go_dockerclient.Config, arg1 *go_dockerclient.HostConfig, arg2 string, arg3 time.Duration) DockerContainerMetadata { + ret := m.ctrl.Call(m, "CreateContainer", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateContainer", arg0, arg1, arg2, arg3) +// CreateContainer indicates an expected call of CreateContainer +func (mr *MockDockerClientMockRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockDockerClient)(nil).CreateContainer), arg0, arg1, arg2, arg3) } -func (_m *MockDockerClient) DescribeContainer(_param0 string) (api.ContainerStatus, DockerContainerMetadata) { - ret := _m.ctrl.Call(_m, "DescribeContainer", _param0) +// DescribeContainer mocks base method +func (m *MockDockerClient) DescribeContainer(arg0 string) (api.ContainerStatus, DockerContainerMetadata) { + ret := m.ctrl.Call(m, "DescribeContainer", arg0) ret0, _ := ret[0].(api.ContainerStatus) ret1, _ := ret[1].(DockerContainerMetadata) return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeContainer", arg0) +// DescribeContainer indicates an expected call of DescribeContainer +func (mr *MockDockerClientMockRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainer", reflect.TypeOf((*MockDockerClient)(nil).DescribeContainer), arg0) } func (_m *MockDockerClient) ImportLocalEmptyVolumeImage() DockerContainerMetadata { @@ -230,214 +262,254 @@ func (_m *MockDockerClient) InspectContainer(_param0 string, _param1 time.Durati return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) +// InspectContainer indicates an expected call of InspectContainer +func (mr *MockDockerClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockDockerClient)(nil).InspectContainer), arg0, arg1) } -func (_m *MockDockerClient) InspectImage(_param0 string) (*go_dockerclient.Image, error) { - ret := _m.ctrl.Call(_m, "InspectImage", _param0) +// InspectImage mocks base method +func (m *MockDockerClient) InspectImage(arg0 string) (*go_dockerclient.Image, error) { + ret := m.ctrl.Call(m, "InspectImage", arg0) ret0, _ := ret[0].(*go_dockerclient.Image) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) InspectImage(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectImage", arg0) +// InspectImage indicates an expected call of InspectImage +func (mr *MockDockerClientMockRecorder) InspectImage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImage", reflect.TypeOf((*MockDockerClient)(nil).InspectImage), arg0) } -func (_m *MockDockerClient) KnownVersions() []dockerclient.DockerVersion { - ret := _m.ctrl.Call(_m, "KnownVersions") +// KnownVersions mocks base method +func (m *MockDockerClient) KnownVersions() []dockerclient.DockerVersion { + ret := m.ctrl.Call(m, "KnownVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -func (_mr *_MockDockerClientRecorder) KnownVersions() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "KnownVersions") +// KnownVersions indicates an expected call of KnownVersions +func (mr *MockDockerClientMockRecorder) KnownVersions() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnownVersions", reflect.TypeOf((*MockDockerClient)(nil).KnownVersions)) } -func (_m *MockDockerClient) ListContainers(_param0 bool, _param1 time.Duration) ListContainersResponse { - ret := _m.ctrl.Call(_m, "ListContainers", _param0, _param1) +// ListContainers mocks base method +func (m *MockDockerClient) ListContainers(arg0 bool, arg1 time.Duration) ListContainersResponse { + ret := m.ctrl.Call(m, "ListContainers", arg0, arg1) ret0, _ := ret[0].(ListContainersResponse) return ret0 } -func (_mr *_MockDockerClientRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ListContainers", arg0, arg1) +// ListContainers indicates an expected call of ListContainers +func (mr *MockDockerClientMockRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockDockerClient)(nil).ListContainers), arg0, arg1) } -func (_m *MockDockerClient) LoadImage(_param0 io.Reader, _param1 time.Duration) error { - ret := _m.ctrl.Call(_m, "LoadImage", _param0, _param1) +// LoadImage mocks base method +func (m *MockDockerClient) LoadImage(arg0 io.Reader, arg1 time.Duration) error { + ret := m.ctrl.Call(m, "LoadImage", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockDockerClientRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0, arg1) +// LoadImage indicates an expected call of LoadImage +func (mr *MockDockerClientMockRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadImage", reflect.TypeOf((*MockDockerClient)(nil).LoadImage), arg0, arg1) } -func (_m *MockDockerClient) PullImage(_param0 string, _param1 *api.RegistryAuthenticationData) DockerContainerMetadata { - ret := _m.ctrl.Call(_m, "PullImage", _param0, _param1) +// PullImage mocks base method +func (m *MockDockerClient) PullImage(arg0 string, arg1 *api.RegistryAuthenticationData) DockerContainerMetadata { + ret := m.ctrl.Call(m, "PullImage", arg0, arg1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "PullImage", arg0, arg1) +// PullImage indicates an expected call of PullImage +func (mr *MockDockerClientMockRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockDockerClient)(nil).PullImage), arg0, arg1) } -func (_m *MockDockerClient) RemoveContainer(_param0 string, _param1 time.Duration) error { - ret := _m.ctrl.Call(_m, "RemoveContainer", _param0, _param1) +// RemoveContainer mocks base method +func (m *MockDockerClient) RemoveContainer(arg0 string, arg1 time.Duration) error { + ret := m.ctrl.Call(m, "RemoveContainer", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockDockerClientRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainer", arg0, arg1) +// RemoveContainer indicates an expected call of RemoveContainer +func (mr *MockDockerClientMockRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockDockerClient)(nil).RemoveContainer), arg0, arg1) } -func (_m *MockDockerClient) RemoveImage(_param0 string, _param1 time.Duration) error { - ret := _m.ctrl.Call(_m, "RemoveImage", _param0, _param1) +// RemoveImage mocks base method +func (m *MockDockerClient) RemoveImage(arg0 string, arg1 time.Duration) error { + ret := m.ctrl.Call(m, "RemoveImage", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockDockerClientRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImage", arg0, arg1) +// RemoveImage indicates an expected call of RemoveImage +func (mr *MockDockerClientMockRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockDockerClient)(nil).RemoveImage), arg0, arg1) } -func (_m *MockDockerClient) StartContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { - ret := _m.ctrl.Call(_m, "StartContainer", _param0, _param1) +// StartContainer mocks base method +func (m *MockDockerClient) StartContainer(arg0 string, arg1 time.Duration) DockerContainerMetadata { + ret := m.ctrl.Call(m, "StartContainer", arg0, arg1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainer", arg0, arg1) +// StartContainer indicates an expected call of StartContainer +func (mr *MockDockerClientMockRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockDockerClient)(nil).StartContainer), arg0, arg1) } -func (_m *MockDockerClient) Stats(_param0 string, _param1 context.Context) (<-chan *go_dockerclient.Stats, error) { - ret := _m.ctrl.Call(_m, "Stats", _param0, _param1) +// Stats mocks base method +func (m *MockDockerClient) Stats(arg0 string, arg1 context.Context) (<-chan *go_dockerclient.Stats, error) { + ret := m.ctrl.Call(m, "Stats", arg0, arg1) ret0, _ := ret[0].(<-chan *go_dockerclient.Stats) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Stats", arg0, arg1) +// Stats indicates an expected call of Stats +func (mr *MockDockerClientMockRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockDockerClient)(nil).Stats), arg0, arg1) } -func (_m *MockDockerClient) StopContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { - ret := _m.ctrl.Call(_m, "StopContainer", _param0, _param1) +// StopContainer mocks base method +func (m *MockDockerClient) StopContainer(arg0 string, arg1 time.Duration) DockerContainerMetadata { + ret := m.ctrl.Call(m, "StopContainer", arg0, arg1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -func (_mr *_MockDockerClientRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainer", arg0, arg1) +// StopContainer indicates an expected call of StopContainer +func (mr *MockDockerClientMockRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockDockerClient)(nil).StopContainer), arg0, arg1) } -func (_m *MockDockerClient) SupportedVersions() []dockerclient.DockerVersion { - ret := _m.ctrl.Call(_m, "SupportedVersions") +// SupportedVersions mocks base method +func (m *MockDockerClient) SupportedVersions() []dockerclient.DockerVersion { + ret := m.ctrl.Call(m, "SupportedVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -func (_mr *_MockDockerClientRecorder) SupportedVersions() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SupportedVersions") +// SupportedVersions indicates an expected call of SupportedVersions +func (mr *MockDockerClientMockRecorder) SupportedVersions() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportedVersions", reflect.TypeOf((*MockDockerClient)(nil).SupportedVersions)) } -func (_m *MockDockerClient) Version() (string, error) { - ret := _m.ctrl.Call(_m, "Version") +// Version mocks base method +func (m *MockDockerClient) Version() (string, error) { + ret := m.ctrl.Call(m, "Version") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockDockerClientRecorder) Version() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") +// Version indicates an expected call of Version +func (mr *MockDockerClientMockRecorder) Version() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockDockerClient)(nil).Version)) } -func (_m *MockDockerClient) WithVersion(_param0 dockerclient.DockerVersion) DockerClient { - ret := _m.ctrl.Call(_m, "WithVersion", _param0) +// WithVersion mocks base method +func (m *MockDockerClient) WithVersion(arg0 dockerclient.DockerVersion) DockerClient { + ret := m.ctrl.Call(m, "WithVersion", arg0) ret0, _ := ret[0].(DockerClient) return ret0 } -func (_mr *_MockDockerClientRecorder) WithVersion(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WithVersion", arg0) +// WithVersion indicates an expected call of WithVersion +func (mr *MockDockerClientMockRecorder) WithVersion(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithVersion", reflect.TypeOf((*MockDockerClient)(nil).WithVersion), arg0) } -// Mock of ImageManager interface +// MockImageManager is a mock of ImageManager interface type MockImageManager struct { ctrl *gomock.Controller - recorder *_MockImageManagerRecorder + recorder *MockImageManagerMockRecorder } -// Recorder for MockImageManager (not exported) -type _MockImageManagerRecorder struct { +// MockImageManagerMockRecorder is the mock recorder for MockImageManager +type MockImageManagerMockRecorder struct { mock *MockImageManager } +// NewMockImageManager creates a new mock instance func NewMockImageManager(ctrl *gomock.Controller) *MockImageManager { mock := &MockImageManager{ctrl: ctrl} - mock.recorder = &_MockImageManagerRecorder{mock} + mock.recorder = &MockImageManagerMockRecorder{mock} return mock } -func (_m *MockImageManager) EXPECT() *_MockImageManagerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockImageManager) EXPECT() *MockImageManagerMockRecorder { + return m.recorder } -func (_m *MockImageManager) AddAllImageStates(_param0 []*image.ImageState) { - _m.ctrl.Call(_m, "AddAllImageStates", _param0) +// AddAllImageStates mocks base method +func (m *MockImageManager) AddAllImageStates(arg0 []*image.ImageState) { + m.ctrl.Call(m, "AddAllImageStates", arg0) } -func (_mr *_MockImageManagerRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddAllImageStates", arg0) +// AddAllImageStates indicates an expected call of AddAllImageStates +func (mr *MockImageManagerMockRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAllImageStates", reflect.TypeOf((*MockImageManager)(nil).AddAllImageStates), arg0) } -func (_m *MockImageManager) GetImageStateFromImageName(_param0 string) *image.ImageState { - ret := _m.ctrl.Call(_m, "GetImageStateFromImageName", _param0) +// GetImageStateFromImageName mocks base method +func (m *MockImageManager) GetImageStateFromImageName(arg0 string) *image.ImageState { + ret := m.ctrl.Call(m, "GetImageStateFromImageName", arg0) ret0, _ := ret[0].(*image.ImageState) return ret0 } -func (_mr *_MockImageManagerRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetImageStateFromImageName", arg0) +// GetImageStateFromImageName indicates an expected call of GetImageStateFromImageName +func (mr *MockImageManagerMockRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageStateFromImageName", reflect.TypeOf((*MockImageManager)(nil).GetImageStateFromImageName), arg0) } -func (_m *MockImageManager) RecordContainerReference(_param0 *api.Container) error { - ret := _m.ctrl.Call(_m, "RecordContainerReference", _param0) +// RecordContainerReference mocks base method +func (m *MockImageManager) RecordContainerReference(arg0 *api.Container) error { + ret := m.ctrl.Call(m, "RecordContainerReference", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockImageManagerRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RecordContainerReference", arg0) +// RecordContainerReference indicates an expected call of RecordContainerReference +func (mr *MockImageManagerMockRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordContainerReference", reflect.TypeOf((*MockImageManager)(nil).RecordContainerReference), arg0) } -func (_m *MockImageManager) RemoveContainerReferenceFromImageState(_param0 *api.Container) error { - ret := _m.ctrl.Call(_m, "RemoveContainerReferenceFromImageState", _param0) +// RemoveContainerReferenceFromImageState mocks base method +func (m *MockImageManager) RemoveContainerReferenceFromImageState(arg0 *api.Container) error { + ret := m.ctrl.Call(m, "RemoveContainerReferenceFromImageState", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockImageManagerRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainerReferenceFromImageState", arg0) +// RemoveContainerReferenceFromImageState indicates an expected call of RemoveContainerReferenceFromImageState +func (mr *MockImageManagerMockRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainerReferenceFromImageState", reflect.TypeOf((*MockImageManager)(nil).RemoveContainerReferenceFromImageState), arg0) } -func (_m *MockImageManager) SetSaver(_param0 statemanager.Saver) { - _m.ctrl.Call(_m, "SetSaver", _param0) +// SetSaver mocks base method +func (m *MockImageManager) SetSaver(arg0 statemanager.Saver) { + m.ctrl.Call(m, "SetSaver", arg0) } -func (_mr *_MockImageManagerRecorder) SetSaver(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) +// SetSaver indicates an expected call of SetSaver +func (mr *MockImageManagerMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSaver", reflect.TypeOf((*MockImageManager)(nil).SetSaver), arg0) } func (_m *MockImageManager) StartImageCleanupProcess(_param0 context0.Context) { _m.ctrl.Call(_m, "StartImageCleanupProcess", _param0) } -func (_mr *_MockImageManagerRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "StartImageCleanupProcess", arg0) +// StartImageCleanupProcess indicates an expected call of StartImageCleanupProcess +func (mr *MockImageManagerMockRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartImageCleanupProcess", reflect.TypeOf((*MockImageManager)(nil).StartImageCleanupProcess), arg0) } diff --git a/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go b/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go index ba7c578d551..0d7406b0664 100644 --- a/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go +++ b/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go @@ -11,55 +11,64 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/eni/netlinkwrapper (interfaces: NetLink) +// Package mock_netlinkwrapper is a generated GoMock package. package mock_netlinkwrapper import ( + reflect "reflect" + gomock "github.com/golang/mock/gomock" netlink "github.com/vishvananda/netlink" ) -// Mock of NetLink interface +// MockNetLink is a mock of NetLink interface type MockNetLink struct { ctrl *gomock.Controller - recorder *_MockNetLinkRecorder + recorder *MockNetLinkMockRecorder } -// Recorder for MockNetLink (not exported) -type _MockNetLinkRecorder struct { +// MockNetLinkMockRecorder is the mock recorder for MockNetLink +type MockNetLinkMockRecorder struct { mock *MockNetLink } +// NewMockNetLink creates a new mock instance func NewMockNetLink(ctrl *gomock.Controller) *MockNetLink { mock := &MockNetLink{ctrl: ctrl} - mock.recorder = &_MockNetLinkRecorder{mock} + mock.recorder = &MockNetLinkMockRecorder{mock} return mock } -func (_m *MockNetLink) EXPECT() *_MockNetLinkRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockNetLink) EXPECT() *MockNetLinkMockRecorder { + return m.recorder } -func (_m *MockNetLink) LinkByName(_param0 string) (netlink.Link, error) { - ret := _m.ctrl.Call(_m, "LinkByName", _param0) +// LinkByName mocks base method +func (m *MockNetLink) LinkByName(arg0 string) (netlink.Link, error) { + ret := m.ctrl.Call(m, "LinkByName", arg0) ret0, _ := ret[0].(netlink.Link) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNetLinkRecorder) LinkByName(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "LinkByName", arg0) +// LinkByName indicates an expected call of LinkByName +func (mr *MockNetLinkMockRecorder) LinkByName(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkByName", reflect.TypeOf((*MockNetLink)(nil).LinkByName), arg0) } -func (_m *MockNetLink) LinkList() ([]netlink.Link, error) { - ret := _m.ctrl.Call(_m, "LinkList") +// LinkList mocks base method +func (m *MockNetLink) LinkList() ([]netlink.Link, error) { + ret := m.ctrl.Call(m, "LinkList") ret0, _ := ret[0].([]netlink.Link) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockNetLinkRecorder) LinkList() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "LinkList") +// LinkList indicates an expected call of LinkList +func (mr *MockNetLinkMockRecorder) LinkList() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkList", reflect.TypeOf((*MockNetLink)(nil).LinkList)) } diff --git a/agent/eni/pause/mocks/load_mocks.go b/agent/eni/pause/mocks/load_mocks.go index 31a04f6e1ef..484e546abc9 100644 --- a/agent/eni/pause/mocks/load_mocks.go +++ b/agent/eni/pause/mocks/load_mocks.go @@ -11,46 +11,53 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/eni/pause (interfaces: Loader) +// Package mock_pause is a generated GoMock package. package mock_pause import ( + reflect "reflect" + config "github.com/aws/amazon-ecs-agent/agent/config" engine "github.com/aws/amazon-ecs-agent/agent/engine" go_dockerclient "github.com/fsouza/go-dockerclient" gomock "github.com/golang/mock/gomock" ) -// Mock of Loader interface +// MockLoader is a mock of Loader interface type MockLoader struct { ctrl *gomock.Controller - recorder *_MockLoaderRecorder + recorder *MockLoaderMockRecorder } -// Recorder for MockLoader (not exported) -type _MockLoaderRecorder struct { +// MockLoaderMockRecorder is the mock recorder for MockLoader +type MockLoaderMockRecorder struct { mock *MockLoader } +// NewMockLoader creates a new mock instance func NewMockLoader(ctrl *gomock.Controller) *MockLoader { mock := &MockLoader{ctrl: ctrl} - mock.recorder = &_MockLoaderRecorder{mock} + mock.recorder = &MockLoaderMockRecorder{mock} return mock } -func (_m *MockLoader) EXPECT() *_MockLoaderRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockLoader) EXPECT() *MockLoaderMockRecorder { + return m.recorder } -func (_m *MockLoader) LoadImage(_param0 *config.Config, _param1 engine.DockerClient) (*go_dockerclient.Image, error) { - ret := _m.ctrl.Call(_m, "LoadImage", _param0, _param1) +// LoadImage mocks base method +func (m *MockLoader) LoadImage(arg0 *config.Config, arg1 engine.DockerClient) (*go_dockerclient.Image, error) { + ret := m.ctrl.Call(m, "LoadImage", arg0, arg1) ret0, _ := ret[0].(*go_dockerclient.Image) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockLoaderRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0, arg1) +// LoadImage indicates an expected call of LoadImage +func (mr *MockLoaderMockRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadImage", reflect.TypeOf((*MockLoader)(nil).LoadImage), arg0, arg1) } diff --git a/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go b/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go index d82440896cc..61e50d4e8bb 100644 --- a/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go +++ b/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go @@ -11,53 +11,62 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/eni/udevwrapper (interfaces: Udev) +// Package mock_udevwrapper is a generated GoMock package. package mock_udevwrapper import ( + reflect "reflect" + udev "github.com/deniswernert/udev" gomock "github.com/golang/mock/gomock" ) -// Mock of Udev interface +// MockUdev is a mock of Udev interface type MockUdev struct { ctrl *gomock.Controller - recorder *_MockUdevRecorder + recorder *MockUdevMockRecorder } -// Recorder for MockUdev (not exported) -type _MockUdevRecorder struct { +// MockUdevMockRecorder is the mock recorder for MockUdev +type MockUdevMockRecorder struct { mock *MockUdev } +// NewMockUdev creates a new mock instance func NewMockUdev(ctrl *gomock.Controller) *MockUdev { mock := &MockUdev{ctrl: ctrl} - mock.recorder = &_MockUdevRecorder{mock} + mock.recorder = &MockUdevMockRecorder{mock} return mock } -func (_m *MockUdev) EXPECT() *_MockUdevRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockUdev) EXPECT() *MockUdevMockRecorder { + return m.recorder } -func (_m *MockUdev) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// Close mocks base method +func (m *MockUdev) Close() error { + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockUdevRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// Close indicates an expected call of Close +func (mr *MockUdevMockRecorder) Close() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockUdev)(nil).Close)) } -func (_m *MockUdev) Monitor(_param0 chan *udev.UEvent) chan bool { - ret := _m.ctrl.Call(_m, "Monitor", _param0) +// Monitor mocks base method +func (m *MockUdev) Monitor(arg0 chan *udev.UEvent) chan bool { + ret := m.ctrl.Call(m, "Monitor", arg0) ret0, _ := ret[0].(chan bool) return ret0 } -func (_mr *_MockUdevRecorder) Monitor(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Monitor", arg0) +// Monitor indicates an expected call of Monitor +func (mr *MockUdevMockRecorder) Monitor(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Monitor", reflect.TypeOf((*MockUdev)(nil).Monitor), arg0) } diff --git a/agent/handlers/mocks/handlers_mocks.go b/agent/handlers/mocks/handlers_mocks.go index b63b06a375e..459cd5ace44 100644 --- a/agent/handlers/mocks/handlers_mocks.go +++ b/agent/handlers/mocks/handlers_mocks.go @@ -11,43 +11,50 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/handlers (interfaces: DockerStateResolver) +// Package mock_handlers is a generated GoMock package. package mock_handlers import ( + reflect "reflect" + dockerstate "github.com/aws/amazon-ecs-agent/agent/engine/dockerstate" gomock "github.com/golang/mock/gomock" ) -// Mock of DockerStateResolver interface +// MockDockerStateResolver is a mock of DockerStateResolver interface type MockDockerStateResolver struct { ctrl *gomock.Controller - recorder *_MockDockerStateResolverRecorder + recorder *MockDockerStateResolverMockRecorder } -// Recorder for MockDockerStateResolver (not exported) -type _MockDockerStateResolverRecorder struct { +// MockDockerStateResolverMockRecorder is the mock recorder for MockDockerStateResolver +type MockDockerStateResolverMockRecorder struct { mock *MockDockerStateResolver } +// NewMockDockerStateResolver creates a new mock instance func NewMockDockerStateResolver(ctrl *gomock.Controller) *MockDockerStateResolver { mock := &MockDockerStateResolver{ctrl: ctrl} - mock.recorder = &_MockDockerStateResolverRecorder{mock} + mock.recorder = &MockDockerStateResolverMockRecorder{mock} return mock } -func (_m *MockDockerStateResolver) EXPECT() *_MockDockerStateResolverRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockDockerStateResolver) EXPECT() *MockDockerStateResolverMockRecorder { + return m.recorder } -func (_m *MockDockerStateResolver) State() dockerstate.TaskEngineState { - ret := _m.ctrl.Call(_m, "State") +// State mocks base method +func (m *MockDockerStateResolver) State() dockerstate.TaskEngineState { + ret := m.ctrl.Call(m, "State") ret0, _ := ret[0].(dockerstate.TaskEngineState) return ret0 } -func (_mr *_MockDockerStateResolverRecorder) State() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "State") +// State indicates an expected call of State +func (mr *MockDockerStateResolverMockRecorder) State() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "State", reflect.TypeOf((*MockDockerStateResolver)(nil).State)) } diff --git a/agent/handlers/mocks/http/handlers_mocks.go b/agent/handlers/mocks/http/handlers_mocks.go index 9881a07cacc..e4e28f56e30 100644 --- a/agent/handlers/mocks/http/handlers_mocks.go +++ b/agent/handlers/mocks/http/handlers_mocks.go @@ -11,63 +11,73 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: net/http (interfaces: ResponseWriter) +// Package mock_http is a generated GoMock package. package mock_http import ( http "net/http" + reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// Mock of ResponseWriter interface +// MockResponseWriter is a mock of ResponseWriter interface type MockResponseWriter struct { ctrl *gomock.Controller - recorder *_MockResponseWriterRecorder + recorder *MockResponseWriterMockRecorder } -// Recorder for MockResponseWriter (not exported) -type _MockResponseWriterRecorder struct { +// MockResponseWriterMockRecorder is the mock recorder for MockResponseWriter +type MockResponseWriterMockRecorder struct { mock *MockResponseWriter } +// NewMockResponseWriter creates a new mock instance func NewMockResponseWriter(ctrl *gomock.Controller) *MockResponseWriter { mock := &MockResponseWriter{ctrl: ctrl} - mock.recorder = &_MockResponseWriterRecorder{mock} + mock.recorder = &MockResponseWriterMockRecorder{mock} return mock } -func (_m *MockResponseWriter) EXPECT() *_MockResponseWriterRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockResponseWriter) EXPECT() *MockResponseWriterMockRecorder { + return m.recorder } -func (_m *MockResponseWriter) Header() http.Header { - ret := _m.ctrl.Call(_m, "Header") +// Header mocks base method +func (m *MockResponseWriter) Header() http.Header { + ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(http.Header) return ret0 } -func (_mr *_MockResponseWriterRecorder) Header() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Header") +// Header indicates an expected call of Header +func (mr *MockResponseWriterMockRecorder) Header() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockResponseWriter)(nil).Header)) } -func (_m *MockResponseWriter) Write(_param0 []byte) (int, error) { - ret := _m.ctrl.Call(_m, "Write", _param0) +// Write mocks base method +func (m *MockResponseWriter) Write(arg0 []byte) (int, error) { + ret := m.ctrl.Call(m, "Write", arg0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockResponseWriterRecorder) Write(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0) +// Write indicates an expected call of Write +func (mr *MockResponseWriterMockRecorder) Write(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockResponseWriter)(nil).Write), arg0) } -func (_m *MockResponseWriter) WriteHeader(_param0 int) { - _m.ctrl.Call(_m, "WriteHeader", _param0) +// WriteHeader mocks base method +func (m *MockResponseWriter) WriteHeader(arg0 int) { + m.ctrl.Call(m, "WriteHeader", arg0) } -func (_mr *_MockResponseWriterRecorder) WriteHeader(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteHeader", arg0) +// WriteHeader indicates an expected call of WriteHeader +func (mr *MockResponseWriterMockRecorder) WriteHeader(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteHeader", reflect.TypeOf((*MockResponseWriter)(nil).WriteHeader), arg0) } diff --git a/agent/httpclient/mock/httpclient.go b/agent/httpclient/mock/httpclient.go index 40af7d40cad..f973bd42560 100644 --- a/agent/httpclient/mock/httpclient.go +++ b/agent/httpclient/mock/httpclient.go @@ -11,45 +11,51 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: net/http (interfaces: RoundTripper) +// Package mock_http is a generated GoMock package. package mock_http import ( http "net/http" + reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// Mock of RoundTripper interface +// MockRoundTripper is a mock of RoundTripper interface type MockRoundTripper struct { ctrl *gomock.Controller - recorder *_MockRoundTripperRecorder + recorder *MockRoundTripperMockRecorder } -// Recorder for MockRoundTripper (not exported) -type _MockRoundTripperRecorder struct { +// MockRoundTripperMockRecorder is the mock recorder for MockRoundTripper +type MockRoundTripperMockRecorder struct { mock *MockRoundTripper } +// NewMockRoundTripper creates a new mock instance func NewMockRoundTripper(ctrl *gomock.Controller) *MockRoundTripper { mock := &MockRoundTripper{ctrl: ctrl} - mock.recorder = &_MockRoundTripperRecorder{mock} + mock.recorder = &MockRoundTripperMockRecorder{mock} return mock } -func (_m *MockRoundTripper) EXPECT() *_MockRoundTripperRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockRoundTripper) EXPECT() *MockRoundTripperMockRecorder { + return m.recorder } -func (_m *MockRoundTripper) RoundTrip(_param0 *http.Request) (*http.Response, error) { - ret := _m.ctrl.Call(_m, "RoundTrip", _param0) +// RoundTrip mocks base method +func (m *MockRoundTripper) RoundTrip(arg0 *http.Request) (*http.Response, error) { + ret := m.ctrl.Call(m, "RoundTrip", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockRoundTripperRecorder) RoundTrip(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RoundTrip", arg0) +// RoundTrip indicates an expected call of RoundTrip +func (mr *MockRoundTripperMockRecorder) RoundTrip(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoundTrip", reflect.TypeOf((*MockRoundTripper)(nil).RoundTrip), arg0) } diff --git a/agent/logger/audit/mocks/audit_log_mocks.go b/agent/logger/audit/mocks/audit_log_mocks.go index 76faa0aeb01..842fc9e0ff8 100644 --- a/agent/logger/audit/mocks/audit_log_mocks.go +++ b/agent/logger/audit/mocks/audit_log_mocks.go @@ -11,94 +11,109 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/logger/audit (interfaces: AuditLogger,InfoLogger) +// Package mock_audit is a generated GoMock package. package mock_audit import ( + reflect "reflect" + request "github.com/aws/amazon-ecs-agent/agent/logger/audit/request" gomock "github.com/golang/mock/gomock" ) -// Mock of AuditLogger interface +// MockAuditLogger is a mock of AuditLogger interface type MockAuditLogger struct { ctrl *gomock.Controller - recorder *_MockAuditLoggerRecorder + recorder *MockAuditLoggerMockRecorder } -// Recorder for MockAuditLogger (not exported) -type _MockAuditLoggerRecorder struct { +// MockAuditLoggerMockRecorder is the mock recorder for MockAuditLogger +type MockAuditLoggerMockRecorder struct { mock *MockAuditLogger } +// NewMockAuditLogger creates a new mock instance func NewMockAuditLogger(ctrl *gomock.Controller) *MockAuditLogger { mock := &MockAuditLogger{ctrl: ctrl} - mock.recorder = &_MockAuditLoggerRecorder{mock} + mock.recorder = &MockAuditLoggerMockRecorder{mock} return mock } -func (_m *MockAuditLogger) EXPECT() *_MockAuditLoggerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockAuditLogger) EXPECT() *MockAuditLoggerMockRecorder { + return m.recorder } -func (_m *MockAuditLogger) GetCluster() string { - ret := _m.ctrl.Call(_m, "GetCluster") +// GetCluster mocks base method +func (m *MockAuditLogger) GetCluster() string { + ret := m.ctrl.Call(m, "GetCluster") ret0, _ := ret[0].(string) return ret0 } -func (_mr *_MockAuditLoggerRecorder) GetCluster() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCluster") +// GetCluster indicates an expected call of GetCluster +func (mr *MockAuditLoggerMockRecorder) GetCluster() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockAuditLogger)(nil).GetCluster)) } -func (_m *MockAuditLogger) GetContainerInstanceArn() string { - ret := _m.ctrl.Call(_m, "GetContainerInstanceArn") +// GetContainerInstanceArn mocks base method +func (m *MockAuditLogger) GetContainerInstanceArn() string { + ret := m.ctrl.Call(m, "GetContainerInstanceArn") ret0, _ := ret[0].(string) return ret0 } -func (_mr *_MockAuditLoggerRecorder) GetContainerInstanceArn() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetContainerInstanceArn") +// GetContainerInstanceArn indicates an expected call of GetContainerInstanceArn +func (mr *MockAuditLoggerMockRecorder) GetContainerInstanceArn() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInstanceArn", reflect.TypeOf((*MockAuditLogger)(nil).GetContainerInstanceArn)) } -func (_m *MockAuditLogger) Log(_param0 request.LogRequest, _param1 int, _param2 string) { - _m.ctrl.Call(_m, "Log", _param0, _param1, _param2) +// Log mocks base method +func (m *MockAuditLogger) Log(arg0 request.LogRequest, arg1 int, arg2 string) { + m.ctrl.Call(m, "Log", arg0, arg1, arg2) } -func (_mr *_MockAuditLoggerRecorder) Log(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Log", arg0, arg1, arg2) +// Log indicates an expected call of Log +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) } -// Mock of InfoLogger interface +// MockInfoLogger is a mock of InfoLogger interface type MockInfoLogger struct { ctrl *gomock.Controller - recorder *_MockInfoLoggerRecorder + recorder *MockInfoLoggerMockRecorder } -// Recorder for MockInfoLogger (not exported) -type _MockInfoLoggerRecorder struct { +// MockInfoLoggerMockRecorder is the mock recorder for MockInfoLogger +type MockInfoLoggerMockRecorder struct { mock *MockInfoLogger } +// NewMockInfoLogger creates a new mock instance func NewMockInfoLogger(ctrl *gomock.Controller) *MockInfoLogger { mock := &MockInfoLogger{ctrl: ctrl} - mock.recorder = &_MockInfoLoggerRecorder{mock} + mock.recorder = &MockInfoLoggerMockRecorder{mock} return mock } -func (_m *MockInfoLogger) EXPECT() *_MockInfoLoggerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockInfoLogger) EXPECT() *MockInfoLoggerMockRecorder { + return m.recorder } -func (_m *MockInfoLogger) Info(_param0 ...interface{}) { - _s := []interface{}{} - for _, _x := range _param0 { - _s = append(_s, _x) +// Info mocks base method +func (m *MockInfoLogger) Info(arg0 ...interface{}) { + varargs := []interface{}{} + for _, a := range arg0 { + varargs = append(varargs, a) } - _m.ctrl.Call(_m, "Info", _s...) + m.ctrl.Call(m, "Info", varargs...) } -func (_mr *_MockInfoLoggerRecorder) Info(arg0 ...interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Info", arg0...) +// Info indicates an expected call of Info +func (mr *MockInfoLoggerMockRecorder) Info(arg0 ...interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockInfoLogger)(nil).Info), arg0...) } diff --git a/agent/statemanager/mocks/statemanager_mocks.go b/agent/statemanager/mocks/statemanager_mocks.go index f96d573d787..a4333ed5ea4 100644 --- a/agent/statemanager/mocks/statemanager_mocks.go +++ b/agent/statemanager/mocks/statemanager_mocks.go @@ -11,62 +11,73 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/statemanager (interfaces: StateManager) +// Package mock_statemanager is a generated GoMock package. package mock_statemanager import ( + reflect "reflect" + gomock "github.com/golang/mock/gomock" ) -// Mock of StateManager interface +// MockStateManager is a mock of StateManager interface type MockStateManager struct { ctrl *gomock.Controller - recorder *_MockStateManagerRecorder + recorder *MockStateManagerMockRecorder } -// Recorder for MockStateManager (not exported) -type _MockStateManagerRecorder struct { +// MockStateManagerMockRecorder is the mock recorder for MockStateManager +type MockStateManagerMockRecorder struct { mock *MockStateManager } +// NewMockStateManager creates a new mock instance func NewMockStateManager(ctrl *gomock.Controller) *MockStateManager { mock := &MockStateManager{ctrl: ctrl} - mock.recorder = &_MockStateManagerRecorder{mock} + mock.recorder = &MockStateManagerMockRecorder{mock} return mock } -func (_m *MockStateManager) EXPECT() *_MockStateManagerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockStateManager) EXPECT() *MockStateManagerMockRecorder { + return m.recorder } -func (_m *MockStateManager) ForceSave() error { - ret := _m.ctrl.Call(_m, "ForceSave") +// ForceSave mocks base method +func (m *MockStateManager) ForceSave() error { + ret := m.ctrl.Call(m, "ForceSave") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockStateManagerRecorder) ForceSave() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ForceSave") +// ForceSave indicates an expected call of ForceSave +func (mr *MockStateManagerMockRecorder) ForceSave() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceSave", reflect.TypeOf((*MockStateManager)(nil).ForceSave)) } -func (_m *MockStateManager) Load() error { - ret := _m.ctrl.Call(_m, "Load") +// Load mocks base method +func (m *MockStateManager) Load() error { + ret := m.ctrl.Call(m, "Load") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockStateManagerRecorder) Load() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Load") +// Load indicates an expected call of Load +func (mr *MockStateManagerMockRecorder) Load() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockStateManager)(nil).Load)) } -func (_m *MockStateManager) Save() error { - ret := _m.ctrl.Call(_m, "Save") +// Save mocks base method +func (m *MockStateManager) Save() error { + ret := m.ctrl.Call(m, "Save") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockStateManagerRecorder) Save() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Save") +// Save indicates an expected call of Save +func (mr *MockStateManagerMockRecorder) Save() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStateManager)(nil).Save)) } diff --git a/agent/stats/mock/engine.go b/agent/stats/mock/engine.go index c6b64a110b2..22127ca68e3 100644 --- a/agent/stats/mock/engine.go +++ b/agent/stats/mock/engine.go @@ -11,45 +11,52 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/stats (interfaces: Engine) +// Package mock_stats is a generated GoMock package. package mock_stats import ( + reflect "reflect" + ecstcs "github.com/aws/amazon-ecs-agent/agent/tcs/model/ecstcs" gomock "github.com/golang/mock/gomock" ) -// Mock of Engine interface +// MockEngine is a mock of Engine interface type MockEngine struct { ctrl *gomock.Controller - recorder *_MockEngineRecorder + recorder *MockEngineMockRecorder } -// Recorder for MockEngine (not exported) -type _MockEngineRecorder struct { +// MockEngineMockRecorder is the mock recorder for MockEngine +type MockEngineMockRecorder struct { mock *MockEngine } +// NewMockEngine creates a new mock instance func NewMockEngine(ctrl *gomock.Controller) *MockEngine { mock := &MockEngine{ctrl: ctrl} - mock.recorder = &_MockEngineRecorder{mock} + mock.recorder = &MockEngineMockRecorder{mock} return mock } -func (_m *MockEngine) EXPECT() *_MockEngineRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockEngine) EXPECT() *MockEngineMockRecorder { + return m.recorder } -func (_m *MockEngine) GetInstanceMetrics() (*ecstcs.MetricsMetadata, []*ecstcs.TaskMetric, error) { - ret := _m.ctrl.Call(_m, "GetInstanceMetrics") +// GetInstanceMetrics mocks base method +func (m *MockEngine) GetInstanceMetrics() (*ecstcs.MetricsMetadata, []*ecstcs.TaskMetric, error) { + ret := m.ctrl.Call(m, "GetInstanceMetrics") ret0, _ := ret[0].(*ecstcs.MetricsMetadata) ret1, _ := ret[1].([]*ecstcs.TaskMetric) ret2, _ := ret[2].(error) return ret0, ret1, ret2 } -func (_mr *_MockEngineRecorder) GetInstanceMetrics() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetInstanceMetrics") +// GetInstanceMetrics indicates an expected call of GetInstanceMetrics +func (mr *MockEngineMockRecorder) GetInstanceMetrics() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMetrics", reflect.TypeOf((*MockEngine)(nil).GetInstanceMetrics)) } diff --git a/agent/stats/resolver/mock/resolver.go b/agent/stats/resolver/mock/resolver.go index 74ee5c3c46e..9f890d23585 100644 --- a/agent/stats/resolver/mock/resolver.go +++ b/agent/stats/resolver/mock/resolver.go @@ -11,55 +11,64 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/stats/resolver (interfaces: ContainerMetadataResolver) +// Package mock_resolver is a generated GoMock package. package mock_resolver import ( + reflect "reflect" + api "github.com/aws/amazon-ecs-agent/agent/api" gomock "github.com/golang/mock/gomock" ) -// Mock of ContainerMetadataResolver interface +// MockContainerMetadataResolver is a mock of ContainerMetadataResolver interface type MockContainerMetadataResolver struct { ctrl *gomock.Controller - recorder *_MockContainerMetadataResolverRecorder + recorder *MockContainerMetadataResolverMockRecorder } -// Recorder for MockContainerMetadataResolver (not exported) -type _MockContainerMetadataResolverRecorder struct { +// MockContainerMetadataResolverMockRecorder is the mock recorder for MockContainerMetadataResolver +type MockContainerMetadataResolverMockRecorder struct { mock *MockContainerMetadataResolver } +// NewMockContainerMetadataResolver creates a new mock instance func NewMockContainerMetadataResolver(ctrl *gomock.Controller) *MockContainerMetadataResolver { mock := &MockContainerMetadataResolver{ctrl: ctrl} - mock.recorder = &_MockContainerMetadataResolverRecorder{mock} + mock.recorder = &MockContainerMetadataResolverMockRecorder{mock} return mock } -func (_m *MockContainerMetadataResolver) EXPECT() *_MockContainerMetadataResolverRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockContainerMetadataResolver) EXPECT() *MockContainerMetadataResolverMockRecorder { + return m.recorder } -func (_m *MockContainerMetadataResolver) ResolveContainer(_param0 string) (*api.DockerContainer, error) { - ret := _m.ctrl.Call(_m, "ResolveContainer", _param0) +// ResolveContainer mocks base method +func (m *MockContainerMetadataResolver) ResolveContainer(arg0 string) (*api.DockerContainer, error) { + ret := m.ctrl.Call(m, "ResolveContainer", arg0) ret0, _ := ret[0].(*api.DockerContainer) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockContainerMetadataResolverRecorder) ResolveContainer(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ResolveContainer", arg0) +// ResolveContainer indicates an expected call of ResolveContainer +func (mr *MockContainerMetadataResolverMockRecorder) ResolveContainer(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveContainer", reflect.TypeOf((*MockContainerMetadataResolver)(nil).ResolveContainer), arg0) } -func (_m *MockContainerMetadataResolver) ResolveTask(_param0 string) (*api.Task, error) { - ret := _m.ctrl.Call(_m, "ResolveTask", _param0) +// ResolveTask mocks base method +func (m *MockContainerMetadataResolver) ResolveTask(arg0 string) (*api.Task, error) { + ret := m.ctrl.Call(m, "ResolveTask", arg0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockContainerMetadataResolverRecorder) ResolveTask(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ResolveTask", arg0) +// ResolveTask indicates an expected call of ResolveTask +func (mr *MockContainerMetadataResolverMockRecorder) ResolveTask(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveTask", reflect.TypeOf((*MockContainerMetadataResolver)(nil).ResolveTask), arg0) } diff --git a/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go index 88e928cd9e7..163fd4164a7 100644 --- a/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go +++ b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go @@ -11,44 +11,51 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper (interfaces: IOUtil) +// Package mock_ioutilwrapper is a generated GoMock package. package mock_ioutilwrapper import ( + reflect "reflect" + oswrapper "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" gomock "github.com/golang/mock/gomock" ) -// Mock of IOUtil interface +// MockIOUtil is a mock of IOUtil interface type MockIOUtil struct { ctrl *gomock.Controller - recorder *_MockIOUtilRecorder + recorder *MockIOUtilMockRecorder } -// Recorder for MockIOUtil (not exported) -type _MockIOUtilRecorder struct { +// MockIOUtilMockRecorder is the mock recorder for MockIOUtil +type MockIOUtilMockRecorder struct { mock *MockIOUtil } +// NewMockIOUtil creates a new mock instance func NewMockIOUtil(ctrl *gomock.Controller) *MockIOUtil { mock := &MockIOUtil{ctrl: ctrl} - mock.recorder = &_MockIOUtilRecorder{mock} + mock.recorder = &MockIOUtilMockRecorder{mock} return mock } -func (_m *MockIOUtil) EXPECT() *_MockIOUtilRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockIOUtil) EXPECT() *MockIOUtilMockRecorder { + return m.recorder } -func (_m *MockIOUtil) TempFile(_param0 string, _param1 string) (oswrapper.File, error) { - ret := _m.ctrl.Call(_m, "TempFile", _param0, _param1) +// TempFile mocks base method +func (m *MockIOUtil) TempFile(arg0, arg1 string) (oswrapper.File, error) { + ret := m.ctrl.Call(m, "TempFile", arg0, arg1) ret0, _ := ret[0].(oswrapper.File) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockIOUtilRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "TempFile", arg0, arg1) +// TempFile indicates an expected call of TempFile +func (mr *MockIOUtilMockRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TempFile", reflect.TypeOf((*MockIOUtil)(nil).TempFile), arg0, arg1) } diff --git a/agent/utils/mocks/utils_mocks.go b/agent/utils/mocks/utils_mocks.go index 1d7b8b26bdf..bcb83fccefc 100644 --- a/agent/utils/mocks/utils_mocks.go +++ b/agent/utils/mocks/utils_mocks.go @@ -11,84 +11,96 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/utils (interfaces: LicenseProvider,Backoff) +// Package mock_utils is a generated GoMock package. package mock_utils import ( + reflect "reflect" time "time" gomock "github.com/golang/mock/gomock" ) -// Mock of LicenseProvider interface +// MockLicenseProvider is a mock of LicenseProvider interface type MockLicenseProvider struct { ctrl *gomock.Controller - recorder *_MockLicenseProviderRecorder + recorder *MockLicenseProviderMockRecorder } -// Recorder for MockLicenseProvider (not exported) -type _MockLicenseProviderRecorder struct { +// MockLicenseProviderMockRecorder is the mock recorder for MockLicenseProvider +type MockLicenseProviderMockRecorder struct { mock *MockLicenseProvider } +// NewMockLicenseProvider creates a new mock instance func NewMockLicenseProvider(ctrl *gomock.Controller) *MockLicenseProvider { mock := &MockLicenseProvider{ctrl: ctrl} - mock.recorder = &_MockLicenseProviderRecorder{mock} + mock.recorder = &MockLicenseProviderMockRecorder{mock} return mock } -func (_m *MockLicenseProvider) EXPECT() *_MockLicenseProviderRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockLicenseProvider) EXPECT() *MockLicenseProviderMockRecorder { + return m.recorder } -func (_m *MockLicenseProvider) GetText() (string, error) { - ret := _m.ctrl.Call(_m, "GetText") +// GetText mocks base method +func (m *MockLicenseProvider) GetText() (string, error) { + ret := m.ctrl.Call(m, "GetText") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockLicenseProviderRecorder) GetText() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "GetText") +// GetText indicates an expected call of GetText +func (mr *MockLicenseProviderMockRecorder) GetText() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetText", reflect.TypeOf((*MockLicenseProvider)(nil).GetText)) } -// Mock of Backoff interface +// MockBackoff is a mock of Backoff interface type MockBackoff struct { ctrl *gomock.Controller - recorder *_MockBackoffRecorder + recorder *MockBackoffMockRecorder } -// Recorder for MockBackoff (not exported) -type _MockBackoffRecorder struct { +// MockBackoffMockRecorder is the mock recorder for MockBackoff +type MockBackoffMockRecorder struct { mock *MockBackoff } +// NewMockBackoff creates a new mock instance func NewMockBackoff(ctrl *gomock.Controller) *MockBackoff { mock := &MockBackoff{ctrl: ctrl} - mock.recorder = &_MockBackoffRecorder{mock} + mock.recorder = &MockBackoffMockRecorder{mock} return mock } -func (_m *MockBackoff) EXPECT() *_MockBackoffRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockBackoff) EXPECT() *MockBackoffMockRecorder { + return m.recorder } -func (_m *MockBackoff) Duration() time.Duration { - ret := _m.ctrl.Call(_m, "Duration") +// Duration mocks base method +func (m *MockBackoff) Duration() time.Duration { + ret := m.ctrl.Call(m, "Duration") ret0, _ := ret[0].(time.Duration) return ret0 } -func (_mr *_MockBackoffRecorder) Duration() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Duration") +// Duration indicates an expected call of Duration +func (mr *MockBackoffMockRecorder) Duration() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Duration", reflect.TypeOf((*MockBackoff)(nil).Duration)) } -func (_m *MockBackoff) Reset() { - _m.ctrl.Call(_m, "Reset") +// Reset mocks base method +func (m *MockBackoff) Reset() { + m.ctrl.Call(m, "Reset") } -func (_mr *_MockBackoffRecorder) Reset() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset") +// Reset indicates an expected call of Reset +func (mr *MockBackoffMockRecorder) Reset() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockBackoff)(nil).Reset)) } diff --git a/agent/utils/oswrapper/mocks/oswrapper_mocks.go b/agent/utils/oswrapper/mocks/oswrapper_mocks.go index d567e39566d..163da2179af 100644 --- a/agent/utils/oswrapper/mocks/oswrapper_mocks.go +++ b/agent/utils/oswrapper/mocks/oswrapper_mocks.go @@ -11,169 +11,197 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/utils/oswrapper (interfaces: File,OS) +// Package mock_oswrapper is a generated GoMock package. package mock_oswrapper import ( os "os" + reflect "reflect" oswrapper "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" gomock "github.com/golang/mock/gomock" ) -// Mock of File interface +// MockFile is a mock of File interface type MockFile struct { ctrl *gomock.Controller - recorder *_MockFileRecorder + recorder *MockFileMockRecorder } -// Recorder for MockFile (not exported) -type _MockFileRecorder struct { +// MockFileMockRecorder is the mock recorder for MockFile +type MockFileMockRecorder struct { mock *MockFile } +// NewMockFile creates a new mock instance func NewMockFile(ctrl *gomock.Controller) *MockFile { mock := &MockFile{ctrl: ctrl} - mock.recorder = &_MockFileRecorder{mock} + mock.recorder = &MockFileMockRecorder{mock} return mock } -func (_m *MockFile) EXPECT() *_MockFileRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockFile) EXPECT() *MockFileMockRecorder { + return m.recorder } -func (_m *MockFile) Chmod(_param0 os.FileMode) error { - ret := _m.ctrl.Call(_m, "Chmod", _param0) +// Chmod mocks base method +func (m *MockFile) Chmod(arg0 os.FileMode) error { + ret := m.ctrl.Call(m, "Chmod", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockFileRecorder) Chmod(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Chmod", arg0) +// Chmod indicates an expected call of Chmod +func (mr *MockFileMockRecorder) Chmod(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFile)(nil).Chmod), arg0) } -func (_m *MockFile) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// Close mocks base method +func (m *MockFile) Close() error { + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockFileRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// Close indicates an expected call of Close +func (mr *MockFileMockRecorder) Close() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFile)(nil).Close)) } -func (_m *MockFile) Name() string { - ret := _m.ctrl.Call(_m, "Name") +// Name mocks base method +func (m *MockFile) Name() string { + ret := m.ctrl.Call(m, "Name") ret0, _ := ret[0].(string) return ret0 } -func (_mr *_MockFileRecorder) Name() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Name") +// Name indicates an expected call of Name +func (mr *MockFileMockRecorder) Name() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFile)(nil).Name)) } -func (_m *MockFile) Sync() error { - ret := _m.ctrl.Call(_m, "Sync") +// Sync mocks base method +func (m *MockFile) Sync() error { + ret := m.ctrl.Call(m, "Sync") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockFileRecorder) Sync() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Sync") +// Sync indicates an expected call of Sync +func (mr *MockFileMockRecorder) Sync() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockFile)(nil).Sync)) } -func (_m *MockFile) Write(_param0 []byte) (int, error) { - ret := _m.ctrl.Call(_m, "Write", _param0) +// Write mocks base method +func (m *MockFile) Write(arg0 []byte) (int, error) { + ret := m.ctrl.Call(m, "Write", arg0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockFileRecorder) Write(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0) +// Write indicates an expected call of Write +func (mr *MockFileMockRecorder) Write(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockFile)(nil).Write), arg0) } -// Mock of OS interface +// MockOS is a mock of OS interface type MockOS struct { ctrl *gomock.Controller - recorder *_MockOSRecorder + recorder *MockOSMockRecorder } -// Recorder for MockOS (not exported) -type _MockOSRecorder struct { +// MockOSMockRecorder is the mock recorder for MockOS +type MockOSMockRecorder struct { mock *MockOS } +// NewMockOS creates a new mock instance func NewMockOS(ctrl *gomock.Controller) *MockOS { mock := &MockOS{ctrl: ctrl} - mock.recorder = &_MockOSRecorder{mock} + mock.recorder = &MockOSMockRecorder{mock} return mock } -func (_m *MockOS) EXPECT() *_MockOSRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockOS) EXPECT() *MockOSMockRecorder { + return m.recorder } -func (_m *MockOS) Create(_param0 string) (oswrapper.File, error) { - ret := _m.ctrl.Call(_m, "Create", _param0) +// Create mocks base method +func (m *MockOS) Create(arg0 string) (oswrapper.File, error) { + ret := m.ctrl.Call(m, "Create", arg0) ret0, _ := ret[0].(oswrapper.File) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockOSRecorder) Create(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0) +// Create indicates an expected call of Create +func (mr *MockOSMockRecorder) Create(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOS)(nil).Create), arg0) } -func (_m *MockOS) IsNotExist(_param0 error) bool { - ret := _m.ctrl.Call(_m, "IsNotExist", _param0) +// IsNotExist mocks base method +func (m *MockOS) IsNotExist(arg0 error) bool { + ret := m.ctrl.Call(m, "IsNotExist", arg0) ret0, _ := ret[0].(bool) return ret0 } -func (_mr *_MockOSRecorder) IsNotExist(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "IsNotExist", arg0) +// IsNotExist indicates an expected call of IsNotExist +func (mr *MockOSMockRecorder) IsNotExist(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNotExist", reflect.TypeOf((*MockOS)(nil).IsNotExist), arg0) } -func (_m *MockOS) MkdirAll(_param0 string, _param1 os.FileMode) error { - ret := _m.ctrl.Call(_m, "MkdirAll", _param0, _param1) +// MkdirAll mocks base method +func (m *MockOS) MkdirAll(arg0 string, arg1 os.FileMode) error { + ret := m.ctrl.Call(m, "MkdirAll", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockOSRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "MkdirAll", arg0, arg1) +// MkdirAll indicates an expected call of MkdirAll +func (mr *MockOSMockRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockOS)(nil).MkdirAll), arg0, arg1) } -func (_m *MockOS) OpenFile(_param0 string, _param1 int, _param2 os.FileMode) (oswrapper.File, error) { - ret := _m.ctrl.Call(_m, "OpenFile", _param0, _param1, _param2) +// OpenFile mocks base method +func (m *MockOS) OpenFile(arg0 string, arg1 int, arg2 os.FileMode) (oswrapper.File, error) { + ret := m.ctrl.Call(m, "OpenFile", arg0, arg1, arg2) ret0, _ := ret[0].(oswrapper.File) ret1, _ := ret[1].(error) return ret0, ret1 } -func (_mr *_MockOSRecorder) OpenFile(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "OpenFile", arg0, arg1, arg2) +// OpenFile indicates an expected call of OpenFile +func (mr *MockOSMockRecorder) OpenFile(arg0, arg1, arg2 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenFile", reflect.TypeOf((*MockOS)(nil).OpenFile), arg0, arg1, arg2) } -func (_m *MockOS) RemoveAll(_param0 string) error { - ret := _m.ctrl.Call(_m, "RemoveAll", _param0) +// RemoveAll mocks base method +func (m *MockOS) RemoveAll(arg0 string) error { + ret := m.ctrl.Call(m, "RemoveAll", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockOSRecorder) RemoveAll(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveAll", arg0) +// RemoveAll indicates an expected call of RemoveAll +func (mr *MockOSMockRecorder) RemoveAll(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAll", reflect.TypeOf((*MockOS)(nil).RemoveAll), arg0) } -func (_m *MockOS) Rename(_param0 string, _param1 string) error { - ret := _m.ctrl.Call(_m, "Rename", _param0, _param1) +// Rename mocks base method +func (m *MockOS) Rename(arg0, arg1 string) error { + ret := m.ctrl.Call(m, "Rename", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockOSRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Rename", arg0, arg1) +// Rename indicates an expected call of Rename +func (mr *MockOSMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockOS)(nil).Rename), arg0, arg1) } diff --git a/agent/utils/ttime/mocks/time_mocks.go b/agent/utils/ttime/mocks/time_mocks.go index 3a2b1ae88e5..9f970652adb 100644 --- a/agent/utils/ttime/mocks/time_mocks.go +++ b/agent/utils/ttime/mocks/time_mocks.go @@ -11,114 +11,132 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/utils/ttime (interfaces: Time,Timer) +// Package mock_ttime is a generated GoMock package. package mock_ttime import ( + reflect "reflect" time "time" ttime "github.com/aws/amazon-ecs-agent/agent/utils/ttime" gomock "github.com/golang/mock/gomock" ) -// Mock of Time interface +// MockTime is a mock of Time interface type MockTime struct { ctrl *gomock.Controller - recorder *_MockTimeRecorder + recorder *MockTimeMockRecorder } -// Recorder for MockTime (not exported) -type _MockTimeRecorder struct { +// MockTimeMockRecorder is the mock recorder for MockTime +type MockTimeMockRecorder struct { mock *MockTime } +// NewMockTime creates a new mock instance func NewMockTime(ctrl *gomock.Controller) *MockTime { mock := &MockTime{ctrl: ctrl} - mock.recorder = &_MockTimeRecorder{mock} + mock.recorder = &MockTimeMockRecorder{mock} return mock } -func (_m *MockTime) EXPECT() *_MockTimeRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTime) EXPECT() *MockTimeMockRecorder { + return m.recorder } -func (_m *MockTime) After(_param0 time.Duration) <-chan time.Time { - ret := _m.ctrl.Call(_m, "After", _param0) +// After mocks base method +func (m *MockTime) After(arg0 time.Duration) <-chan time.Time { + ret := m.ctrl.Call(m, "After", arg0) ret0, _ := ret[0].(<-chan time.Time) return ret0 } -func (_mr *_MockTimeRecorder) After(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "After", arg0) +// After indicates an expected call of After +func (mr *MockTimeMockRecorder) After(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "After", reflect.TypeOf((*MockTime)(nil).After), arg0) } -func (_m *MockTime) AfterFunc(_param0 time.Duration, _param1 func()) ttime.Timer { - ret := _m.ctrl.Call(_m, "AfterFunc", _param0, _param1) +// AfterFunc mocks base method +func (m *MockTime) AfterFunc(arg0 time.Duration, arg1 func()) ttime.Timer { + ret := m.ctrl.Call(m, "AfterFunc", arg0, arg1) ret0, _ := ret[0].(ttime.Timer) return ret0 } -func (_mr *_MockTimeRecorder) AfterFunc(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AfterFunc", arg0, arg1) +// AfterFunc indicates an expected call of AfterFunc +func (mr *MockTimeMockRecorder) AfterFunc(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AfterFunc", reflect.TypeOf((*MockTime)(nil).AfterFunc), arg0, arg1) } -func (_m *MockTime) Now() time.Time { - ret := _m.ctrl.Call(_m, "Now") +// Now mocks base method +func (m *MockTime) Now() time.Time { + ret := m.ctrl.Call(m, "Now") ret0, _ := ret[0].(time.Time) return ret0 } -func (_mr *_MockTimeRecorder) Now() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Now") +// Now indicates an expected call of Now +func (mr *MockTimeMockRecorder) Now() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Now", reflect.TypeOf((*MockTime)(nil).Now)) } -func (_m *MockTime) Sleep(_param0 time.Duration) { - _m.ctrl.Call(_m, "Sleep", _param0) +// Sleep mocks base method +func (m *MockTime) Sleep(arg0 time.Duration) { + m.ctrl.Call(m, "Sleep", arg0) } -func (_mr *_MockTimeRecorder) Sleep(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Sleep", arg0) +// Sleep indicates an expected call of Sleep +func (mr *MockTimeMockRecorder) Sleep(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sleep", reflect.TypeOf((*MockTime)(nil).Sleep), arg0) } -// Mock of Timer interface +// MockTimer is a mock of Timer interface type MockTimer struct { ctrl *gomock.Controller - recorder *_MockTimerRecorder + recorder *MockTimerMockRecorder } -// Recorder for MockTimer (not exported) -type _MockTimerRecorder struct { +// MockTimerMockRecorder is the mock recorder for MockTimer +type MockTimerMockRecorder struct { mock *MockTimer } +// NewMockTimer creates a new mock instance func NewMockTimer(ctrl *gomock.Controller) *MockTimer { mock := &MockTimer{ctrl: ctrl} - mock.recorder = &_MockTimerRecorder{mock} + mock.recorder = &MockTimerMockRecorder{mock} return mock } -func (_m *MockTimer) EXPECT() *_MockTimerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockTimer) EXPECT() *MockTimerMockRecorder { + return m.recorder } -func (_m *MockTimer) Reset(_param0 time.Duration) bool { - ret := _m.ctrl.Call(_m, "Reset", _param0) +// Reset mocks base method +func (m *MockTimer) Reset(arg0 time.Duration) bool { + ret := m.ctrl.Call(m, "Reset", arg0) ret0, _ := ret[0].(bool) return ret0 } -func (_mr *_MockTimerRecorder) Reset(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset", arg0) +// Reset indicates an expected call of Reset +func (mr *MockTimerMockRecorder) Reset(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTimer)(nil).Reset), arg0) } -func (_m *MockTimer) Stop() bool { - ret := _m.ctrl.Call(_m, "Stop") +// Stop mocks base method +func (m *MockTimer) Stop() bool { + ret := m.ctrl.Call(m, "Stop") ret0, _ := ret[0].(bool) return ret0 } -func (_mr *_MockTimerRecorder) Stop() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Stop") +// Stop indicates an expected call of Stop +func (mr *MockTimerMockRecorder) Stop() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockTimer)(nil).Stop)) } diff --git a/agent/wsclient/mock/client.go b/agent/wsclient/mock/client.go index e49ea719ca4..65b66db374d 100644 --- a/agent/wsclient/mock/client.go +++ b/agent/wsclient/mock/client.go @@ -11,125 +11,147 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Automatically generated by MockGen. DO NOT EDIT! +// Code generated by MockGen. DO NOT EDIT. // Source: github.com/aws/amazon-ecs-agent/agent/wsclient (interfaces: ClientServer,WebsocketConn) +// Package mock_wsclient is a generated GoMock package. package mock_wsclient import ( + reflect "reflect" time "time" wsclient "github.com/aws/amazon-ecs-agent/agent/wsclient" gomock "github.com/golang/mock/gomock" ) -// Mock of ClientServer interface +// MockClientServer is a mock of ClientServer interface type MockClientServer struct { ctrl *gomock.Controller - recorder *_MockClientServerRecorder + recorder *MockClientServerMockRecorder } -// Recorder for MockClientServer (not exported) -type _MockClientServerRecorder struct { +// MockClientServerMockRecorder is the mock recorder for MockClientServer +type MockClientServerMockRecorder struct { mock *MockClientServer } +// NewMockClientServer creates a new mock instance func NewMockClientServer(ctrl *gomock.Controller) *MockClientServer { mock := &MockClientServer{ctrl: ctrl} - mock.recorder = &_MockClientServerRecorder{mock} + mock.recorder = &MockClientServerMockRecorder{mock} return mock } -func (_m *MockClientServer) EXPECT() *_MockClientServerRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockClientServer) EXPECT() *MockClientServerMockRecorder { + return m.recorder } -func (_m *MockClientServer) AddRequestHandler(_param0 wsclient.RequestHandler) { - _m.ctrl.Call(_m, "AddRequestHandler", _param0) +// AddRequestHandler mocks base method +func (m *MockClientServer) AddRequestHandler(arg0 wsclient.RequestHandler) { + m.ctrl.Call(m, "AddRequestHandler", arg0) } -func (_mr *_MockClientServerRecorder) AddRequestHandler(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "AddRequestHandler", arg0) +// AddRequestHandler indicates an expected call of AddRequestHandler +func (mr *MockClientServerMockRecorder) AddRequestHandler(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRequestHandler", reflect.TypeOf((*MockClientServer)(nil).AddRequestHandler), arg0) } -func (_m *MockClientServer) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// Close mocks base method +func (m *MockClientServer) Close() error { + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientServerRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// Close indicates an expected call of Close +func (mr *MockClientServerMockRecorder) Close() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClientServer)(nil).Close)) } -func (_m *MockClientServer) Connect() error { - ret := _m.ctrl.Call(_m, "Connect") +// Connect mocks base method +func (m *MockClientServer) Connect() error { + ret := m.ctrl.Call(m, "Connect") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientServerRecorder) Connect() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Connect") +// Connect indicates an expected call of Connect +func (mr *MockClientServerMockRecorder) Connect() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockClientServer)(nil).Connect)) } -func (_m *MockClientServer) Disconnect(_param0 ...interface{}) error { - _s := []interface{}{} - for _, _x := range _param0 { - _s = append(_s, _x) +// Disconnect mocks base method +func (m *MockClientServer) Disconnect(arg0 ...interface{}) error { + varargs := []interface{}{} + for _, a := range arg0 { + varargs = append(varargs, a) } - ret := _m.ctrl.Call(_m, "Disconnect", _s...) + ret := m.ctrl.Call(m, "Disconnect", varargs...) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientServerRecorder) Disconnect(arg0 ...interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Disconnect", arg0...) +// Disconnect indicates an expected call of Disconnect +func (mr *MockClientServerMockRecorder) Disconnect(arg0 ...interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disconnect", reflect.TypeOf((*MockClientServer)(nil).Disconnect), arg0...) } -func (_m *MockClientServer) IsConnected() bool { - ret := _m.ctrl.Call(_m, "IsConnected") +// IsConnected mocks base method +func (m *MockClientServer) IsConnected() bool { + ret := m.ctrl.Call(m, "IsConnected") ret0, _ := ret[0].(bool) return ret0 } -func (_mr *_MockClientServerRecorder) IsConnected() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "IsConnected") +// IsConnected indicates an expected call of IsConnected +func (mr *MockClientServerMockRecorder) IsConnected() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockClientServer)(nil).IsConnected)) } -func (_m *MockClientServer) MakeRequest(_param0 interface{}) error { - ret := _m.ctrl.Call(_m, "MakeRequest", _param0) +// MakeRequest mocks base method +func (m *MockClientServer) MakeRequest(arg0 interface{}) error { + ret := m.ctrl.Call(m, "MakeRequest", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientServerRecorder) MakeRequest(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "MakeRequest", arg0) +// MakeRequest indicates an expected call of MakeRequest +func (mr *MockClientServerMockRecorder) MakeRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRequest", reflect.TypeOf((*MockClientServer)(nil).MakeRequest), arg0) } -func (_m *MockClientServer) Serve() error { - ret := _m.ctrl.Call(_m, "Serve") +// Serve mocks base method +func (m *MockClientServer) Serve() error { + ret := m.ctrl.Call(m, "Serve") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockClientServerRecorder) Serve() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Serve") +// Serve indicates an expected call of Serve +func (mr *MockClientServerMockRecorder) Serve() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Serve", reflect.TypeOf((*MockClientServer)(nil).Serve)) } -func (_m *MockClientServer) SetAnyRequestHandler(_param0 wsclient.RequestHandler) { - _m.ctrl.Call(_m, "SetAnyRequestHandler", _param0) +// SetAnyRequestHandler mocks base method +func (m *MockClientServer) SetAnyRequestHandler(arg0 wsclient.RequestHandler) { + m.ctrl.Call(m, "SetAnyRequestHandler", arg0) } -func (_mr *_MockClientServerRecorder) SetAnyRequestHandler(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SetAnyRequestHandler", arg0) +// SetAnyRequestHandler indicates an expected call of SetAnyRequestHandler +func (mr *MockClientServerMockRecorder) SetAnyRequestHandler(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAnyRequestHandler", reflect.TypeOf((*MockClientServer)(nil).SetAnyRequestHandler), arg0) } -func (_m *MockClientServer) SetConnection(_param0 wsclient.WebsocketConn) { - _m.ctrl.Call(_m, "SetConnection", _param0) +// SetConnection mocks base method +func (m *MockClientServer) SetConnection(arg0 wsclient.WebsocketConn) { + m.ctrl.Call(m, "SetConnection", arg0) } -func (_mr *_MockClientServerRecorder) SetConnection(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "SetConnection", arg0) +// SetConnection indicates an expected call of SetConnection +func (mr *MockClientServerMockRecorder) SetConnection(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConnection", reflect.TypeOf((*MockClientServer)(nil).SetConnection), arg0) } func (_m *MockClientServer) SetReadDeadline(_param0 time.Time) error { @@ -148,51 +170,58 @@ func (_m *MockClientServer) WriteMessage(_param0 []byte) error { return ret0 } -func (_mr *_MockClientServerRecorder) WriteMessage(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessage", arg0) +// WriteMessage indicates an expected call of WriteMessage +func (mr *MockClientServerMockRecorder) WriteMessage(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMessage", reflect.TypeOf((*MockClientServer)(nil).WriteMessage), arg0) } -// Mock of WebsocketConn interface +// MockWebsocketConn is a mock of WebsocketConn interface type MockWebsocketConn struct { ctrl *gomock.Controller - recorder *_MockWebsocketConnRecorder + recorder *MockWebsocketConnMockRecorder } -// Recorder for MockWebsocketConn (not exported) -type _MockWebsocketConnRecorder struct { +// MockWebsocketConnMockRecorder is the mock recorder for MockWebsocketConn +type MockWebsocketConnMockRecorder struct { mock *MockWebsocketConn } +// NewMockWebsocketConn creates a new mock instance func NewMockWebsocketConn(ctrl *gomock.Controller) *MockWebsocketConn { mock := &MockWebsocketConn{ctrl: ctrl} - mock.recorder = &_MockWebsocketConnRecorder{mock} + mock.recorder = &MockWebsocketConnMockRecorder{mock} return mock } -func (_m *MockWebsocketConn) EXPECT() *_MockWebsocketConnRecorder { - return _m.recorder +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockWebsocketConn) EXPECT() *MockWebsocketConnMockRecorder { + return m.recorder } -func (_m *MockWebsocketConn) Close() error { - ret := _m.ctrl.Call(_m, "Close") +// Close mocks base method +func (m *MockWebsocketConn) Close() error { + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockWebsocketConnRecorder) Close() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") +// Close indicates an expected call of Close +func (mr *MockWebsocketConnMockRecorder) Close() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockWebsocketConn)(nil).Close)) } -func (_m *MockWebsocketConn) ReadMessage() (int, []byte, error) { - ret := _m.ctrl.Call(_m, "ReadMessage") +// ReadMessage mocks base method +func (m *MockWebsocketConn) ReadMessage() (int, []byte, error) { + ret := m.ctrl.Call(m, "ReadMessage") ret0, _ := ret[0].(int) ret1, _ := ret[1].([]byte) ret2, _ := ret[2].(error) return ret0, ret1, ret2 } -func (_mr *_MockWebsocketConnRecorder) ReadMessage() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessage") +// ReadMessage indicates an expected call of ReadMessage +func (mr *MockWebsocketConnMockRecorder) ReadMessage() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessage", reflect.TypeOf((*MockWebsocketConn)(nil).ReadMessage)) } func (_m *MockWebsocketConn) SetReadDeadline(_param0 time.Time) error { @@ -221,6 +250,7 @@ func (_m *MockWebsocketConn) WriteMessage(_param0 int, _param1 []byte) error { return ret0 } -func (_mr *_MockWebsocketConnRecorder) WriteMessage(arg0, arg1 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessage", arg0, arg1) +// WriteMessage indicates an expected call of WriteMessage +func (mr *MockWebsocketConnMockRecorder) WriteMessage(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMessage", reflect.TypeOf((*MockWebsocketConn)(nil).WriteMessage), arg0, arg1) } From 9d5d867c3e341100b8066d2e99f36648b5ccd9b0 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 11 Sep 2017 16:39:36 -0700 Subject: [PATCH 06/58] engine: modify tests to include metadata service --- agent/engine/docker_task_engine_test.go | 20 ++++++++++---------- agent/engine/task_manager_test.go | 2 ++ 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/agent/engine/docker_task_engine_test.go b/agent/engine/docker_task_engine_test.go index 04ec6be9920..d3b63c98fe7 100644 --- a/agent/engine/docker_task_engine_test.go +++ b/agent/engine/docker_task_engine_test.go @@ -194,7 +194,7 @@ func TestBatchContainerHappyPath(t *testing.T) { eventStream <- DockerContainerChangeEvent{ Status: api.ContainerStopped, DockerContainerMetadata: DockerContainerMetadata{ - DockerID: "containerId", + DockerID: containerID, ExitCode: &exitCode, }, } @@ -302,16 +302,16 @@ func TestContainerMetadataEnabledHappyPath(t *testing.T) { eventStream <- createDockerEvent(api.ContainerCreated) createStartEventsReported.Done() }() - }).Return(DockerContainerMetadata{DockerID: "containerId"}) + }).Return(DockerContainerMetadata{DockerID: containerID}) - client.EXPECT().StartContainer("containerId", startContainerTimeout).Do( + client.EXPECT().StartContainer(containerID, startContainerTimeout).Do( func(id string, timeout time.Duration) { createStartEventsReported.Add(1) go func() { eventStream <- createDockerEvent(api.ContainerRunning) createStartEventsReported.Done() }() - }).Return(DockerContainerMetadata{DockerID: "containerId"}) + }).Return(DockerContainerMetadata{DockerID: containerID}) metadataManager.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil) } @@ -589,7 +589,7 @@ func TestContainerMetadataEnabledErrorPath(t *testing.T) { // when the steady state for the pause container is set to RESOURCES_PROVISIONED and // the steady state for the normal container is set to RUNNING func TestTaskWithSteadyStateResourcesProvisioned(t *testing.T) { - ctrl, client, mockTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) + ctrl, client, mockTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() mockCNIClient := mock_ecscni.NewMockCNIClient(ctrl) @@ -1580,8 +1580,8 @@ func TestEngineDisableConcurrentPull(t *testing.T) { "Task engine should not be able to perform concurrent pulling for version < 1.11.1") } -func TestPauseContainerHappyPath(t *testing.T) { - ctrl, dockerClient, mockTime, taskEngine, _, imageManager := mocks(t, &defaultConfig) +func TestPauseContaienrHappyPath(t *testing.T) { + ctrl, dockerClient, mockTime, taskEngine, _, imageManager, _ := mocks(t, &defaultConfig) defer ctrl.Finish() cniClient := mock_ecscni.NewMockCNIClient(ctrl) @@ -1692,7 +1692,7 @@ func TestBuildCNIConfigFromTaskContainer(t *testing.T) { t.Run(fmt.Sprintf("When BlockInstanceMetadata is %t", blockIMDS), func(t *testing.T) { config := defaultConfig config.AWSVPCBlockInstanceMetdata = blockIMDS - ctrl, dockerClient, _, taskEngine, _, _ := mocks(t, &config) + ctrl, dockerClient, _, taskEngine, _, _, _ := mocks(t, &config) defer ctrl.Finish() testTask := testdata.LoadTask("sleep5") @@ -1738,7 +1738,7 @@ func TestBuildCNIConfigFromTaskContainer(t *testing.T) { } func TestBuildCNIConfigFromTaskContainerInspectError(t *testing.T) { - ctrl, dockerClient, _, taskEngine, _, _ := mocks(t, &defaultConfig) + ctrl, dockerClient, _, taskEngine, _, _, _ := mocks(t, &defaultConfig) defer ctrl.Finish() testTask := testdata.LoadTask("sleep5") @@ -1760,7 +1760,7 @@ func TestBuildCNIConfigFromTaskContainerInspectError(t *testing.T) { // TestStopPauseContainerCleanupCalled tests when stopping the pause container // its network namespace should be cleaned up first func TestStopPauseContainerCleanupCalled(t *testing.T) { - ctrl, dockerClient, _, taskEngine, _, _ := mocks(t, &defaultConfig) + ctrl, dockerClient, _, taskEngine, _, _, _ := mocks(t, &defaultConfig) defer ctrl.Finish() mockCNIClient := mock_ecscni.NewMockCNIClient(ctrl) diff --git a/agent/engine/task_manager_test.go b/agent/engine/task_manager_test.go index 80d1bb35cdb..60228683350 100644 --- a/agent/engine/task_manager_test.go +++ b/agent/engine/task_manager_test.go @@ -958,6 +958,7 @@ func TestCleanupTaskGivesUpIfWaitingTooLong(t *testing.T) { } func TestCleanupTaskENIs(t *testing.T) { + cfg := config.DefaultConfig() ctrl := gomock.NewController(t) mockTime := mock_ttime.NewMockTime(ctrl) mockState := mock_dockerstate.NewMockTaskEngineState(ctrl) @@ -966,6 +967,7 @@ func TestCleanupTaskENIs(t *testing.T) { defer ctrl.Finish() taskEngine := &DockerTaskEngine{ + cfg: &cfg, saver: statemanager.NewNoopStateManager(), state: mockState, client: mockClient, From 011b1d46c7d7e55e2dd3746d5825a0e23afc4263 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Fri, 8 Sep 2017 15:14:14 -0700 Subject: [PATCH 07/58] engine: metadata updates through agent restarts This change adds logic in the agent to update the metadata file after the agent restarts and the related unit test. Note that we added a MetadataFileUpdated flag in the api.Container struct and this is included with state file's ECSDataVersion 6 bump. --- agent/api/container.go | 18 +++++++ agent/engine/docker_task_engine.go | 15 ++++++ agent/engine/docker_task_engine_test.go | 63 ++++++++++++++++++++++++- agent/statemanager/state_manager.go | 1 + 4 files changed, 96 insertions(+), 1 deletion(-) diff --git a/agent/api/container.go b/agent/api/container.go index bfff3590fb0..baa281a7002 100644 --- a/agent/api/container.go +++ b/agent/api/container.go @@ -123,6 +123,10 @@ type Container struct { // handled properly so that the state storage continues to work. SentStatusUnsafe ContainerStatus `json:"SentStatus"` + // MetadataUpdated is set to true when we have completed updating the + // metadata file + MetadataFileUpdated bool `json:"metadataFileUpdated"` + knownExitCode *int KnownPortBindings []PortBinding @@ -317,3 +321,17 @@ func (c *Container) IsInternal() bool { func (c *Container) IsRunning() bool { return c.GetKnownStatus().IsRunning() } + +func (c *Container) IsMetadataFileUpdated() bool { + c.lock.RLock() + defer c.lock.RUnlock() + + return c.MetadataFileUpdated +} + +func (c *Container) SetMetadataFileUpdated() { + c.lock.Lock() + defer c.lock.Unlock() + + c.MetadataFileUpdated = true +} diff --git a/agent/engine/docker_task_engine.go b/agent/engine/docker_task_engine.go index 93d1f65c323..d2d82f65ad4 100644 --- a/agent/engine/docker_task_engine.go +++ b/agent/engine/docker_task_engine.go @@ -274,6 +274,10 @@ func (engine *DockerTaskEngine) synchronizeState() { } } else { engine.imageManager.RecordContainerReference(cont.Container) + if engine.cfg.ContainerMetadataEnabled && !cont.Container.IsMetadataFileUpdated() { + go engine.updateMetadataFile(task, cont) + } + } if currentState > cont.Container.GetKnownStatus() { cont.Container.SetKnownStatus(currentState) @@ -708,6 +712,7 @@ func (engine *DockerTaskEngine) startContainer(task *api.Task, container *api.Co if err != nil { seelog.Errorf("Update metadata file failed for container %s of task %s: %v", container, task, err) } else { + container.SetMetadataFileUpdated() seelog.Debugf("Updated metadata file for container %s of task %s", container, task) } }() @@ -947,3 +952,13 @@ func (engine *DockerTaskEngine) isParallelPullCompatible() bool { return false } + +func (engine *DockerTaskEngine) updateMetadataFile(task *api.Task, cont *api.DockerContainer) { + err := engine.metadataManager.Update(cont.DockerID, task.Arn, cont.Container.Name) + if err != nil { + seelog.Errorf("Update metadata file failed for container %s of task %s: %v", cont.Container, task, err) + } else { + cont.Container.SetMetadataFileUpdated() + seelog.Debugf("Updated metadata file for container %s of task %s", cont.Container, task) + } +} diff --git a/agent/engine/docker_task_engine_test.go b/agent/engine/docker_task_engine_test.go index d3b63c98fe7..1450577af00 100644 --- a/agent/engine/docker_task_engine_test.go +++ b/agent/engine/docker_task_engine_test.go @@ -1839,7 +1839,7 @@ func TestTaskWithCircularDependency(t *testing.T) { // TestCreateContainerOnAgentRestart tests when agent restarts it should use the // docker container name restored from agent state file to create the container func TestCreateContainerOnAgentRestart(t *testing.T) { - ctrl, client, _, privateTaskEngine, _, _ := mocks(t, &config.Config{}) + ctrl, client, _, privateTaskEngine, _, _, _ := mocks(t, &config.Config{}) saver := mock_statemanager.NewMockStateManager(ctrl) defer ctrl.Finish() @@ -1904,3 +1904,64 @@ func TestPullNormalImage(t *testing.T) { metadata := taskEngine.pullContainer(task, container) assert.Equal(t, DockerContainerMetadata{}, metadata, "expected empty metadata") } + +// TestMetadataFileUpdatedAgentRestart checks whether metadataManager.Update(...) is +// invoked in the path DockerTaskEngine.Init() -> .synchronizeState() -> .updateMetadataFile(...) +// for the following case: +// agent starts, container created, metadata file created, agent restarted, container recovered +// during task engine init, metadata file updated +func TestMetadataFileUpdatedAgentRestart(t *testing.T) { + + conf := &defaultConfig + conf.ContainerMetadataEnabled = true + + ctrl, client, _, privateTaskEngine, _, imageManager, metadataManager := mocks(t, conf) + saver := mock_statemanager.NewMockStateManager(ctrl) + defer ctrl.Finish() + + var wg sync.WaitGroup + wg.Add(1) + + taskEngine, _ := privateTaskEngine.(*DockerTaskEngine) + assert.True(t, taskEngine.cfg.ContainerMetadataEnabled, "ContainerMetadataEnabled set to false.") + + taskEngine.SetSaver(saver) + state := taskEngine.State() + task := testdata.LoadTask("sleep5") + + container, _ := task.ContainerByName("sleep5") + assert.False(t, container.MetadataFileUpdated) + + dockerContainer := &api.DockerContainer{DockerID: containerID, Container: container} + + expectedTaskARN := task.Arn + expectedDockerID := dockerContainer.DockerID + expectedContainerName := container.Name + + state.AddContainer(dockerContainer, task) + + client.EXPECT().Version() + eventStream := make(chan DockerContainerChangeEvent) + client.EXPECT().ContainerEvents(gomock.Any()).Return(eventStream, nil) + imageManager.EXPECT().AddAllImageStates(gomock.Any()).AnyTimes() + imageManager.EXPECT().RecordContainerReference(gomock.Any()).AnyTimes() + imageManager.EXPECT().GetImageStateFromImageName(gomock.Any()).AnyTimes() + client.EXPECT().PullImage(gomock.Any(), gomock.Any()).AnyTimes() + client.EXPECT().DescribeContainer(gomock.Any()).AnyTimes() + saver.EXPECT().Save().AnyTimes() + + metadataManager.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(dockerID string, taskARN string, containerName string) { + assert.Equal(t, expectedTaskARN, taskARN) + assert.Equal(t, expectedContainerName, containerName) + assert.Equal(t, expectedDockerID, dockerID) + wg.Done() + }) + + ctx, cancel := context.WithCancel(context.TODO()) + err := taskEngine.Init(ctx) + assert.NoError(t, err) + defer cancel() + defer taskEngine.Disable() + + wg.Wait() +} diff --git a/agent/statemanager/state_manager.go b/agent/statemanager/state_manager.go index 57b1dc422ab..f59b359aa43 100644 --- a/agent/statemanager/state_manager.go +++ b/agent/statemanager/state_manager.go @@ -49,6 +49,7 @@ const ( // c) Add 'SteadyStateStatus' field to 'Container' struct // d) Add 'ENIAttachments' struct // e) Deprecate 'SteadyStateDependencies' in favor of 'TransitionDependencySet' + // f) Add 'MetadataUpdated' field to 'api.Container' ECSDataVersion = 6 // ecsDataFile specifies the filename in the ECS_DATADIR From b2ee17c808b11ad31b15f5ecb237dd9c8f21e4e0 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Fri, 8 Sep 2017 15:14:14 -0700 Subject: [PATCH 08/58] agent/functional_tests: added unix functional test --- .../task-definition.json | 10 ++++++++ .../tests/functionaltests_unix_test.go | 24 +++++++++++++++++++ agent/functional_tests/util/utils_unix.go | 1 + 3 files changed, 35 insertions(+) create mode 100644 agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json diff --git a/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json b/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json new file mode 100644 index 00000000000..4ce68ce4e4b --- /dev/null +++ b/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json @@ -0,0 +1,10 @@ +{ + "family": "ecsftest-mdservice-validator", + "containerDefinitions": [{ + "image": "127.0.0.1:51670/busybox:latest", + "name": "mdservice-validator-unix", + "cpu": 10, + "memory": 10, + "command": ["sh", "-c", "sleep 1 && if cat $ECS_CONTAINER_METADATA_FILE | grep \"READY\"; then exit 42; else exit 1; fi"] + }] +} diff --git a/agent/functional_tests/tests/functionaltests_unix_test.go b/agent/functional_tests/tests/functionaltests_unix_test.go index e68281fec0c..302a517f462 100644 --- a/agent/functional_tests/tests/functionaltests_unix_test.go +++ b/agent/functional_tests/tests/functionaltests_unix_test.go @@ -636,3 +636,27 @@ func fluentdDriverTest(taskDefinition string, t *testing.T) { err = SearchStrInDir(fluentdLogPath, "ecsfts", logTag) assert.NoError(t, err, "failed to find the log tag specified in the task definition") } + +// TestMetadataServiceValidator Tests that the metadata file can be accessed from the +// container using the ECS_CONTAINER_METADATA_FILE environment variables +func TestMetadataServiceValidator(t *testing.T) { + agentOptions := &AgentOptions{ + ExtraEnvironment: map[string]string{ + "ECS_ENABLE_CONTAINER_METADATA": "true", + }, + } + + agent := RunAgent(t, agentOptions) + defer agent.Cleanup() + + task, err := agent.StartTask(t, "mdservice-validator-unix") + require.NoError(t, err, "Register task definition failed") + defer task.Stop() + + // clean up + err = task.WaitStopped(2 * time.Minute) + require.NoError(t, err, "Error waiting for task to transition to STOPPED") + exitCode, _ := task.ContainerExitcode("mdservice-validator-unix") + + assert.Equal(t, 42, exitCode, fmt.Sprintf("Expected exit code of 42; got %d", exitCode)) +} diff --git a/agent/functional_tests/util/utils_unix.go b/agent/functional_tests/util/utils_unix.go index b9be36484eb..8baec6df5c0 100644 --- a/agent/functional_tests/util/utils_unix.go +++ b/agent/functional_tests/util/utils_unix.go @@ -139,6 +139,7 @@ func (agent *TestAgent) StartAgent() error { Env: []string{ "ECS_CLUSTER=" + Cluster, "ECS_DATADIR=/data", + "ECS_HOST_DATA_DIR=" + agent.TestDir, "ECS_LOGLEVEL=debug", "ECS_LOGFILE=/log/integ_agent.log", "ECS_BACKEND_HOST=" + os.Getenv("ECS_BACKEND_HOST"), From a1525042ee0f691fd913f0a895c1d39443f041be Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Wed, 13 Sep 2017 18:50:23 -0700 Subject: [PATCH 09/58] engine: remove duplicate function --- agent/engine/engine_integ_test.go | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/agent/engine/engine_integ_test.go b/agent/engine/engine_integ_test.go index bb6919cae1c..53cb93977c1 100644 --- a/agent/engine/engine_integ_test.go +++ b/agent/engine/engine_integ_test.go @@ -92,32 +92,6 @@ func setup(cfg *config.Config, t *testing.T) (TaskEngine, func(), credentials.Ma }, credentialsManager } -/* -func discardEvents(from interface{}) func() { - done := make(chan bool) - - go func() { - for { - ndx, _, _ := reflect.Select([]reflect.SelectCase{ - { - Dir: reflect.SelectRecv, - Chan: reflect.ValueOf(from), - }, - { - Dir: reflect.SelectRecv, - Chan: reflect.ValueOf(done), - }, - }) - if ndx == 1 { - break - } - } - }() - return func() { - done <- true - } -} -*/ // TestDockerStateToContainerState tests convert the container status from // docker inspect to the status defined in agent func TestDockerStateToContainerState(t *testing.T) { From cdf61a50ba0313cf87bcb8652cb33429d01bb6be Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Thu, 14 Sep 2017 10:22:08 -0700 Subject: [PATCH 10/58] containermetadata: handle multiple IP addresses --- README.md | 1 - agent/config/config_unix.go | 1 + agent/config/config_windows.go | 1 + agent/containermetadata/parse_metadata.go | 7 ++++--- agent/containermetadata/types.go | 6 +++--- .../mdservice-validator-unix/task-definition.json | 2 +- 6 files changed, 10 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index e52acd2823c..72847654162 100644 --- a/README.md +++ b/README.md @@ -175,7 +175,6 @@ configure them as something other than the defaults. | `ECS_IMAGE_MINIMUM_CLEANUP_AGE` | 30m | The minimum time interval between when an image is pulled and when it can be considered for automated image cleanup. | 1h | 1h | | `ECS_NUM_IMAGES_DELETE_PER_CYCLE` | 5 | The maximum number of images to delete in a single automated image cleanup cycle. If set to less than 1, the value is ignored. | 5 | 5 | | `ECS_INSTANCE_ATTRIBUTES` | `{"stack": "prod"}` | These attributes take effect only during initial registration. After the agent has joined an ECS cluster, use the PutAttributes API action to add additional attributes. For more information, see [Amazon ECS Container Agent Configuration](http://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the Amazon ECS Developer Guide.| `{}` | `{}` | -<<<<<<< 6f11735d92bbf1ce7bbe099721a17384095fdff7 | `ECS_ENABLE_TASK_ENI` | `false` | Whether to enable task networking for task to be launched with its own network interface | `false` | Not applicable | | `ECS_CNI_PLUGINS_PATH` | `/ecs/cni` | The path where the cni binary file is located | `/amazon-ecs-cni-plugins` | Not applicable | | `ECS_AWSVPC_BLOCK_IMDS` | `true` | Whether to block access to [Instance Metdata](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) for Tasks started with `awsvpc` network mode | `false` | Not applicable | diff --git a/agent/config/config_unix.go b/agent/config/config_unix.go index 1987f86018b..5700b8279fa 100644 --- a/agent/config/config_unix.go +++ b/agent/config/config_unix.go @@ -49,6 +49,7 @@ func DefaultConfig() Config { PauseContainerImageName: DefaultPauseContainerImageName, PauseContainerTag: DefaultPauseContainerTag, AWSVPCBlockInstanceMetdata: false, + ContainerMetadataEnabled: false, } } diff --git a/agent/config/config_windows.go b/agent/config/config_windows.go index ec41ac89fb9..21d8589afbd 100644 --- a/agent/config/config_windows.go +++ b/agent/config/config_windows.go @@ -75,6 +75,7 @@ func DefaultConfig() Config { MinimumImageDeletionAge: DefaultImageDeletionAge, ImageCleanupInterval: DefaultImageCleanupTimeInterval, NumImagesToDeletePerCycle: DefaultNumImagesToDeletePerCycle, + ContainerMetadataEnabled: false, } } diff --git a/agent/containermetadata/parse_metadata.go b/agent/containermetadata/parse_metadata.go index 14cfd1747f7..3748b63c274 100644 --- a/agent/containermetadata/parse_metadata.go +++ b/agent/containermetadata/parse_metadata.go @@ -121,12 +121,13 @@ func parseNetworkMetadata(settings *docker.NetworkSettings, hostConfig *docker.H if len(settings.Networks) > 0 { for modeFromSettings, containerNetwork := range settings.Networks { networkMode := modeFromSettings - ipv4Address := containerNetwork.IPAddress - network := Network{NetworkMode: networkMode, IPv4Address: ipv4Address} + ipv4Addresses := []string{containerNetwork.IPAddress} + network := Network{NetworkMode: networkMode, IPv4Addresses: ipv4Addresses} networkList = append(networkList, network) } } else { - network := Network{NetworkMode: networkModeFromHostConfig, IPv4Address: ipv4AddressFromSettings} + ipv4Addresses := []string{ipv4AddressFromSettings} + network := Network{NetworkMode: networkModeFromHostConfig, IPv4Addresses: ipv4Addresses} networkList = append(networkList, network) } diff --git a/agent/containermetadata/types.go b/agent/containermetadata/types.go index 4b33d13c5dd..01a3baa7a8b 100644 --- a/agent/containermetadata/types.go +++ b/agent/containermetadata/types.go @@ -35,9 +35,9 @@ type DockerMetadataClient interface { // Network is a struct that keeps track of metadata of a network interface type Network struct { - NetworkMode string `json:"NetworkMode,omitempty"` - IPv4Address string `json:"IPv4Address,omitempty"` - IPv6Address string `json:"IPv6Address,omitempty"` + NetworkMode string `json:"NetworkMode,omitempty"` + IPv4Addresses []string `json:"IPv4Addresses,omitempty"` + IPv6Addresses []string `json:"IPv6Addresses,omitempty"` } // NetworkMetadata keeps track of the data we parse from the Network Settings diff --git a/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json b/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json index 4ce68ce4e4b..ed09c345584 100644 --- a/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json +++ b/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-unix/task-definition.json @@ -5,6 +5,6 @@ "name": "mdservice-validator-unix", "cpu": 10, "memory": 10, - "command": ["sh", "-c", "sleep 1 && if cat $ECS_CONTAINER_METADATA_FILE | grep \"READY\"; then exit 42; else exit 1; fi"] + "command": ["sh", "-c", "sleep 10 && if cat $ECS_CONTAINER_METADATA_FILE | grep \"READY\"; then exit 42; else exit 1; fi"] }] } From b06c3f3dcc0ec077e0363120230025025bc9d59a Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Thu, 14 Sep 2017 16:21:47 -0700 Subject: [PATCH 11/58] containermetadata: use asserts for tests --- README.md | 3 -- agent/api/container.go | 2 +- agent/config/config_test.go | 3 +- agent/containermetadata/manager.go | 1 - agent/containermetadata/manager_test.go | 40 ++++++------------- agent/containermetadata/manager_unix_test.go | 19 +++------ .../containermetadata/manager_windows_test.go | 21 ++++------ agent/containermetadata/utils_test.go | 5 +-- .../containermetadata/write_metadata_test.go | 5 +-- .../write_metadata_unix_test.go | 31 ++++++-------- .../write_metadata_windows_test.go | 23 +++++------ agent/ecscni/mocks/ecscni_mocks.go | 15 ++++--- agent/engine/default.go | 6 ++- agent/engine/docker_task_engine.go | 5 ++- 14 files changed, 75 insertions(+), 104 deletions(-) diff --git a/README.md b/README.md index 72847654162..52162751792 100644 --- a/README.md +++ b/README.md @@ -179,9 +179,6 @@ configure them as something other than the defaults. | `ECS_CNI_PLUGINS_PATH` | `/ecs/cni` | The path where the cni binary file is located | `/amazon-ecs-cni-plugins` | Not applicable | | `ECS_AWSVPC_BLOCK_IMDS` | `true` | Whether to block access to [Instance Metdata](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) for Tasks started with `awsvpc` network mode | `false` | Not applicable | | `ECS_AWSVPC_ADDITIONAL_LOCAL_ROUTES` | `["10.0.15.0/24"]` | In `awsvpc` network mode, traffic to these prefixes will be routed via the host bridge instead of the task ENI | `[]` | Not applicable | -| `ECS_ENABLE_TASK_ENI` | `false` | Whether to enable task networking for task to be launched with its own network interface | `false` | `false` | -| `ECS_CNI_PLUGINS_PATH` | `/ecs/cni` | The path where the cni binary file is located | `/amazon-ecs-cni-plugins` | `/amazon-ecs-cni-plugins` | -| `ECS_AWSVPC_BLOCK_IMDS` | `true` | Whether to block access to [Instance Metdata](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) for Tasks started with `awsvpc` network mode | `false` | `false`| | `ECS_ENABLE_CONTAINER_METADATA` | `` | Whether to enable creation of a metadata file in the containers. If enabled the agent will inject a file with the container's various metadata and the user can access the container's metadata internally by accessing the environment variable $ECS_CONTAINER_METADATA_FILE. | `false` | `false` | | `ECS_HOST_DATA_DIR` | `/var/lib/ecs` | The source directory on the host from which ECS_DATADIR is mounted. We use this to determine the source mount path for container metadata files in the case the Agent is run in a container. We do not use this value in Windows because the Agent is not run on a container in Windows. | `/var/lib/ecs` | `Not used` | diff --git a/agent/api/container.go b/agent/api/container.go index baa281a7002..df0f6118d3f 100644 --- a/agent/api/container.go +++ b/agent/api/container.go @@ -123,7 +123,7 @@ type Container struct { // handled properly so that the state storage continues to work. SentStatusUnsafe ContainerStatus `json:"SentStatus"` - // MetadataUpdated is set to true when we have completed updating the + // MetadataFileUpdated is set to true when we have completed updating the // metadata file MetadataFileUpdated bool `json:"metadataFileUpdated"` diff --git a/agent/config/config_test.go b/agent/config/config_test.go index e9a4a680a00..7c30f91f4f2 100644 --- a/agent/config/config_test.go +++ b/agent/config/config_test.go @@ -151,7 +151,8 @@ func TestEnvironmentConfig(t *testing.T) { assert.NoError(t, err, "should marshal additional local routes") assert.Equal(t, additionalLocalRoutesJSON, string(serializedAdditionalLocalRoutesJSON)) assert.Equal(t, (90 * time.Second), conf.TaskCleanupWaitDuration) - assert.Equal(t, "/etc/ecs/", conf.DataDirOnHost) + assert.Equal(t, "/etc/ecs/", conf.DataDirOnHost, "Wrong value for DataDirOnHost") + assert.True(t, conf.ContainerMetadataEnabled, "Wrong value for ContainerMetadataEnabled") } func TestTrimWhitespace(t *testing.T) { diff --git a/agent/containermetadata/manager.go b/agent/containermetadata/manager.go index 6ff5f242348..2b5bb304588 100644 --- a/agent/containermetadata/manager.go +++ b/agent/containermetadata/manager.go @@ -21,7 +21,6 @@ import ( "github.com/aws/amazon-ecs-agent/agent/config" "github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper" - "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" docker "github.com/fsouza/go-dockerclient" diff --git a/agent/containermetadata/manager_test.go b/agent/containermetadata/manager_test.go index 22c79470aab..813f8010639 100644 --- a/agent/containermetadata/manager_test.go +++ b/agent/containermetadata/manager_test.go @@ -25,6 +25,7 @@ import ( docker "github.com/fsouza/go-dockerclient" "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" ) const ( @@ -54,9 +55,7 @@ func TestSetContainerInstanceARN(t *testing.T) { newManager := &metadataManager{} newManager.SetContainerInstanceARN(mockARN) - if newManager.containerInstanceARN != mockARN { - t.Error("Got unexpected container instance ARN: " + newManager.containerInstanceARN) - } + assert.Equal(t, mockARN, newManager.containerInstanceARN) } // TestCreateMalformedFilepath checks case when taskARN is invalid resulting in an invalid file path @@ -71,9 +70,7 @@ func TestCreateMalformedFilepath(t *testing.T) { err := newManager.Create(nil, nil, mockTaskARN, mockContainerName) expectErrorMessage := fmt.Sprintf("container metadata create for task %s container %s: get metdata file path of task %s container %s: get task ARN: invalid TaskARN %s", mockTaskARN, mockContainerName, mockTaskARN, mockContainerName, mockTaskARN) - if err.Error() != expectErrorMessage { - t.Error("Got unexpected error: " + err.Error()) - } + assert.Equal(t, expectErrorMessage, err.Error()) } // TestCreateMkdirAllFail checks case when MkdirAll call fails @@ -94,9 +91,7 @@ func TestCreateMkdirAllFail(t *testing.T) { err := newManager.Create(nil, nil, mockTaskARN, mockContainerName) expectErrorMessage := fmt.Sprintf("creating metadata directory for task %s: err", mockTaskARN) - if err.Error() != expectErrorMessage { - t.Error("Got unexpected error: " + err.Error()) - } + assert.Equal(t, expectErrorMessage, err.Error()) } // TestUpdateInspectFail checks case when Inspect call fails @@ -115,11 +110,7 @@ func TestUpdateInspectFail(t *testing.T) { mockClient.EXPECT().InspectContainer(mockDockerID, inspectContainerTimeout).Return(nil, errors.New("Inspect fail")) err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) - if err == nil { - t.Error("Expected inspect error to result in update fail") - } else if err.Error() != "Inspect fail" { - t.Error("Got unexpected error: " + err.Error()) - } + assert.Error(t, err, "Expected inspect error to result in update fail") } // TestUpdateNotRunningFail checks case where container is not running @@ -145,13 +136,11 @@ func TestUpdateNotRunningFail(t *testing.T) { err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) expectErrorMessage := fmt.Sprintf("container metadata update for task %s container %s: container not running or invalid", mockTaskARN, mockContainerName) - if err.Error() != expectErrorMessage { - t.Error("Got unexpected error: " + err.Error()) - } + assert.Equal(t, expectErrorMessage, err.Error()) } -// TestCleanMalformedFilepath checks case where ARN is invalid -func TestCleanMalformedFilepath(t *testing.T) { +// TestMalformedFilepath checks case where ARN is invalid +func TestMalformedFilepath(t *testing.T) { _, _, _, _, done := managerSetup(t) defer done() @@ -161,13 +150,11 @@ func TestCleanMalformedFilepath(t *testing.T) { err := newManager.Clean(mockTaskARN) expectErrorMessage := fmt.Sprintf("clean task %s: get task ARN: invalid TaskARN invalidARN", mockTaskARN) - if err.Error() != expectErrorMessage { - t.Error("Got unexpected error: " + err.Error()) - } + assert.Equal(t, expectErrorMessage, err.Error()) } -// TestClean is the mainline case for metadata create -func TestClean(t *testing.T) { +// TestHappyPath is the mainline case for metadata create +func TestHappyPath(t *testing.T) { _, _, mockOS, _, done := managerSetup(t) defer done() @@ -181,7 +168,6 @@ func TestClean(t *testing.T) { mockOS.EXPECT().RemoveAll(gomock.Any()).Return(nil), ) err := newManager.Clean(mockTaskARN) - if err != nil { - t.Error("Got unexpected error: " + err.Error()) - } + + assert.NoError(t, err) } diff --git a/agent/containermetadata/manager_unix_test.go b/agent/containermetadata/manager_unix_test.go index b2ed8e3e921..6c46a047df8 100644 --- a/agent/containermetadata/manager_unix_test.go +++ b/agent/containermetadata/manager_unix_test.go @@ -19,6 +19,7 @@ import ( docker "github.com/fsouza/go-dockerclient" "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" ) // TestCreate is the mainline case for metadata create @@ -47,16 +48,9 @@ func TestCreate(t *testing.T) { } err := newManager.Create(mockConfig, mockHostConfig, mockTaskARN, mockContainerName) - if err != nil { - t.Error("Got unexpected error: " + err.Error()) - } - - if len(mockConfig.Env) != 1 { - t.Error("Unexpected number of environment variables in config: ", len(mockConfig.Env)) - } - if len(mockHostConfig.Binds) != 1 { - t.Error("Unexpected number of binds in host config: ", len(mockHostConfig.Binds)) - } + assert.NoError(t, err) + assert.Equal(t, 1, len(mockConfig.Env), "Unexpected number of environment variables in config") + assert.Equal(t, 1, len(mockHostConfig.Binds), "Unexpected number of binds in host config") } // TestUpdate is mainline case for metadata update @@ -90,7 +84,6 @@ func TestUpdate(t *testing.T) { mockFile.EXPECT().Close().Return(nil), ) err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) - if err != nil { - t.Error("Got unexpected error: " + err.Error()) - } + + assert.NoError(t, err) } diff --git a/agent/containermetadata/manager_windows_test.go b/agent/containermetadata/manager_windows_test.go index bc8b5063964..6121e6804a1 100644 --- a/agent/containermetadata/manager_windows_test.go +++ b/agent/containermetadata/manager_windows_test.go @@ -20,6 +20,7 @@ import ( docker "github.com/fsouza/go-dockerclient" "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" ) // TestCreate is the mainline case for metadata create @@ -47,19 +48,12 @@ func TestCreate(t *testing.T) { } err := newManager.Create(mockConfig, mockHostConfig, mockTaskARN, mockContainerName) - if err != nil { - t.Error("Got unexpected error: " + err.Error()) - } - - if len(mockConfig.Env) != 1 { - t.Error("Unexpected number of environment variables in config: ", len(mockConfig.Env)) - } - if len(mockHostConfig.Binds) != 1 { - t.Error("Unexpected number of binds in host config: ", len(mockHostConfig.Binds)) - } + assert.NoError(t, err) + assert.Equal(t, 1, len(mockConfig.Env), "Unexpected number of environment variables in config") + assert.Equal(t, 1, len(mockHostConfig.Binds), "Unexpected number of binds in host config") } -// TestUpdate is mainline case for metadata update +// TestUpdate is happy path case for metadata update func TestUpdate(t *testing.T) { mockClient, _, mockOS, mockFile, done := managerSetup(t) defer done() @@ -87,7 +81,6 @@ func TestUpdate(t *testing.T) { mockFile.EXPECT().Close().Return(nil), ) err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) - if err != nil { - t.Error("Got unexpected error: " + err.Error()) - } + + assert.NoError(t, err) } diff --git a/agent/containermetadata/utils_test.go b/agent/containermetadata/utils_test.go index 315df3250c2..5d9eeab8fb0 100644 --- a/agent/containermetadata/utils_test.go +++ b/agent/containermetadata/utils_test.go @@ -16,6 +16,7 @@ package containermetadata import ( "fmt" + "github.com/stretchr/testify/assert" "testing" ) @@ -30,7 +31,5 @@ func TestGetTaskIDFailDueToInvalidID(t *testing.T) { _, err := getTaskIDfromARN(mockTaskARN) expectErrorMessage := fmt.Sprintf("get task ARN: cannot find TaskID for TaskARN %s", mockTaskARN) - if err.Error() != expectErrorMessage { - t.Error("Got unexpected error: " + err.Error()) - } + assert.Equal(t, expectErrorMessage, err.Error()) } diff --git a/agent/containermetadata/write_metadata_test.go b/agent/containermetadata/write_metadata_test.go index 44fac4ff6d0..915f64c7fb3 100644 --- a/agent/containermetadata/write_metadata_test.go +++ b/agent/containermetadata/write_metadata_test.go @@ -22,6 +22,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper/mocks" "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" ) func writeSetup(t *testing.T) (*mock_ioutilwrapper.MockIOUtil, *mock_oswrapper.MockOS, *mock_oswrapper.MockFile, func()) { @@ -44,7 +45,5 @@ func TestWriteInvalidARN(t *testing.T) { expectErrorMessage := fmt.Sprintf("write to metadata file for task %s container %s: get metdata file path of task %s container %s: get task ARN: invalid TaskARN %s", mockTaskARN, mockContainerName, mockTaskARN, mockContainerName, mockTaskARN) err := writeToMetadataFile(nil, nil, mockData, mockTaskARN, mockContainerName, mockDataDir) - if err.Error() != expectErrorMessage { - t.Error("Got unexpected error: " + err.Error()) - } + assert.Equal(t, expectErrorMessage, err.Error()) } diff --git a/agent/containermetadata/write_metadata_unix_test.go b/agent/containermetadata/write_metadata_unix_test.go index 45e6945312d..4b42a66184b 100644 --- a/agent/containermetadata/write_metadata_unix_test.go +++ b/agent/containermetadata/write_metadata_unix_test.go @@ -19,6 +19,7 @@ import ( "testing" "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" ) // TestWriteTempFileFail checks case where temp file cannot be made @@ -36,12 +37,10 @@ func TestWriteTempFileFail(t *testing.T) { ) err := writeToMetadataFile(nil, mockIOUtil, mockData, mockTaskARN, mockContainerName, mockDataDir) - if err == nil { - t.Error("Expected error to be returned") - } - if err.Error() != "temp file fail" { - t.Error("Got unexpected error: " + err.Error()) - } + expectErrorMessage := "temp file fail" + + assert.Error(t, err) + assert.Equal(t, expectErrorMessage, err.Error()) } // TestWriteFileWriteFail checks case where write to file fails @@ -61,12 +60,10 @@ func TestWriteFileWriteFail(t *testing.T) { ) err := writeToMetadataFile(nil, mockIOUtil, mockData, mockTaskARN, mockContainerName, mockDataDir) - if err == nil { - t.Error("Expected error to be returned") - } - if err.Error() != "write fail" { - t.Error("Got unexpected error: " + err.Error()) - } + expectErrorMessage := "write fail" + + assert.Error(t, err) + assert.Equal(t, expectErrorMessage, err.Error()) } // TestWriteChmodFail checks case where chmod fails @@ -87,10 +84,8 @@ func TestWriteChmodFail(t *testing.T) { ) err := writeToMetadataFile(nil, mockIOUtil, mockData, mockTaskARN, mockContainerName, mockDataDir) - if err == nil { - t.Error("Expected error to be returned") - } - if err.Error() != "chmod fail" { - t.Error("Got unexpected error: " + err.Error()) - } + expectErrorMessage := "chmod fail" + + assert.Error(t, err) + assert.Equal(t, expectErrorMessage, err.Error()) } diff --git a/agent/containermetadata/write_metadata_windows_test.go b/agent/containermetadata/write_metadata_windows_test.go index 4c8c0217fae..1247449b3d6 100644 --- a/agent/containermetadata/write_metadata_windows_test.go +++ b/agent/containermetadata/write_metadata_windows_test.go @@ -19,6 +19,7 @@ import ( "testing" "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" ) // TestWriteOpenFileFail checks case where open file fails and does not return a NotExist error @@ -38,12 +39,11 @@ func TestWriteOpenFileFail(t *testing.T) { ) err := writeToMetadataFile(mockOS, nil, mockData, mockTaskARN, mockContainerName, mockDataDir) - if err == nil { - t.Error("Expected error to be returned") - } - if err.Error() != "does exist" { - t.Error("Got unexpected error: " + err.Error()) - } + + expectErrorMessage := "does exist" + + assert.Error(t, err) + assert.Equal(t, expectErrorMessage, err.Error()) } // TestWriteFileWrtieFail checks case where we fail to write to file @@ -63,10 +63,9 @@ func TestWriteFileWriteFail(t *testing.T) { ) err := writeToMetadataFile(mockOS, nil, mockData, mockTaskARN, mockContainerName, mockDataDir) - if err == nil { - t.Error("Expected error to be returned") - } - if err.Error() != "write fail" { - t.Error("Got unexpected error: " + err.Error()) - } + + expectErrorMessage := "write fail" + + assert.Error(t, err) + assert.Equal(t, expectErrorMessage, err.Error()) } diff --git a/agent/ecscni/mocks/ecscni_mocks.go b/agent/ecscni/mocks/ecscni_mocks.go index e50b9a20163..4b3c32a5df7 100644 --- a/agent/ecscni/mocks/ecscni_mocks.go +++ b/agent/ecscni/mocks/ecscni_mocks.go @@ -72,18 +72,21 @@ func (mr *MockCNIClientMockRecorder) CleanupNS(arg0 interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanupNS", reflect.TypeOf((*MockCNIClient)(nil).CleanupNS), arg0) } -func (_m *MockCNIClient) ReleaseIPResource(_param0 *ecscni.Config) error { - ret := _m.ctrl.Call(_m, "ReleaseIPResource", _param0) +// ReleaseIPResource mocks base method +func (m *MockCNIClient) ReleaseIPResource(arg0 *ecscni.Config) error { + ret := m.ctrl.Call(m, "ReleaseIPResource", arg0) ret0, _ := ret[0].(error) return ret0 } -func (_mr *_MockCNIClientRecorder) ReleaseIPResource(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "ReleaseIPResource", arg0) +// ReleaseIPResource indicates an expected call of ReleaseIPResource +func (mr *MockCNIClientMockRecorder) ReleaseIPResource(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIPResource", reflect.TypeOf((*MockCNIClient)(nil).ReleaseIPResource), arg0) } -func (_m *MockCNIClient) SetupNS(_param0 *ecscni.Config) error { - ret := _m.ctrl.Call(_m, "SetupNS", _param0) +// SetupNS mocks base method +func (m *MockCNIClient) SetupNS(arg0 *ecscni.Config) error { + ret := m.ctrl.Call(m, "SetupNS", arg0) ret0, _ := ret[0].(error) return ret0 } diff --git a/agent/engine/default.go b/agent/engine/default.go index 20f2d9a54f9..fde764e3385 100644 --- a/agent/engine/default.go +++ b/agent/engine/default.go @@ -27,6 +27,10 @@ import ( var log = logger.ForModule("TaskEngine") // NewTaskEngine returns a default TaskEngine -func NewTaskEngine(cfg *config.Config, client DockerClient, credentialsManager credentials.Manager, containerChangeEventStream *eventstream.EventStream, imageManager ImageManager, state dockerstate.TaskEngineState, metadataManager containermetadata.Manager) TaskEngine { +func NewTaskEngine(cfg *config.Config, client DockerClient, + credentialsManager credentials.Manager, + containerChangeEventStream *eventstream.EventStream, + imageManager ImageManager, state dockerstate.TaskEngineState, + metadataManager containermetadata.Manager) TaskEngine { return NewDockerTaskEngine(cfg, client, credentialsManager, containerChangeEventStream, imageManager, state, metadataManager) } diff --git a/agent/engine/docker_task_engine.go b/agent/engine/docker_task_engine.go index d2d82f65ad4..8dafb475c76 100644 --- a/agent/engine/docker_task_engine.go +++ b/agent/engine/docker_task_engine.go @@ -101,7 +101,10 @@ type DockerTaskEngine struct { // The distinction between created and initialized is that when created it may // be serialized/deserialized, but it will not communicate with docker until it // is also initialized. -func NewDockerTaskEngine(cfg *config.Config, client DockerClient, credentialsManager credentials.Manager, containerChangeEventStream *eventstream.EventStream, imageManager ImageManager, state dockerstate.TaskEngineState, metadataManager containermetadata.Manager) *DockerTaskEngine { +func NewDockerTaskEngine(cfg *config.Config, client DockerClient, + credentialsManager credentials.Manager, containerChangeEventStream *eventstream.EventStream, + imageManager ImageManager, state dockerstate.TaskEngineState, + metadataManager containermetadata.Manager) *DockerTaskEngine { dockerTaskEngine := &DockerTaskEngine{ cfg: cfg, client: client, From 9e0d80fa4826c22dd39e39933e6d746f1c0e87de Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Fri, 22 Sep 2017 09:44:45 -0700 Subject: [PATCH 12/58] functional_tests: added windows functional test --- agent/api/container.go | 3 ++ agent/config/config_windows.go | 3 +- agent/containermetadata/manager.go | 15 +++----- .../containermetadata/manager_windows_test.go | 5 +-- .../write_metadata_windows.go | 11 ++---- .../write_metadata_windows_test.go | 1 - agent/engine/docker_task_engine.go | 6 +-- .../task-definition.json | 12 ++++++ .../tests/functionaltests_windows_test.go | 37 +++++++++++++++++++ agent/functional_tests/util/utils_windows.go | 10 +++++ 10 files changed, 77 insertions(+), 26 deletions(-) create mode 100644 agent/functional_tests/testdata/taskdefinitions/mdservice-validator-windows/task-definition.json diff --git a/agent/api/container.go b/agent/api/container.go index df0f6118d3f..b0efb8cc6cc 100644 --- a/agent/api/container.go +++ b/agent/api/container.go @@ -322,6 +322,8 @@ func (c *Container) IsRunning() bool { return c.GetKnownStatus().IsRunning() } +// IsMetadataFileUpdated() returns true if the metadata file has been once the +// metadata file is ready and will no longer change func (c *Container) IsMetadataFileUpdated() bool { c.lock.RLock() defer c.lock.RUnlock() @@ -329,6 +331,7 @@ func (c *Container) IsMetadataFileUpdated() bool { return c.MetadataFileUpdated } +// SetMetadataFileUpdated sets the container's MetadataFileUpdated status to true func (c *Container) SetMetadataFileUpdated() { c.lock.Lock() defer c.lock.Unlock() diff --git a/agent/config/config_windows.go b/agent/config/config_windows.go index 21d8589afbd..c64d5dd0a15 100644 --- a/agent/config/config_windows.go +++ b/agent/config/config_windows.go @@ -61,7 +61,8 @@ func DefaultConfig() Config { }, ReservedPortsUDP: []uint16{}, DataDir: dataDir, - // DataDirOnHost is identical to DataDir for Windows because we do not run on a container + // DataDirOnHost is identical to DataDir for Windows because we do not + // run as a container DataDirOnHost: dataDir, // DisableMetrics is set to true on Windows as docker stats does not work DisableMetrics: true, diff --git a/agent/containermetadata/manager.go b/agent/containermetadata/manager.go index 2b5bb304588..5dcb543db81 100644 --- a/agent/containermetadata/manager.go +++ b/agent/containermetadata/manager.go @@ -31,6 +31,12 @@ const ( inspectContainerTimeout = 30 * time.Second metadataFile = "ecs-container-metadata.json" metadataPerm = 0644 + // MetadataInitial is the initial state of the metadata file which + // contains metadata provided by the ECS Agent + MetadataInitial = "INITIAL" + // MetadataReady is the final state of the metadata file which indicates + // it has acquired all the data it needs (Currently from the Agent and Docker) + MetadataReady = "READY" ) // MetadataStatus specifies the current update status of the metadata file. @@ -42,15 +48,6 @@ const ( // statuses should amended/appended accordingly. type MetadataStatus string -const ( - // MetadataInitial is the initial state of the metadata file which - // contains metadata provided by the ECS Agent - MetadataInitial = "INITIAL" - // MetadataReady is the final state of the metadata file which indicates - // it has acquired all the data it needs (Currently from the Agent and Docker) - MetadataReady = "READY" -) - // Manager is an interface that allows us to abstract away the metadata // operations type Manager interface { diff --git a/agent/containermetadata/manager_windows_test.go b/agent/containermetadata/manager_windows_test.go index 6121e6804a1..b5c3f369335 100644 --- a/agent/containermetadata/manager_windows_test.go +++ b/agent/containermetadata/manager_windows_test.go @@ -15,7 +15,6 @@ package containermetadata import ( - "errors" "testing" docker "github.com/fsouza/go-dockerclient" @@ -35,9 +34,7 @@ func TestCreate(t *testing.T) { gomock.InOrder( mockOS.EXPECT().MkdirAll(gomock.Any(), gomock.Any()).Return(nil), - mockOS.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, errors.New("err")), - mockOS.EXPECT().IsNotExist(gomock.Any()).Return(true), - mockOS.EXPECT().Create(gomock.Any()).Return(mockFile, nil), + mockOS.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockFile, nil), mockFile.EXPECT().Write(gomock.Any()).Return(0, nil), mockFile.EXPECT().Sync().Return(nil), mockFile.EXPECT().Close().Return(nil), diff --git a/agent/containermetadata/write_metadata_windows.go b/agent/containermetadata/write_metadata_windows.go index 2201ac3324a..f4b051fd905 100644 --- a/agent/containermetadata/write_metadata_windows.go +++ b/agent/containermetadata/write_metadata_windows.go @@ -51,17 +51,12 @@ func writeToMetadataFile(osWrap oswrapper.OS, ioutilWrap ioutilwrapper.IOUtil, d } metadataFileName := filepath.Join(metadataFileDir, metadataFile) - file, err := osWrap.OpenFile(metadataFileName, os.O_WRONLY, metadataPerm) + file, err := osWrap.OpenFile(metadataFileName, os.O_WRONLY|os.O_CREATE, metadataPerm) if err != nil { - // Retry if file does not exist - if osWrap.IsNotExist(err) { - file, err = osWrap.Create(metadataFileName) - } - if err != nil { - return err - } + return err } defer file.Close() + _, err = file.Write(data) if err != nil { return err diff --git a/agent/containermetadata/write_metadata_windows_test.go b/agent/containermetadata/write_metadata_windows_test.go index 1247449b3d6..084bf678fe5 100644 --- a/agent/containermetadata/write_metadata_windows_test.go +++ b/agent/containermetadata/write_metadata_windows_test.go @@ -35,7 +35,6 @@ func TestWriteOpenFileFail(t *testing.T) { gomock.InOrder( mockOS.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, mockOpenErr), - mockOS.EXPECT().IsNotExist(mockOpenErr).Return(false), ) err := writeToMetadataFile(mockOS, nil, mockData, mockTaskARN, mockContainerName, mockDataDir) diff --git a/agent/engine/docker_task_engine.go b/agent/engine/docker_task_engine.go index 8dafb475c76..e200598ff1c 100644 --- a/agent/engine/docker_task_engine.go +++ b/agent/engine/docker_task_engine.go @@ -343,7 +343,7 @@ func (engine *DockerTaskEngine) sweepTask(task *api.Task) { if engine.cfg.ContainerMetadataEnabled { err := engine.metadataManager.Clean(task.Arn) if err != nil { - seelog.Errorf("Clean task metadata failed for task %s: %v", task, err) + seelog.Warnf("Clean task metadata failed for task %s: %v", task, err) } } engine.saver.Save() @@ -671,7 +671,7 @@ func (engine *DockerTaskEngine) createContainer(task *api.Task, container *api.C if engine.cfg.ContainerMetadataEnabled && !container.IsInternal() { mderr := engine.metadataManager.Create(config, hostConfig, task.Arn, container.Name) if mderr != nil { - seelog.Errorf("Create metadata failed for container %s of task %s: %v", container, task, mderr) + seelog.Warnf("Create metadata failed for container %s of task %s: %v", container, task, mderr) } } @@ -713,7 +713,7 @@ func (engine *DockerTaskEngine) startContainer(task *api.Task, container *api.Co go func() { err := engine.metadataManager.Update(dockerContainer.DockerID, task.Arn, container.Name) if err != nil { - seelog.Errorf("Update metadata file failed for container %s of task %s: %v", container, task, err) + seelog.Warnf("Update metadata file failed for container %s of task %s: %v", container, task, err) } else { container.SetMetadataFileUpdated() seelog.Debugf("Updated metadata file for container %s of task %s", container, task) diff --git a/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-windows/task-definition.json b/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-windows/task-definition.json new file mode 100644 index 00000000000..6d81554166c --- /dev/null +++ b/agent/functional_tests/testdata/taskdefinitions/mdservice-validator-windows/task-definition.json @@ -0,0 +1,12 @@ +{ + "family": "ecsftest-mdservice-validator", + "networkMode": "none", + "containerDefinitions": [{ + "image": "microsoft/windowsservercore:latest", + "name": "mdservice-validator-windows", + "cpu": 100, + "memory": 100, + "entryPoint": ["powershell"], + "command": ["-c", "sleep 10; if($?){if(cat $env:ECS_CONTAINER_METADATA_FILE | Select-String -pattern READY){exit 42}else {exit 1}};"] + }] +} diff --git a/agent/functional_tests/tests/functionaltests_windows_test.go b/agent/functional_tests/tests/functionaltests_windows_test.go index 552bcada8d9..29401eedcb7 100644 --- a/agent/functional_tests/tests/functionaltests_windows_test.go +++ b/agent/functional_tests/tests/functionaltests_windows_test.go @@ -186,3 +186,40 @@ func taskIamRolesTest(networkMode string, agent *TestAgent, t *testing.T) { } } + +// TestMetadataServiceValidator Tests that the metadata file can be accessed from the +// container using the ECS_CONTAINER_METADATA_FILE environment variables +func TestMetadataServiceValidator(t *testing.T) { + agentOptions := &AgentOptions{ + ExtraEnvironment: map[string]string{ + "ECS_ENABLE_CONTAINER_METADATA": "true", + }, + } + + agent := RunAgent(t, agentOptions) + defer agent.Cleanup() + + tdOverride := make(map[string]string) + tdOverride["$$$TEST_REGION$$$"] = *ECS.Config.Region + tdOverride["$$$NETWORK_MODE$$$"] = "" + + task, err := agent.StartTaskWithTaskDefinitionOverrides(t, "mdservice-validator-windows", tdOverride) + if err != nil { + t.Fatalf("Error starting mdservice-validator-windows: %v", err) + } + + // clean up + err = task.WaitStopped(2 * time.Minute) + require.NoError(t, err, "Error waiting for task to transition to STOPPED") + + containerID, err := agent.ResolveTaskDockerID(task, "mdservice-validator-windows") + if err != nil { + t.Fatalf("Error resolving docker id for container in task: %v", err) + } + + containerMetaData, err := agent.DockerClient.InspectContainer(containerID) + require.NoError(t, err, "Could not inspect container for task") + + exitCode := containerMetaData.State.ExitCode + assert.Equal(t, 42, exitCode, fmt.Sprintf("Expected exit code of 42; got %d", exitCode)) +} diff --git a/agent/functional_tests/util/utils_windows.go b/agent/functional_tests/util/utils_windows.go index 8748ae6f7a4..0bffb7ca99e 100644 --- a/agent/functional_tests/util/utils_windows.go +++ b/agent/functional_tests/util/utils_windows.go @@ -115,6 +115,11 @@ func (agent *TestAgent) StopAgent() error { } func (agent *TestAgent) StartAgent() error { + if agent.Options != nil { + for k, v := range agent.Options.ExtraEnvironment { + os.Setenv(k, v) + } + } agentInvoke := exec.Command(".\\agent.exe") if TestDirectory := os.Getenv("ECS_WINDOWS_TEST_DIR"); TestDirectory != "" { agentInvoke.Dir = TestDirectory @@ -130,6 +135,11 @@ func (agent *TestAgent) StartAgent() error { } func (agent *TestAgent) Cleanup() { + if agent.Options != nil { + for k, _ := range agent.Options.ExtraEnvironment { + os.Unsetenv(k) + } + } key, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Amazon\ECS Agent\State File`, registry.ALL_ACCESS) if err != nil { return From 464003868c87c3e69fc5d2644e7025415b0fa850 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Wed, 4 Oct 2017 13:42:32 -0700 Subject: [PATCH 13/58] agent: downgrade gomock to resolve merge conflicts --- agent/Godeps/Godeps.json | 3 +- .../acs/update_handler/os/mock/filesystem.go | 130 +++--- agent/api/mocks/api_mocks.go | 153 +++---- agent/app/factory/mocks/factory_mocks.go | 65 ++- agent/app/mocks/credentials_mocks.go | 41 +- agent/app/oswrapper/mocks/oswrapper_mocks.go | 31 +- agent/async/mocks/async_mocks.go | 41 +- .../mocks/containermetadata_mocks.go | 86 ++-- agent/credentials/mocks/credentials_mocks.go | 51 +-- agent/ec2/http/mocks/http_mocks.go | 30 +- agent/ec2/mocks/ec2_mocks.go | 137 +++---- agent/ecr/mocks/ecr_mocks.go | 103 ++--- agent/ecs_client/model/ecs/service.go | 12 +- agent/ecscni/mocks/ecscni_mocks.go | 71 ++-- agent/ecscni/mocks_cnitypes/result_mocks.go | 61 ++- agent/ecscni/mocks_libcni/libcni_mocks.go | 61 ++- agent/engine/docker_task_engine_test.go | 4 +- agent/engine/docker_task_engine_unix_test.go | 2 +- .../dockerclient/mocks/dockerclient_mocks.go | 61 ++- .../dockeriface/mocks/dockeriface_mocks.go | 211 ++++------ .../dockerstate/mocks/dockerstate_mocks.go | 211 ++++------ agent/engine/engine_mocks.go | 382 +++++++----------- .../mocks/mock_netlinkwrapper_linux.go | 41 +- agent/eni/pause/mocks/load_mocks.go | 31 +- .../mocks/mock_udevwrapper_linux.go | 41 +- agent/handlers/mocks/handlers_mocks.go | 31 +- agent/handlers/mocks/http/handlers_mocks.go | 50 +-- agent/httpclient/mock/httpclient.go | 30 +- agent/logger/audit/mocks/audit_log_mocks.go | 83 ++-- .../statemanager/mocks/statemanager_mocks.go | 51 +-- agent/stats/mock/engine.go | 31 +- agent/stats/resolver/mock/resolver.go | 41 +- .../mocks/ioutilwrapper_mocks.go | 31 +- agent/utils/mocks/utils_mocks.go | 66 ++- .../utils/oswrapper/mocks/oswrapper_mocks.go | 146 +++---- agent/utils/ttime/mocks/time_mocks.go | 96 ++--- agent/wsclient/mock/client.go | 162 +++----- 37 files changed, 1154 insertions(+), 1724 deletions(-) diff --git a/agent/Godeps/Godeps.json b/agent/Godeps/Godeps.json index d926a37ffd4..75604dbc9ae 100644 --- a/agent/Godeps/Godeps.json +++ b/agent/Godeps/Godeps.json @@ -334,8 +334,7 @@ }, { "ImportPath": "github.com/golang/mock/gomock", - "Comment": "v1.0.0-17-g18f6dd1", - "Rev": "18f6dd13ccdd227b8ebc546ca95cd62a02f3970c" + "Rev": "bd3c8e81be01eef76d4b503f5e687d2d1354d2d9" }, { "ImportPath": "github.com/gorilla/websocket", diff --git a/agent/acs/update_handler/os/mock/filesystem.go b/agent/acs/update_handler/os/mock/filesystem.go index 125fe9fe8f7..e3041e74628 100644 --- a/agent/acs/update_handler/os/mock/filesystem.go +++ b/agent/acs/update_handler/os/mock/filesystem.go @@ -11,172 +11,146 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/acs/update_handler/os (interfaces: FileSystem) -// Package mock_os is a generated GoMock package. package mock_os import ( io "io" os "os" - reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// MockFileSystem is a mock of FileSystem interface +// Mock of FileSystem interface type MockFileSystem struct { ctrl *gomock.Controller - recorder *MockFileSystemMockRecorder + recorder *_MockFileSystemRecorder } -// MockFileSystemMockRecorder is the mock recorder for MockFileSystem -type MockFileSystemMockRecorder struct { +// Recorder for MockFileSystem (not exported) +type _MockFileSystemRecorder struct { mock *MockFileSystem } -// NewMockFileSystem creates a new mock instance func NewMockFileSystem(ctrl *gomock.Controller) *MockFileSystem { mock := &MockFileSystem{ctrl: ctrl} - mock.recorder = &MockFileSystemMockRecorder{mock} + mock.recorder = &_MockFileSystemRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockFileSystem) EXPECT() *MockFileSystemMockRecorder { - return m.recorder +func (_m *MockFileSystem) EXPECT() *_MockFileSystemRecorder { + return _m.recorder } -// Copy mocks base method -func (m *MockFileSystem) Copy(arg0 io.Writer, arg1 io.Reader) (int64, error) { - ret := m.ctrl.Call(m, "Copy", arg0, arg1) +func (_m *MockFileSystem) Copy(_param0 io.Writer, _param1 io.Reader) (int64, error) { + ret := _m.ctrl.Call(_m, "Copy", _param0, _param1) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) return ret0, ret1 } -// Copy indicates an expected call of Copy -func (mr *MockFileSystemMockRecorder) Copy(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockFileSystem)(nil).Copy), arg0, arg1) +func (_mr *_MockFileSystemRecorder) Copy(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Copy", arg0, arg1) } -// Create mocks base method -func (m *MockFileSystem) Create(arg0 string) (io.ReadWriteCloser, error) { - ret := m.ctrl.Call(m, "Create", arg0) +func (_m *MockFileSystem) Create(_param0 string) (io.ReadWriteCloser, error) { + ret := _m.ctrl.Call(_m, "Create", _param0) ret0, _ := ret[0].(io.ReadWriteCloser) ret1, _ := ret[1].(error) return ret0, ret1 } -// Create indicates an expected call of Create -func (mr *MockFileSystemMockRecorder) Create(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFileSystem)(nil).Create), arg0) +func (_mr *_MockFileSystemRecorder) Create(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0) } -// Exit mocks base method -func (m *MockFileSystem) Exit(arg0 int) { - m.ctrl.Call(m, "Exit", arg0) +func (_m *MockFileSystem) Exit(_param0 int) { + _m.ctrl.Call(_m, "Exit", _param0) } -// Exit indicates an expected call of Exit -func (mr *MockFileSystemMockRecorder) Exit(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exit", reflect.TypeOf((*MockFileSystem)(nil).Exit), arg0) +func (_mr *_MockFileSystemRecorder) Exit(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Exit", arg0) } -// MkdirAll mocks base method -func (m *MockFileSystem) MkdirAll(arg0 string, arg1 os.FileMode) error { - ret := m.ctrl.Call(m, "MkdirAll", arg0, arg1) +func (_m *MockFileSystem) MkdirAll(_param0 string, _param1 os.FileMode) error { + ret := _m.ctrl.Call(_m, "MkdirAll", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// MkdirAll indicates an expected call of MkdirAll -func (mr *MockFileSystemMockRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockFileSystem)(nil).MkdirAll), arg0, arg1) +func (_mr *_MockFileSystemRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "MkdirAll", arg0, arg1) } -// Open mocks base method -func (m *MockFileSystem) Open(arg0 string) (io.ReadWriteCloser, error) { - ret := m.ctrl.Call(m, "Open", arg0) +func (_m *MockFileSystem) Open(_param0 string) (io.ReadWriteCloser, error) { + ret := _m.ctrl.Call(_m, "Open", _param0) ret0, _ := ret[0].(io.ReadWriteCloser) ret1, _ := ret[1].(error) return ret0, ret1 } -// Open indicates an expected call of Open -func (mr *MockFileSystemMockRecorder) Open(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockFileSystem)(nil).Open), arg0) +func (_mr *_MockFileSystemRecorder) Open(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Open", arg0) } -// ReadAll mocks base method -func (m *MockFileSystem) ReadAll(arg0 io.Reader) ([]byte, error) { - ret := m.ctrl.Call(m, "ReadAll", arg0) +func (_m *MockFileSystem) ReadAll(_param0 io.Reader) ([]byte, error) { + ret := _m.ctrl.Call(_m, "ReadAll", _param0) ret0, _ := ret[0].([]byte) ret1, _ := ret[1].(error) return ret0, ret1 } -// ReadAll indicates an expected call of ReadAll -func (mr *MockFileSystemMockRecorder) ReadAll(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAll", reflect.TypeOf((*MockFileSystem)(nil).ReadAll), arg0) +func (_mr *_MockFileSystemRecorder) ReadAll(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadAll", arg0) } -// Remove mocks base method -func (m *MockFileSystem) Remove(arg0 string) { - m.ctrl.Call(m, "Remove", arg0) +func (_m *MockFileSystem) Remove(_param0 string) { + _m.ctrl.Call(_m, "Remove", _param0) } -// Remove indicates an expected call of Remove -func (mr *MockFileSystemMockRecorder) Remove(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockFileSystem)(nil).Remove), arg0) +func (_mr *_MockFileSystemRecorder) Remove(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Remove", arg0) } -// Rename mocks base method -func (m *MockFileSystem) Rename(arg0, arg1 string) error { - ret := m.ctrl.Call(m, "Rename", arg0, arg1) +func (_m *MockFileSystem) Rename(_param0 string, _param1 string) error { + ret := _m.ctrl.Call(_m, "Rename", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// Rename indicates an expected call of Rename -func (mr *MockFileSystemMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockFileSystem)(nil).Rename), arg0, arg1) +func (_mr *_MockFileSystemRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Rename", arg0, arg1) } -// TeeReader mocks base method -func (m *MockFileSystem) TeeReader(arg0 io.Reader, arg1 io.Writer) io.Reader { - ret := m.ctrl.Call(m, "TeeReader", arg0, arg1) +func (_m *MockFileSystem) TeeReader(_param0 io.Reader, _param1 io.Writer) io.Reader { + ret := _m.ctrl.Call(_m, "TeeReader", _param0, _param1) ret0, _ := ret[0].(io.Reader) return ret0 } -// TeeReader indicates an expected call of TeeReader -func (mr *MockFileSystemMockRecorder) TeeReader(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TeeReader", reflect.TypeOf((*MockFileSystem)(nil).TeeReader), arg0, arg1) +func (_mr *_MockFileSystemRecorder) TeeReader(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "TeeReader", arg0, arg1) } -// TempFile mocks base method -func (m *MockFileSystem) TempFile(arg0, arg1 string) (*os.File, error) { - ret := m.ctrl.Call(m, "TempFile", arg0, arg1) +func (_m *MockFileSystem) TempFile(_param0 string, _param1 string) (*os.File, error) { + ret := _m.ctrl.Call(_m, "TempFile", _param0, _param1) ret0, _ := ret[0].(*os.File) ret1, _ := ret[1].(error) return ret0, ret1 } -// TempFile indicates an expected call of TempFile -func (mr *MockFileSystemMockRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TempFile", reflect.TypeOf((*MockFileSystem)(nil).TempFile), arg0, arg1) +func (_mr *_MockFileSystemRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "TempFile", arg0, arg1) } -// WriteFile mocks base method -func (m *MockFileSystem) WriteFile(arg0 string, arg1 []byte, arg2 os.FileMode) error { - ret := m.ctrl.Call(m, "WriteFile", arg0, arg1, arg2) +func (_m *MockFileSystem) WriteFile(_param0 string, _param1 []byte, _param2 os.FileMode) error { + ret := _m.ctrl.Call(_m, "WriteFile", _param0, _param1, _param2) ret0, _ := ret[0].(error) return ret0 } -// WriteFile indicates an expected call of WriteFile -func (mr *MockFileSystemMockRecorder) WriteFile(arg0, arg1, arg2 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFile", reflect.TypeOf((*MockFileSystem)(nil).WriteFile), arg0, arg1, arg2) +func (_mr *_MockFileSystemRecorder) WriteFile(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFile", arg0, arg1, arg2) } diff --git a/agent/api/mocks/api_mocks.go b/agent/api/mocks/api_mocks.go index 71762acc89c..709ff7b9ccb 100644 --- a/agent/api/mocks/api_mocks.go +++ b/agent/api/mocks/api_mocks.go @@ -11,213 +11,184 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/api (interfaces: ECSSDK,ECSSubmitStateSDK,ECSClient) -// Package mock_api is a generated GoMock package. package mock_api import ( - reflect "reflect" - api "github.com/aws/amazon-ecs-agent/agent/api" ecs "github.com/aws/amazon-ecs-agent/agent/ecs_client/model/ecs" gomock "github.com/golang/mock/gomock" ) -// MockECSSDK is a mock of ECSSDK interface +// Mock of ECSSDK interface type MockECSSDK struct { ctrl *gomock.Controller - recorder *MockECSSDKMockRecorder + recorder *_MockECSSDKRecorder } -// MockECSSDKMockRecorder is the mock recorder for MockECSSDK -type MockECSSDKMockRecorder struct { +// Recorder for MockECSSDK (not exported) +type _MockECSSDKRecorder struct { mock *MockECSSDK } -// NewMockECSSDK creates a new mock instance func NewMockECSSDK(ctrl *gomock.Controller) *MockECSSDK { mock := &MockECSSDK{ctrl: ctrl} - mock.recorder = &MockECSSDKMockRecorder{mock} + mock.recorder = &_MockECSSDKRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockECSSDK) EXPECT() *MockECSSDKMockRecorder { - return m.recorder +func (_m *MockECSSDK) EXPECT() *_MockECSSDKRecorder { + return _m.recorder } -// CreateCluster mocks base method -func (m *MockECSSDK) CreateCluster(arg0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) { - ret := m.ctrl.Call(m, "CreateCluster", arg0) +func (_m *MockECSSDK) CreateCluster(_param0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) { + ret := _m.ctrl.Call(_m, "CreateCluster", _param0) ret0, _ := ret[0].(*ecs.CreateClusterOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateCluster indicates an expected call of CreateCluster -func (mr *MockECSSDKMockRecorder) CreateCluster(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockECSSDK)(nil).CreateCluster), arg0) +func (_mr *_MockECSSDKRecorder) CreateCluster(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateCluster", arg0) } -// DiscoverPollEndpoint mocks base method -func (m *MockECSSDK) DiscoverPollEndpoint(arg0 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error) { - ret := m.ctrl.Call(m, "DiscoverPollEndpoint", arg0) +func (_m *MockECSSDK) DiscoverPollEndpoint(_param0 *ecs.DiscoverPollEndpointInput) (*ecs.DiscoverPollEndpointOutput, error) { + ret := _m.ctrl.Call(_m, "DiscoverPollEndpoint", _param0) ret0, _ := ret[0].(*ecs.DiscoverPollEndpointOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DiscoverPollEndpoint indicates an expected call of DiscoverPollEndpoint -func (mr *MockECSSDKMockRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSSDK)(nil).DiscoverPollEndpoint), arg0) +func (_mr *_MockECSSDKRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoverPollEndpoint", arg0) } -// RegisterContainerInstance mocks base method -func (m *MockECSSDK) RegisterContainerInstance(arg0 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error) { - ret := m.ctrl.Call(m, "RegisterContainerInstance", arg0) +func (_m *MockECSSDK) RegisterContainerInstance(_param0 *ecs.RegisterContainerInstanceInput) (*ecs.RegisterContainerInstanceOutput, error) { + ret := _m.ctrl.Call(_m, "RegisterContainerInstance", _param0) ret0, _ := ret[0].(*ecs.RegisterContainerInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// RegisterContainerInstance indicates an expected call of RegisterContainerInstance -func (mr *MockECSSDKMockRecorder) RegisterContainerInstance(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstance", reflect.TypeOf((*MockECSSDK)(nil).RegisterContainerInstance), arg0) +func (_mr *_MockECSSDKRecorder) RegisterContainerInstance(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RegisterContainerInstance", arg0) } -// MockECSSubmitStateSDK is a mock of ECSSubmitStateSDK interface +// Mock of ECSSubmitStateSDK interface type MockECSSubmitStateSDK struct { ctrl *gomock.Controller - recorder *MockECSSubmitStateSDKMockRecorder + recorder *_MockECSSubmitStateSDKRecorder } -// MockECSSubmitStateSDKMockRecorder is the mock recorder for MockECSSubmitStateSDK -type MockECSSubmitStateSDKMockRecorder struct { +// Recorder for MockECSSubmitStateSDK (not exported) +type _MockECSSubmitStateSDKRecorder struct { mock *MockECSSubmitStateSDK } -// NewMockECSSubmitStateSDK creates a new mock instance func NewMockECSSubmitStateSDK(ctrl *gomock.Controller) *MockECSSubmitStateSDK { mock := &MockECSSubmitStateSDK{ctrl: ctrl} - mock.recorder = &MockECSSubmitStateSDKMockRecorder{mock} + mock.recorder = &_MockECSSubmitStateSDKRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockECSSubmitStateSDK) EXPECT() *MockECSSubmitStateSDKMockRecorder { - return m.recorder +func (_m *MockECSSubmitStateSDK) EXPECT() *_MockECSSubmitStateSDKRecorder { + return _m.recorder } -// SubmitContainerStateChange mocks base method -func (m *MockECSSubmitStateSDK) SubmitContainerStateChange(arg0 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error) { - ret := m.ctrl.Call(m, "SubmitContainerStateChange", arg0) +func (_m *MockECSSubmitStateSDK) SubmitContainerStateChange(_param0 *ecs.SubmitContainerStateChangeInput) (*ecs.SubmitContainerStateChangeOutput, error) { + ret := _m.ctrl.Call(_m, "SubmitContainerStateChange", _param0) ret0, _ := ret[0].(*ecs.SubmitContainerStateChangeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// SubmitContainerStateChange indicates an expected call of SubmitContainerStateChange -func (mr *MockECSSubmitStateSDKMockRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChange", reflect.TypeOf((*MockECSSubmitStateSDK)(nil).SubmitContainerStateChange), arg0) +func (_mr *_MockECSSubmitStateSDKRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitContainerStateChange", arg0) } -// SubmitTaskStateChange mocks base method -func (m *MockECSSubmitStateSDK) SubmitTaskStateChange(arg0 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error) { - ret := m.ctrl.Call(m, "SubmitTaskStateChange", arg0) +func (_m *MockECSSubmitStateSDK) SubmitTaskStateChange(_param0 *ecs.SubmitTaskStateChangeInput) (*ecs.SubmitTaskStateChangeOutput, error) { + ret := _m.ctrl.Call(_m, "SubmitTaskStateChange", _param0) ret0, _ := ret[0].(*ecs.SubmitTaskStateChangeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// SubmitTaskStateChange indicates an expected call of SubmitTaskStateChange -func (mr *MockECSSubmitStateSDKMockRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChange", reflect.TypeOf((*MockECSSubmitStateSDK)(nil).SubmitTaskStateChange), arg0) +func (_mr *_MockECSSubmitStateSDKRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitTaskStateChange", arg0) } -// MockECSClient is a mock of ECSClient interface +// Mock of ECSClient interface type MockECSClient struct { ctrl *gomock.Controller - recorder *MockECSClientMockRecorder + recorder *_MockECSClientRecorder } -// MockECSClientMockRecorder is the mock recorder for MockECSClient -type MockECSClientMockRecorder struct { +// Recorder for MockECSClient (not exported) +type _MockECSClientRecorder struct { mock *MockECSClient } -// NewMockECSClient creates a new mock instance func NewMockECSClient(ctrl *gomock.Controller) *MockECSClient { mock := &MockECSClient{ctrl: ctrl} - mock.recorder = &MockECSClientMockRecorder{mock} + mock.recorder = &_MockECSClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockECSClient) EXPECT() *MockECSClientMockRecorder { - return m.recorder +func (_m *MockECSClient) EXPECT() *_MockECSClientRecorder { + return _m.recorder } -// DiscoverPollEndpoint mocks base method -func (m *MockECSClient) DiscoverPollEndpoint(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "DiscoverPollEndpoint", arg0) +func (_m *MockECSClient) DiscoverPollEndpoint(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "DiscoverPollEndpoint", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// DiscoverPollEndpoint indicates an expected call of DiscoverPollEndpoint -func (mr *MockECSClientMockRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSClient)(nil).DiscoverPollEndpoint), arg0) +func (_mr *_MockECSClientRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoverPollEndpoint", arg0) } -// DiscoverTelemetryEndpoint mocks base method -func (m *MockECSClient) DiscoverTelemetryEndpoint(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "DiscoverTelemetryEndpoint", arg0) +func (_m *MockECSClient) DiscoverTelemetryEndpoint(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "DiscoverTelemetryEndpoint", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// DiscoverTelemetryEndpoint indicates an expected call of DiscoverTelemetryEndpoint -func (mr *MockECSClientMockRecorder) DiscoverTelemetryEndpoint(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverTelemetryEndpoint", reflect.TypeOf((*MockECSClient)(nil).DiscoverTelemetryEndpoint), arg0) +func (_mr *_MockECSClientRecorder) DiscoverTelemetryEndpoint(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoverTelemetryEndpoint", arg0) } -// RegisterContainerInstance mocks base method -func (m *MockECSClient) RegisterContainerInstance(arg0 string, arg1 []*ecs.Attribute) (string, error) { - ret := m.ctrl.Call(m, "RegisterContainerInstance", arg0, arg1) +func (_m *MockECSClient) RegisterContainerInstance(_param0 string, _param1 []*ecs.Attribute) (string, error) { + ret := _m.ctrl.Call(_m, "RegisterContainerInstance", _param0, _param1) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// RegisterContainerInstance indicates an expected call of RegisterContainerInstance -func (mr *MockECSClientMockRecorder) RegisterContainerInstance(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterContainerInstance", reflect.TypeOf((*MockECSClient)(nil).RegisterContainerInstance), arg0, arg1) +func (_mr *_MockECSClientRecorder) RegisterContainerInstance(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RegisterContainerInstance", arg0, arg1) } -// SubmitContainerStateChange mocks base method -func (m *MockECSClient) SubmitContainerStateChange(arg0 api.ContainerStateChange) error { - ret := m.ctrl.Call(m, "SubmitContainerStateChange", arg0) +func (_m *MockECSClient) SubmitContainerStateChange(_param0 api.ContainerStateChange) error { + ret := _m.ctrl.Call(_m, "SubmitContainerStateChange", _param0) ret0, _ := ret[0].(error) return ret0 } -// SubmitContainerStateChange indicates an expected call of SubmitContainerStateChange -func (mr *MockECSClientMockRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChange", reflect.TypeOf((*MockECSClient)(nil).SubmitContainerStateChange), arg0) +func (_mr *_MockECSClientRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitContainerStateChange", arg0) } -// SubmitTaskStateChange mocks base method -func (m *MockECSClient) SubmitTaskStateChange(arg0 api.TaskStateChange) error { - ret := m.ctrl.Call(m, "SubmitTaskStateChange", arg0) +func (_m *MockECSClient) SubmitTaskStateChange(_param0 api.TaskStateChange) error { + ret := _m.ctrl.Call(_m, "SubmitTaskStateChange", _param0) ret0, _ := ret[0].(error) return ret0 } -// SubmitTaskStateChange indicates an expected call of SubmitTaskStateChange -func (mr *MockECSClientMockRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitTaskStateChange", reflect.TypeOf((*MockECSClient)(nil).SubmitTaskStateChange), arg0) +func (_mr *_MockECSClientRecorder) SubmitTaskStateChange(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SubmitTaskStateChange", arg0) } diff --git a/agent/app/factory/mocks/factory_mocks.go b/agent/app/factory/mocks/factory_mocks.go index a89cad5e675..46e1b421d23 100644 --- a/agent/app/factory/mocks/factory_mocks.go +++ b/agent/app/factory/mocks/factory_mocks.go @@ -11,92 +11,81 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/app/factory (interfaces: StateManager,SaveableOption) -// Package mock_factory is a generated GoMock package. package mock_factory import ( - reflect "reflect" - config "github.com/aws/amazon-ecs-agent/agent/config" statemanager "github.com/aws/amazon-ecs-agent/agent/statemanager" gomock "github.com/golang/mock/gomock" ) -// MockStateManager is a mock of StateManager interface +// Mock of StateManager interface type MockStateManager struct { ctrl *gomock.Controller - recorder *MockStateManagerMockRecorder + recorder *_MockStateManagerRecorder } -// MockStateManagerMockRecorder is the mock recorder for MockStateManager -type MockStateManagerMockRecorder struct { +// Recorder for MockStateManager (not exported) +type _MockStateManagerRecorder struct { mock *MockStateManager } -// NewMockStateManager creates a new mock instance func NewMockStateManager(ctrl *gomock.Controller) *MockStateManager { mock := &MockStateManager{ctrl: ctrl} - mock.recorder = &MockStateManagerMockRecorder{mock} + mock.recorder = &_MockStateManagerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockStateManager) EXPECT() *MockStateManagerMockRecorder { - return m.recorder +func (_m *MockStateManager) EXPECT() *_MockStateManagerRecorder { + return _m.recorder } -// NewStateManager mocks base method -func (m *MockStateManager) NewStateManager(arg0 *config.Config, arg1 ...statemanager.Option) (statemanager.StateManager, error) { - varargs := []interface{}{arg0} - for _, a := range arg1 { - varargs = append(varargs, a) +func (_m *MockStateManager) NewStateManager(_param0 *config.Config, _param1 ...statemanager.Option) (statemanager.StateManager, error) { + _s := []interface{}{_param0} + for _, _x := range _param1 { + _s = append(_s, _x) } - ret := m.ctrl.Call(m, "NewStateManager", varargs...) + ret := _m.ctrl.Call(_m, "NewStateManager", _s...) ret0, _ := ret[0].(statemanager.StateManager) ret1, _ := ret[1].(error) return ret0, ret1 } -// NewStateManager indicates an expected call of NewStateManager -func (mr *MockStateManagerMockRecorder) NewStateManager(arg0 interface{}, arg1 ...interface{}) *gomock.Call { - varargs := append([]interface{}{arg0}, arg1...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStateManager", reflect.TypeOf((*MockStateManager)(nil).NewStateManager), varargs...) +func (_mr *_MockStateManagerRecorder) NewStateManager(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + _s := append([]interface{}{arg0}, arg1...) + return _mr.mock.ctrl.RecordCall(_mr.mock, "NewStateManager", _s...) } -// MockSaveableOption is a mock of SaveableOption interface +// Mock of SaveableOption interface type MockSaveableOption struct { ctrl *gomock.Controller - recorder *MockSaveableOptionMockRecorder + recorder *_MockSaveableOptionRecorder } -// MockSaveableOptionMockRecorder is the mock recorder for MockSaveableOption -type MockSaveableOptionMockRecorder struct { +// Recorder for MockSaveableOption (not exported) +type _MockSaveableOptionRecorder struct { mock *MockSaveableOption } -// NewMockSaveableOption creates a new mock instance func NewMockSaveableOption(ctrl *gomock.Controller) *MockSaveableOption { mock := &MockSaveableOption{ctrl: ctrl} - mock.recorder = &MockSaveableOptionMockRecorder{mock} + mock.recorder = &_MockSaveableOptionRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockSaveableOption) EXPECT() *MockSaveableOptionMockRecorder { - return m.recorder +func (_m *MockSaveableOption) EXPECT() *_MockSaveableOptionRecorder { + return _m.recorder } -// AddSaveable mocks base method -func (m *MockSaveableOption) AddSaveable(arg0 string, arg1 statemanager.Saveable) statemanager.Option { - ret := m.ctrl.Call(m, "AddSaveable", arg0, arg1) +func (_m *MockSaveableOption) AddSaveable(_param0 string, _param1 statemanager.Saveable) statemanager.Option { + ret := _m.ctrl.Call(_m, "AddSaveable", _param0, _param1) ret0, _ := ret[0].(statemanager.Option) return ret0 } -// AddSaveable indicates an expected call of AddSaveable -func (mr *MockSaveableOptionMockRecorder) AddSaveable(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSaveable", reflect.TypeOf((*MockSaveableOption)(nil).AddSaveable), arg0, arg1) +func (_mr *_MockSaveableOptionRecorder) AddSaveable(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddSaveable", arg0, arg1) } diff --git a/agent/app/mocks/credentials_mocks.go b/agent/app/mocks/credentials_mocks.go index b401e67dc30..ee2294343f7 100644 --- a/agent/app/mocks/credentials_mocks.go +++ b/agent/app/mocks/credentials_mocks.go @@ -11,63 +11,54 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/aws-sdk-go/aws/credentials (interfaces: Provider) -// Package mock_credentials is a generated GoMock package. package mock_credentials import ( - reflect "reflect" - credentials "github.com/aws/aws-sdk-go/aws/credentials" gomock "github.com/golang/mock/gomock" ) -// MockProvider is a mock of Provider interface +// Mock of Provider interface type MockProvider struct { ctrl *gomock.Controller - recorder *MockProviderMockRecorder + recorder *_MockProviderRecorder } -// MockProviderMockRecorder is the mock recorder for MockProvider -type MockProviderMockRecorder struct { +// Recorder for MockProvider (not exported) +type _MockProviderRecorder struct { mock *MockProvider } -// NewMockProvider creates a new mock instance func NewMockProvider(ctrl *gomock.Controller) *MockProvider { mock := &MockProvider{ctrl: ctrl} - mock.recorder = &MockProviderMockRecorder{mock} + mock.recorder = &_MockProviderRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockProvider) EXPECT() *MockProviderMockRecorder { - return m.recorder +func (_m *MockProvider) EXPECT() *_MockProviderRecorder { + return _m.recorder } -// IsExpired mocks base method -func (m *MockProvider) IsExpired() bool { - ret := m.ctrl.Call(m, "IsExpired") +func (_m *MockProvider) IsExpired() bool { + ret := _m.ctrl.Call(_m, "IsExpired") ret0, _ := ret[0].(bool) return ret0 } -// IsExpired indicates an expected call of IsExpired -func (mr *MockProviderMockRecorder) IsExpired() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExpired", reflect.TypeOf((*MockProvider)(nil).IsExpired)) +func (_mr *_MockProviderRecorder) IsExpired() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "IsExpired") } -// Retrieve mocks base method -func (m *MockProvider) Retrieve() (credentials.Value, error) { - ret := m.ctrl.Call(m, "Retrieve") +func (_m *MockProvider) Retrieve() (credentials.Value, error) { + ret := _m.ctrl.Call(_m, "Retrieve") ret0, _ := ret[0].(credentials.Value) ret1, _ := ret[1].(error) return ret0, ret1 } -// Retrieve indicates an expected call of Retrieve -func (mr *MockProviderMockRecorder) Retrieve() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retrieve", reflect.TypeOf((*MockProvider)(nil).Retrieve)) +func (_mr *_MockProviderRecorder) Retrieve() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Retrieve") } diff --git a/agent/app/oswrapper/mocks/oswrapper_mocks.go b/agent/app/oswrapper/mocks/oswrapper_mocks.go index bff4b6963a7..002e07710f1 100644 --- a/agent/app/oswrapper/mocks/oswrapper_mocks.go +++ b/agent/app/oswrapper/mocks/oswrapper_mocks.go @@ -11,49 +11,42 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/app/oswrapper (interfaces: OS) -// Package mock_oswrapper is a generated GoMock package. package mock_oswrapper import ( - reflect "reflect" - gomock "github.com/golang/mock/gomock" ) -// MockOS is a mock of OS interface +// Mock of OS interface type MockOS struct { ctrl *gomock.Controller - recorder *MockOSMockRecorder + recorder *_MockOSRecorder } -// MockOSMockRecorder is the mock recorder for MockOS -type MockOSMockRecorder struct { +// Recorder for MockOS (not exported) +type _MockOSRecorder struct { mock *MockOS } -// NewMockOS creates a new mock instance func NewMockOS(ctrl *gomock.Controller) *MockOS { mock := &MockOS{ctrl: ctrl} - mock.recorder = &MockOSMockRecorder{mock} + mock.recorder = &_MockOSRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockOS) EXPECT() *MockOSMockRecorder { - return m.recorder +func (_m *MockOS) EXPECT() *_MockOSRecorder { + return _m.recorder } -// Getpid mocks base method -func (m *MockOS) Getpid() int { - ret := m.ctrl.Call(m, "Getpid") +func (_m *MockOS) Getpid() int { + ret := _m.ctrl.Call(_m, "Getpid") ret0, _ := ret[0].(int) return ret0 } -// Getpid indicates an expected call of Getpid -func (mr *MockOSMockRecorder) Getpid() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getpid", reflect.TypeOf((*MockOS)(nil).Getpid)) +func (_mr *_MockOSRecorder) Getpid() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Getpid") } diff --git a/agent/async/mocks/async_mocks.go b/agent/async/mocks/async_mocks.go index 00067531d3a..157f1111dae 100644 --- a/agent/async/mocks/async_mocks.go +++ b/agent/async/mocks/async_mocks.go @@ -11,61 +11,52 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/async (interfaces: Cache) -// Package mock_async is a generated GoMock package. package mock_async import ( - reflect "reflect" - async "github.com/aws/amazon-ecs-agent/agent/async" gomock "github.com/golang/mock/gomock" ) -// MockCache is a mock of Cache interface +// Mock of Cache interface type MockCache struct { ctrl *gomock.Controller - recorder *MockCacheMockRecorder + recorder *_MockCacheRecorder } -// MockCacheMockRecorder is the mock recorder for MockCache -type MockCacheMockRecorder struct { +// Recorder for MockCache (not exported) +type _MockCacheRecorder struct { mock *MockCache } -// NewMockCache creates a new mock instance func NewMockCache(ctrl *gomock.Controller) *MockCache { mock := &MockCache{ctrl: ctrl} - mock.recorder = &MockCacheMockRecorder{mock} + mock.recorder = &_MockCacheRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockCache) EXPECT() *MockCacheMockRecorder { - return m.recorder +func (_m *MockCache) EXPECT() *_MockCacheRecorder { + return _m.recorder } -// Get mocks base method -func (m *MockCache) Get(arg0 string) (async.Value, bool) { - ret := m.ctrl.Call(m, "Get", arg0) +func (_m *MockCache) Get(_param0 string) (async.Value, bool) { + ret := _m.ctrl.Call(_m, "Get", _param0) ret0, _ := ret[0].(async.Value) ret1, _ := ret[1].(bool) return ret0, ret1 } -// Get indicates an expected call of Get -func (mr *MockCacheMockRecorder) Get(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCache)(nil).Get), arg0) +func (_mr *_MockCacheRecorder) Get(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0) } -// Set mocks base method -func (m *MockCache) Set(arg0 string, arg1 async.Value) { - m.ctrl.Call(m, "Set", arg0, arg1) +func (_m *MockCache) Set(_param0 string, _param1 async.Value) { + _m.ctrl.Call(_m, "Set", _param0, _param1) } -// Set indicates an expected call of Set -func (mr *MockCacheMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCache)(nil).Set), arg0, arg1) +func (_mr *_MockCacheRecorder) Set(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Set", arg0, arg1) } diff --git a/agent/containermetadata/mocks/containermetadata_mocks.go b/agent/containermetadata/mocks/containermetadata_mocks.go index 5dbbd804c6a..13816f41658 100644 --- a/agent/containermetadata/mocks/containermetadata_mocks.go +++ b/agent/containermetadata/mocks/containermetadata_mocks.go @@ -11,121 +11,105 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/containermetadata (interfaces: Manager,DockerMetadataClient) -// Package mock_containermetadata is a generated GoMock package. package mock_containermetadata import ( - reflect "reflect" time "time" go_dockerclient "github.com/fsouza/go-dockerclient" gomock "github.com/golang/mock/gomock" ) -// MockManager is a mock of Manager interface +// Mock of Manager interface type MockManager struct { ctrl *gomock.Controller - recorder *MockManagerMockRecorder + recorder *_MockManagerRecorder } -// MockManagerMockRecorder is the mock recorder for MockManager -type MockManagerMockRecorder struct { +// Recorder for MockManager (not exported) +type _MockManagerRecorder struct { mock *MockManager } -// NewMockManager creates a new mock instance func NewMockManager(ctrl *gomock.Controller) *MockManager { mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} + mock.recorder = &_MockManagerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockManager) EXPECT() *MockManagerMockRecorder { - return m.recorder +func (_m *MockManager) EXPECT() *_MockManagerRecorder { + return _m.recorder } -// Clean mocks base method -func (m *MockManager) Clean(arg0 string) error { - ret := m.ctrl.Call(m, "Clean", arg0) +func (_m *MockManager) Clean(_param0 string) error { + ret := _m.ctrl.Call(_m, "Clean", _param0) ret0, _ := ret[0].(error) return ret0 } -// Clean indicates an expected call of Clean -func (mr *MockManagerMockRecorder) Clean(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clean", reflect.TypeOf((*MockManager)(nil).Clean), arg0) +func (_mr *_MockManagerRecorder) Clean(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Clean", arg0) } -// Create mocks base method -func (m *MockManager) Create(arg0 *go_dockerclient.Config, arg1 *go_dockerclient.HostConfig, arg2, arg3 string) error { - ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3) +func (_m *MockManager) Create(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 string) error { + ret := _m.ctrl.Call(_m, "Create", _param0, _param1, _param2, _param3) ret0, _ := ret[0].(error) return ret0 } -// Create indicates an expected call of Create -func (mr *MockManagerMockRecorder) Create(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockManager)(nil).Create), arg0, arg1, arg2, arg3) +func (_mr *_MockManagerRecorder) Create(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2, arg3) } -// SetContainerInstanceARN mocks base method -func (m *MockManager) SetContainerInstanceARN(arg0 string) { - m.ctrl.Call(m, "SetContainerInstanceARN", arg0) +func (_m *MockManager) SetContainerInstanceARN(_param0 string) { + _m.ctrl.Call(_m, "SetContainerInstanceARN", _param0) } -// SetContainerInstanceARN indicates an expected call of SetContainerInstanceARN -func (mr *MockManagerMockRecorder) SetContainerInstanceARN(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerInstanceARN", reflect.TypeOf((*MockManager)(nil).SetContainerInstanceARN), arg0) +func (_mr *_MockManagerRecorder) SetContainerInstanceARN(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetContainerInstanceARN", arg0) } -// Update mocks base method -func (m *MockManager) Update(arg0, arg1, arg2 string) error { - ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2) +func (_m *MockManager) Update(_param0 string, _param1 string, _param2 string) error { + ret := _m.ctrl.Call(_m, "Update", _param0, _param1, _param2) ret0, _ := ret[0].(error) return ret0 } -// Update indicates an expected call of Update -func (mr *MockManagerMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockManager)(nil).Update), arg0, arg1, arg2) +func (_mr *_MockManagerRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2) } -// MockDockerMetadataClient is a mock of DockerMetadataClient interface +// Mock of DockerMetadataClient interface type MockDockerMetadataClient struct { ctrl *gomock.Controller - recorder *MockDockerMetadataClientMockRecorder + recorder *_MockDockerMetadataClientRecorder } -// MockDockerMetadataClientMockRecorder is the mock recorder for MockDockerMetadataClient -type MockDockerMetadataClientMockRecorder struct { +// Recorder for MockDockerMetadataClient (not exported) +type _MockDockerMetadataClientRecorder struct { mock *MockDockerMetadataClient } -// NewMockDockerMetadataClient creates a new mock instance func NewMockDockerMetadataClient(ctrl *gomock.Controller) *MockDockerMetadataClient { mock := &MockDockerMetadataClient{ctrl: ctrl} - mock.recorder = &MockDockerMetadataClientMockRecorder{mock} + mock.recorder = &_MockDockerMetadataClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockDockerMetadataClient) EXPECT() *MockDockerMetadataClientMockRecorder { - return m.recorder +func (_m *MockDockerMetadataClient) EXPECT() *_MockDockerMetadataClientRecorder { + return _m.recorder } -// InspectContainer mocks base method -func (m *MockDockerMetadataClient) InspectContainer(arg0 string, arg1 time.Duration) (*go_dockerclient.Container, error) { - ret := m.ctrl.Call(m, "InspectContainer", arg0, arg1) +func (_m *MockDockerMetadataClient) InspectContainer(_param0 string, _param1 time.Duration) (*go_dockerclient.Container, error) { + ret := _m.ctrl.Call(_m, "InspectContainer", _param0, _param1) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -// InspectContainer indicates an expected call of InspectContainer -func (mr *MockDockerMetadataClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockDockerMetadataClient)(nil).InspectContainer), arg0, arg1) +func (_mr *_MockDockerMetadataClientRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) } diff --git a/agent/credentials/mocks/credentials_mocks.go b/agent/credentials/mocks/credentials_mocks.go index ba7096a24b6..dd34c181783 100644 --- a/agent/credentials/mocks/credentials_mocks.go +++ b/agent/credentials/mocks/credentials_mocks.go @@ -11,73 +11,62 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/credentials (interfaces: Manager) -// Package mock_credentials is a generated GoMock package. package mock_credentials import ( - reflect "reflect" - credentials "github.com/aws/amazon-ecs-agent/agent/credentials" gomock "github.com/golang/mock/gomock" ) -// MockManager is a mock of Manager interface +// Mock of Manager interface type MockManager struct { ctrl *gomock.Controller - recorder *MockManagerMockRecorder + recorder *_MockManagerRecorder } -// MockManagerMockRecorder is the mock recorder for MockManager -type MockManagerMockRecorder struct { +// Recorder for MockManager (not exported) +type _MockManagerRecorder struct { mock *MockManager } -// NewMockManager creates a new mock instance func NewMockManager(ctrl *gomock.Controller) *MockManager { mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} + mock.recorder = &_MockManagerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockManager) EXPECT() *MockManagerMockRecorder { - return m.recorder +func (_m *MockManager) EXPECT() *_MockManagerRecorder { + return _m.recorder } -// GetTaskCredentials mocks base method -func (m *MockManager) GetTaskCredentials(arg0 string) (credentials.TaskIAMRoleCredentials, bool) { - ret := m.ctrl.Call(m, "GetTaskCredentials", arg0) +func (_m *MockManager) GetTaskCredentials(_param0 string) (credentials.TaskIAMRoleCredentials, bool) { + ret := _m.ctrl.Call(_m, "GetTaskCredentials", _param0) ret0, _ := ret[0].(credentials.TaskIAMRoleCredentials) ret1, _ := ret[1].(bool) return ret0, ret1 } -// GetTaskCredentials indicates an expected call of GetTaskCredentials -func (mr *MockManagerMockRecorder) GetTaskCredentials(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskCredentials", reflect.TypeOf((*MockManager)(nil).GetTaskCredentials), arg0) +func (_mr *_MockManagerRecorder) GetTaskCredentials(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTaskCredentials", arg0) } -// RemoveCredentials mocks base method -func (m *MockManager) RemoveCredentials(arg0 string) { - m.ctrl.Call(m, "RemoveCredentials", arg0) +func (_m *MockManager) RemoveCredentials(_param0 string) { + _m.ctrl.Call(_m, "RemoveCredentials", _param0) } -// RemoveCredentials indicates an expected call of RemoveCredentials -func (mr *MockManagerMockRecorder) RemoveCredentials(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCredentials", reflect.TypeOf((*MockManager)(nil).RemoveCredentials), arg0) +func (_mr *_MockManagerRecorder) RemoveCredentials(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveCredentials", arg0) } -// SetTaskCredentials mocks base method -func (m *MockManager) SetTaskCredentials(arg0 credentials.TaskIAMRoleCredentials) error { - ret := m.ctrl.Call(m, "SetTaskCredentials", arg0) +func (_m *MockManager) SetTaskCredentials(_param0 credentials.TaskIAMRoleCredentials) error { + ret := _m.ctrl.Call(_m, "SetTaskCredentials", _param0) ret0, _ := ret[0].(error) return ret0 } -// SetTaskCredentials indicates an expected call of SetTaskCredentials -func (mr *MockManagerMockRecorder) SetTaskCredentials(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTaskCredentials", reflect.TypeOf((*MockManager)(nil).SetTaskCredentials), arg0) +func (_mr *_MockManagerRecorder) SetTaskCredentials(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetTaskCredentials", arg0) } diff --git a/agent/ec2/http/mocks/http_mocks.go b/agent/ec2/http/mocks/http_mocks.go index abf1394e497..6f7fe7b1642 100644 --- a/agent/ec2/http/mocks/http_mocks.go +++ b/agent/ec2/http/mocks/http_mocks.go @@ -11,51 +11,45 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/ec2/http (interfaces: Client) -// Package mock_http is a generated GoMock package. package mock_http import ( http "net/http" - reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// MockClient is a mock of Client interface +// Mock of Client interface type MockClient struct { ctrl *gomock.Controller - recorder *MockClientMockRecorder + recorder *_MockClientRecorder } -// MockClientMockRecorder is the mock recorder for MockClient -type MockClientMockRecorder struct { +// Recorder for MockClient (not exported) +type _MockClientRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} - mock.recorder = &MockClientMockRecorder{mock} + mock.recorder = &_MockClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockClient) EXPECT() *MockClientMockRecorder { - return m.recorder +func (_m *MockClient) EXPECT() *_MockClientRecorder { + return _m.recorder } -// Get mocks base method -func (m *MockClient) Get(arg0 string) (*http.Response, error) { - ret := m.ctrl.Call(m, "Get", arg0) +func (_m *MockClient) Get(_param0 string) (*http.Response, error) { + ret := _m.ctrl.Call(_m, "Get", _param0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } -// Get indicates an expected call of Get -func (mr *MockClientMockRecorder) Get(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0) +func (_mr *_MockClientRecorder) Get(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0) } diff --git a/agent/ec2/mocks/ec2_mocks.go b/agent/ec2/mocks/ec2_mocks.go index 38bdead4836..b7e2c42c02a 100644 --- a/agent/ec2/mocks/ec2_mocks.go +++ b/agent/ec2/mocks/ec2_mocks.go @@ -11,192 +11,165 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/ec2 (interfaces: EC2MetadataClient,HttpClient) -// Package mock_ec2 is a generated GoMock package. package mock_ec2 import ( - reflect "reflect" - ec2 "github.com/aws/amazon-ecs-agent/agent/ec2" ec2metadata "github.com/aws/aws-sdk-go/aws/ec2metadata" gomock "github.com/golang/mock/gomock" ) -// MockEC2MetadataClient is a mock of EC2MetadataClient interface +// Mock of EC2MetadataClient interface type MockEC2MetadataClient struct { ctrl *gomock.Controller - recorder *MockEC2MetadataClientMockRecorder + recorder *_MockEC2MetadataClientRecorder } -// MockEC2MetadataClientMockRecorder is the mock recorder for MockEC2MetadataClient -type MockEC2MetadataClientMockRecorder struct { +// Recorder for MockEC2MetadataClient (not exported) +type _MockEC2MetadataClientRecorder struct { mock *MockEC2MetadataClient } -// NewMockEC2MetadataClient creates a new mock instance func NewMockEC2MetadataClient(ctrl *gomock.Controller) *MockEC2MetadataClient { mock := &MockEC2MetadataClient{ctrl: ctrl} - mock.recorder = &MockEC2MetadataClientMockRecorder{mock} + mock.recorder = &_MockEC2MetadataClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockEC2MetadataClient) EXPECT() *MockEC2MetadataClientMockRecorder { - return m.recorder +func (_m *MockEC2MetadataClient) EXPECT() *_MockEC2MetadataClientRecorder { + return _m.recorder } -// DefaultCredentials mocks base method -func (m *MockEC2MetadataClient) DefaultCredentials() (*ec2.RoleCredentials, error) { - ret := m.ctrl.Call(m, "DefaultCredentials") +func (_m *MockEC2MetadataClient) DefaultCredentials() (*ec2.RoleCredentials, error) { + ret := _m.ctrl.Call(_m, "DefaultCredentials") ret0, _ := ret[0].(*ec2.RoleCredentials) ret1, _ := ret[1].(error) return ret0, ret1 } -// DefaultCredentials indicates an expected call of DefaultCredentials -func (mr *MockEC2MetadataClientMockRecorder) DefaultCredentials() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultCredentials", reflect.TypeOf((*MockEC2MetadataClient)(nil).DefaultCredentials)) +func (_mr *_MockEC2MetadataClientRecorder) DefaultCredentials() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "DefaultCredentials") } -// GetDynamicData mocks base method -func (m *MockEC2MetadataClient) GetDynamicData(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "GetDynamicData", arg0) +func (_m *MockEC2MetadataClient) GetDynamicData(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "GetDynamicData", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetDynamicData indicates an expected call of GetDynamicData -func (mr *MockEC2MetadataClientMockRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicData", reflect.TypeOf((*MockEC2MetadataClient)(nil).GetDynamicData), arg0) +func (_mr *_MockEC2MetadataClientRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDynamicData", arg0) } -// GetMetadata mocks base method -func (m *MockEC2MetadataClient) GetMetadata(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "GetMetadata", arg0) +func (_m *MockEC2MetadataClient) GetMetadata(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "GetMetadata", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetMetadata indicates an expected call of GetMetadata -func (mr *MockEC2MetadataClientMockRecorder) GetMetadata(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockEC2MetadataClient)(nil).GetMetadata), arg0) +func (_mr *_MockEC2MetadataClientRecorder) GetMetadata(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetMetadata", arg0) } -// InstanceIdentityDocument mocks base method -func (m *MockEC2MetadataClient) InstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { - ret := m.ctrl.Call(m, "InstanceIdentityDocument") +func (_m *MockEC2MetadataClient) InstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { + ret := _m.ctrl.Call(_m, "InstanceIdentityDocument") ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument) ret1, _ := ret[1].(error) return ret0, ret1 } -// InstanceIdentityDocument indicates an expected call of InstanceIdentityDocument -func (mr *MockEC2MetadataClientMockRecorder) InstanceIdentityDocument() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIdentityDocument", reflect.TypeOf((*MockEC2MetadataClient)(nil).InstanceIdentityDocument)) +func (_mr *_MockEC2MetadataClientRecorder) InstanceIdentityDocument() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InstanceIdentityDocument") } -// PrimaryENIMAC mocks base method -func (m *MockEC2MetadataClient) PrimaryENIMAC() (string, error) { - ret := m.ctrl.Call(m, "PrimaryENIMAC") +func (_m *MockEC2MetadataClient) PrimaryENIMAC() (string, error) { + ret := _m.ctrl.Call(_m, "PrimaryENIMAC") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// PrimaryENIMAC indicates an expected call of PrimaryENIMAC -func (mr *MockEC2MetadataClientMockRecorder) PrimaryENIMAC() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryENIMAC", reflect.TypeOf((*MockEC2MetadataClient)(nil).PrimaryENIMAC)) +func (_mr *_MockEC2MetadataClientRecorder) PrimaryENIMAC() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "PrimaryENIMAC") } -// SubnetID mocks base method -func (m *MockEC2MetadataClient) SubnetID(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "SubnetID", arg0) +func (_m *MockEC2MetadataClient) SubnetID(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "SubnetID", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// SubnetID indicates an expected call of SubnetID -func (mr *MockEC2MetadataClientMockRecorder) SubnetID(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubnetID", reflect.TypeOf((*MockEC2MetadataClient)(nil).SubnetID), arg0) +func (_mr *_MockEC2MetadataClientRecorder) SubnetID(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SubnetID", arg0) } -// VPCID mocks base method -func (m *MockEC2MetadataClient) VPCID(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "VPCID", arg0) +func (_m *MockEC2MetadataClient) VPCID(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "VPCID", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// VPCID indicates an expected call of VPCID -func (mr *MockEC2MetadataClientMockRecorder) VPCID(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VPCID", reflect.TypeOf((*MockEC2MetadataClient)(nil).VPCID), arg0) +func (_mr *_MockEC2MetadataClientRecorder) VPCID(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "VPCID", arg0) } -// MockHttpClient is a mock of HttpClient interface +// Mock of HttpClient interface type MockHttpClient struct { ctrl *gomock.Controller - recorder *MockHttpClientMockRecorder + recorder *_MockHttpClientRecorder } -// MockHttpClientMockRecorder is the mock recorder for MockHttpClient -type MockHttpClientMockRecorder struct { +// Recorder for MockHttpClient (not exported) +type _MockHttpClientRecorder struct { mock *MockHttpClient } -// NewMockHttpClient creates a new mock instance func NewMockHttpClient(ctrl *gomock.Controller) *MockHttpClient { mock := &MockHttpClient{ctrl: ctrl} - mock.recorder = &MockHttpClientMockRecorder{mock} + mock.recorder = &_MockHttpClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockHttpClient) EXPECT() *MockHttpClientMockRecorder { - return m.recorder +func (_m *MockHttpClient) EXPECT() *_MockHttpClientRecorder { + return _m.recorder } -// GetDynamicData mocks base method -func (m *MockHttpClient) GetDynamicData(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "GetDynamicData", arg0) +func (_m *MockHttpClient) GetDynamicData(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "GetDynamicData", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetDynamicData indicates an expected call of GetDynamicData -func (mr *MockHttpClientMockRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicData", reflect.TypeOf((*MockHttpClient)(nil).GetDynamicData), arg0) +func (_mr *_MockHttpClientRecorder) GetDynamicData(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDynamicData", arg0) } -// GetInstanceIdentityDocument mocks base method -func (m *MockHttpClient) GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { - ret := m.ctrl.Call(m, "GetInstanceIdentityDocument") +func (_m *MockHttpClient) GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { + ret := _m.ctrl.Call(_m, "GetInstanceIdentityDocument") ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetInstanceIdentityDocument indicates an expected call of GetInstanceIdentityDocument -func (mr *MockHttpClientMockRecorder) GetInstanceIdentityDocument() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceIdentityDocument", reflect.TypeOf((*MockHttpClient)(nil).GetInstanceIdentityDocument)) +func (_mr *_MockHttpClientRecorder) GetInstanceIdentityDocument() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetInstanceIdentityDocument") } -// GetMetadata mocks base method -func (m *MockHttpClient) GetMetadata(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "GetMetadata", arg0) +func (_m *MockHttpClient) GetMetadata(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "GetMetadata", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetMetadata indicates an expected call of GetMetadata -func (mr *MockHttpClientMockRecorder) GetMetadata(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockHttpClient)(nil).GetMetadata), arg0) +func (_mr *_MockHttpClientRecorder) GetMetadata(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetMetadata", arg0) } diff --git a/agent/ecr/mocks/ecr_mocks.go b/agent/ecr/mocks/ecr_mocks.go index 3b70637ec00..a79a9c55788 100644 --- a/agent/ecr/mocks/ecr_mocks.go +++ b/agent/ecr/mocks/ecr_mocks.go @@ -11,135 +11,118 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/ecr (interfaces: ECRSDK,ECRFactory,ECRClient) -// Package mock_ecr is a generated GoMock package. package mock_ecr import ( - reflect "reflect" - - ecr "github.com/aws/amazon-ecs-agent/agent/ecr" - ecr0 "github.com/aws/amazon-ecs-agent/agent/ecr/model/ecr" + ecr0 "github.com/aws/amazon-ecs-agent/agent/ecr" + ecr "github.com/aws/amazon-ecs-agent/agent/ecr/model/ecr" gomock "github.com/golang/mock/gomock" ) -// MockECRSDK is a mock of ECRSDK interface +// Mock of ECRSDK interface type MockECRSDK struct { ctrl *gomock.Controller - recorder *MockECRSDKMockRecorder + recorder *_MockECRSDKRecorder } -// MockECRSDKMockRecorder is the mock recorder for MockECRSDK -type MockECRSDKMockRecorder struct { +// Recorder for MockECRSDK (not exported) +type _MockECRSDKRecorder struct { mock *MockECRSDK } -// NewMockECRSDK creates a new mock instance func NewMockECRSDK(ctrl *gomock.Controller) *MockECRSDK { mock := &MockECRSDK{ctrl: ctrl} - mock.recorder = &MockECRSDKMockRecorder{mock} + mock.recorder = &_MockECRSDKRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockECRSDK) EXPECT() *MockECRSDKMockRecorder { - return m.recorder +func (_m *MockECRSDK) EXPECT() *_MockECRSDKRecorder { + return _m.recorder } -// GetAuthorizationToken mocks base method -func (m *MockECRSDK) GetAuthorizationToken(arg0 *ecr0.GetAuthorizationTokenInput) (*ecr0.GetAuthorizationTokenOutput, error) { - ret := m.ctrl.Call(m, "GetAuthorizationToken", arg0) - ret0, _ := ret[0].(*ecr0.GetAuthorizationTokenOutput) +func (_m *MockECRSDK) GetAuthorizationToken(_param0 *ecr.GetAuthorizationTokenInput) (*ecr.GetAuthorizationTokenOutput, error) { + ret := _m.ctrl.Call(_m, "GetAuthorizationToken", _param0) + ret0, _ := ret[0].(*ecr.GetAuthorizationTokenOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetAuthorizationToken indicates an expected call of GetAuthorizationToken -func (mr *MockECRSDKMockRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizationToken", reflect.TypeOf((*MockECRSDK)(nil).GetAuthorizationToken), arg0) +func (_mr *_MockECRSDKRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAuthorizationToken", arg0) } -// MockECRFactory is a mock of ECRFactory interface +// Mock of ECRFactory interface type MockECRFactory struct { ctrl *gomock.Controller - recorder *MockECRFactoryMockRecorder + recorder *_MockECRFactoryRecorder } -// MockECRFactoryMockRecorder is the mock recorder for MockECRFactory -type MockECRFactoryMockRecorder struct { +// Recorder for MockECRFactory (not exported) +type _MockECRFactoryRecorder struct { mock *MockECRFactory } -// NewMockECRFactory creates a new mock instance func NewMockECRFactory(ctrl *gomock.Controller) *MockECRFactory { mock := &MockECRFactory{ctrl: ctrl} - mock.recorder = &MockECRFactoryMockRecorder{mock} + mock.recorder = &_MockECRFactoryRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockECRFactory) EXPECT() *MockECRFactoryMockRecorder { - return m.recorder +func (_m *MockECRFactory) EXPECT() *_MockECRFactoryRecorder { + return _m.recorder } -// GetClient mocks base method -func (m *MockECRFactory) GetClient(arg0, arg1 string) ecr.ECRClient { - ret := m.ctrl.Call(m, "GetClient", arg0, arg1) - ret0, _ := ret[0].(ecr.ECRClient) +func (_m *MockECRFactory) GetClient(_param0 string, _param1 string) ecr0.ECRClient { + ret := _m.ctrl.Call(_m, "GetClient", _param0, _param1) + ret0, _ := ret[0].(ecr0.ECRClient) return ret0 } -// GetClient indicates an expected call of GetClient -func (mr *MockECRFactoryMockRecorder) GetClient(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockECRFactory)(nil).GetClient), arg0, arg1) +func (_mr *_MockECRFactoryRecorder) GetClient(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetClient", arg0, arg1) } -// MockECRClient is a mock of ECRClient interface +// Mock of ECRClient interface type MockECRClient struct { ctrl *gomock.Controller - recorder *MockECRClientMockRecorder + recorder *_MockECRClientRecorder } -// MockECRClientMockRecorder is the mock recorder for MockECRClient -type MockECRClientMockRecorder struct { +// Recorder for MockECRClient (not exported) +type _MockECRClientRecorder struct { mock *MockECRClient } -// NewMockECRClient creates a new mock instance func NewMockECRClient(ctrl *gomock.Controller) *MockECRClient { mock := &MockECRClient{ctrl: ctrl} - mock.recorder = &MockECRClientMockRecorder{mock} + mock.recorder = &_MockECRClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockECRClient) EXPECT() *MockECRClientMockRecorder { - return m.recorder +func (_m *MockECRClient) EXPECT() *_MockECRClientRecorder { + return _m.recorder } -// GetAuthorizationToken mocks base method -func (m *MockECRClient) GetAuthorizationToken(arg0 string) (*ecr0.AuthorizationData, error) { - ret := m.ctrl.Call(m, "GetAuthorizationToken", arg0) - ret0, _ := ret[0].(*ecr0.AuthorizationData) +func (_m *MockECRClient) GetAuthorizationToken(_param0 string) (*ecr.AuthorizationData, error) { + ret := _m.ctrl.Call(_m, "GetAuthorizationToken", _param0) + ret0, _ := ret[0].(*ecr.AuthorizationData) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetAuthorizationToken indicates an expected call of GetAuthorizationToken -func (mr *MockECRClientMockRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizationToken", reflect.TypeOf((*MockECRClient)(nil).GetAuthorizationToken), arg0) +func (_mr *_MockECRClientRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAuthorizationToken", arg0) } -// IsTokenValid mocks base method -func (m *MockECRClient) IsTokenValid(arg0 *ecr0.AuthorizationData) bool { - ret := m.ctrl.Call(m, "IsTokenValid", arg0) +func (_m *MockECRClient) IsTokenValid(_param0 *ecr.AuthorizationData) bool { + ret := _m.ctrl.Call(_m, "IsTokenValid", _param0) ret0, _ := ret[0].(bool) return ret0 } -// IsTokenValid indicates an expected call of IsTokenValid -func (mr *MockECRClientMockRecorder) IsTokenValid(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTokenValid", reflect.TypeOf((*MockECRClient)(nil).IsTokenValid), arg0) +func (_mr *_MockECRClientRecorder) IsTokenValid(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "IsTokenValid", arg0) } diff --git a/agent/ecs_client/model/ecs/service.go b/agent/ecs_client/model/ecs/service.go index 53c626c906a..7854db53086 100644 --- a/agent/ecs_client/model/ecs/service.go +++ b/agent/ecs_client/model/ecs/service.go @@ -24,11 +24,10 @@ import ( // Amazon EC2 Container Service (Amazon ECS) is a highly scalable, fast, container // management service that makes it easy to run, stop, and manage Docker containers -// on a cluster of Amazon EC2 instances. Amazon ECS lets you launch and stop -// container-enabled applications with simple API calls, allows you to get the -// state of your cluster from a centralized service, and gives you access to -// many familiar Amazon EC2 features like security groups, Amazon EBS volumes, -// and IAM roles. +// on a cluster of EC2 instances. Amazon ECS lets you launch and stop container-enabled +// applications with simple API calls, allows you to get the state of your cluster +// from a centralized service, and gives you access to many familiar Amazon +// EC2 features like security groups, Amazon EBS volumes, and IAM roles. // // You can use Amazon ECS to schedule the placement of containers across your // cluster based on your resource needs, isolation policies, and availability @@ -70,9 +69,6 @@ func New(p client.ConfigProvider, cfgs ...*aws.Config) *ECS { // newClient creates, initializes and returns a new service client instance. func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *ECS { - if len(signingName) == 0 { - signingName = "ecs" - } svc := &ECS{ Client: client.New( cfg, diff --git a/agent/ecscni/mocks/ecscni_mocks.go b/agent/ecscni/mocks/ecscni_mocks.go index 4b3c32a5df7..3d39e70f98c 100644 --- a/agent/ecscni/mocks/ecscni_mocks.go +++ b/agent/ecscni/mocks/ecscni_mocks.go @@ -11,100 +11,85 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/ecscni (interfaces: CNIClient) -// Package mock_ecscni is a generated GoMock package. package mock_ecscni import ( - reflect "reflect" - ecscni "github.com/aws/amazon-ecs-agent/agent/ecscni" gomock "github.com/golang/mock/gomock" ) -// MockCNIClient is a mock of CNIClient interface +// Mock of CNIClient interface type MockCNIClient struct { ctrl *gomock.Controller - recorder *MockCNIClientMockRecorder + recorder *_MockCNIClientRecorder } -// MockCNIClientMockRecorder is the mock recorder for MockCNIClient -type MockCNIClientMockRecorder struct { +// Recorder for MockCNIClient (not exported) +type _MockCNIClientRecorder struct { mock *MockCNIClient } -// NewMockCNIClient creates a new mock instance func NewMockCNIClient(ctrl *gomock.Controller) *MockCNIClient { mock := &MockCNIClient{ctrl: ctrl} - mock.recorder = &MockCNIClientMockRecorder{mock} + mock.recorder = &_MockCNIClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockCNIClient) EXPECT() *MockCNIClientMockRecorder { - return m.recorder +func (_m *MockCNIClient) EXPECT() *_MockCNIClientRecorder { + return _m.recorder } -// Capabilities mocks base method -func (m *MockCNIClient) Capabilities(arg0 string) ([]string, error) { - ret := m.ctrl.Call(m, "Capabilities", arg0) +func (_m *MockCNIClient) Capabilities(_param0 string) ([]string, error) { + ret := _m.ctrl.Call(_m, "Capabilities", _param0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } -// Capabilities indicates an expected call of Capabilities -func (mr *MockCNIClientMockRecorder) Capabilities(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Capabilities", reflect.TypeOf((*MockCNIClient)(nil).Capabilities), arg0) +func (_mr *_MockCNIClientRecorder) Capabilities(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Capabilities", arg0) } -// CleanupNS mocks base method -func (m *MockCNIClient) CleanupNS(arg0 *ecscni.Config) error { - ret := m.ctrl.Call(m, "CleanupNS", arg0) +func (_m *MockCNIClient) CleanupNS(_param0 *ecscni.Config) error { + ret := _m.ctrl.Call(_m, "CleanupNS", _param0) ret0, _ := ret[0].(error) return ret0 } -// CleanupNS indicates an expected call of CleanupNS -func (mr *MockCNIClientMockRecorder) CleanupNS(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanupNS", reflect.TypeOf((*MockCNIClient)(nil).CleanupNS), arg0) +func (_mr *_MockCNIClientRecorder) CleanupNS(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "CleanupNS", arg0) } -// ReleaseIPResource mocks base method -func (m *MockCNIClient) ReleaseIPResource(arg0 *ecscni.Config) error { - ret := m.ctrl.Call(m, "ReleaseIPResource", arg0) +func (_m *MockCNIClient) ReleaseIPResource(_param0 *ecscni.Config) error { + ret := _m.ctrl.Call(_m, "ReleaseIPResource", _param0) ret0, _ := ret[0].(error) return ret0 } -// ReleaseIPResource indicates an expected call of ReleaseIPResource -func (mr *MockCNIClientMockRecorder) ReleaseIPResource(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIPResource", reflect.TypeOf((*MockCNIClient)(nil).ReleaseIPResource), arg0) +func (_mr *_MockCNIClientRecorder) ReleaseIPResource(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ReleaseIPResource", arg0) } -// SetupNS mocks base method -func (m *MockCNIClient) SetupNS(arg0 *ecscni.Config) error { - ret := m.ctrl.Call(m, "SetupNS", arg0) +func (_m *MockCNIClient) SetupNS(_param0 *ecscni.Config) error { + ret := _m.ctrl.Call(_m, "SetupNS", _param0) ret0, _ := ret[0].(error) return ret0 } -// SetupNS indicates an expected call of SetupNS -func (mr *MockCNIClientMockRecorder) SetupNS(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupNS", reflect.TypeOf((*MockCNIClient)(nil).SetupNS), arg0) +func (_mr *_MockCNIClientRecorder) SetupNS(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetupNS", arg0) } -// Version mocks base method -func (m *MockCNIClient) Version(arg0 string) (string, error) { - ret := m.ctrl.Call(m, "Version", arg0) +func (_m *MockCNIClient) Version(_param0 string) (string, error) { + ret := _m.ctrl.Call(_m, "Version", _param0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// Version indicates an expected call of Version -func (mr *MockCNIClientMockRecorder) Version(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockCNIClient)(nil).Version), arg0) +func (_mr *_MockCNIClientRecorder) Version(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Version", arg0) } diff --git a/agent/ecscni/mocks_cnitypes/result_mocks.go b/agent/ecscni/mocks_cnitypes/result_mocks.go index 6b008168c0b..c0dffa7bd99 100644 --- a/agent/ecscni/mocks_cnitypes/result_mocks.go +++ b/agent/ecscni/mocks_cnitypes/result_mocks.go @@ -11,87 +11,74 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/containernetworking/cni/pkg/types (interfaces: Result) -// Package mock_types is a generated GoMock package. package mock_types import ( - reflect "reflect" - types "github.com/containernetworking/cni/pkg/types" gomock "github.com/golang/mock/gomock" ) -// MockResult is a mock of Result interface +// Mock of Result interface type MockResult struct { ctrl *gomock.Controller - recorder *MockResultMockRecorder + recorder *_MockResultRecorder } -// MockResultMockRecorder is the mock recorder for MockResult -type MockResultMockRecorder struct { +// Recorder for MockResult (not exported) +type _MockResultRecorder struct { mock *MockResult } -// NewMockResult creates a new mock instance func NewMockResult(ctrl *gomock.Controller) *MockResult { mock := &MockResult{ctrl: ctrl} - mock.recorder = &MockResultMockRecorder{mock} + mock.recorder = &_MockResultRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockResult) EXPECT() *MockResultMockRecorder { - return m.recorder +func (_m *MockResult) EXPECT() *_MockResultRecorder { + return _m.recorder } -// GetAsVersion mocks base method -func (m *MockResult) GetAsVersion(arg0 string) (types.Result, error) { - ret := m.ctrl.Call(m, "GetAsVersion", arg0) +func (_m *MockResult) GetAsVersion(_param0 string) (types.Result, error) { + ret := _m.ctrl.Call(_m, "GetAsVersion", _param0) ret0, _ := ret[0].(types.Result) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetAsVersion indicates an expected call of GetAsVersion -func (mr *MockResultMockRecorder) GetAsVersion(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAsVersion", reflect.TypeOf((*MockResult)(nil).GetAsVersion), arg0) +func (_mr *_MockResultRecorder) GetAsVersion(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAsVersion", arg0) } -// Print mocks base method -func (m *MockResult) Print() error { - ret := m.ctrl.Call(m, "Print") +func (_m *MockResult) Print() error { + ret := _m.ctrl.Call(_m, "Print") ret0, _ := ret[0].(error) return ret0 } -// Print indicates an expected call of Print -func (mr *MockResultMockRecorder) Print() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Print", reflect.TypeOf((*MockResult)(nil).Print)) +func (_mr *_MockResultRecorder) Print() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Print") } -// String mocks base method -func (m *MockResult) String() string { - ret := m.ctrl.Call(m, "String") +func (_m *MockResult) String() string { + ret := _m.ctrl.Call(_m, "String") ret0, _ := ret[0].(string) return ret0 } -// String indicates an expected call of String -func (mr *MockResultMockRecorder) String() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockResult)(nil).String)) +func (_mr *_MockResultRecorder) String() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "String") } -// Version mocks base method -func (m *MockResult) Version() string { - ret := m.ctrl.Call(m, "Version") +func (_m *MockResult) Version() string { + ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(string) return ret0 } -// Version indicates an expected call of Version -func (mr *MockResultMockRecorder) Version() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockResult)(nil).Version)) +func (_mr *_MockResultRecorder) Version() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } diff --git a/agent/ecscni/mocks_libcni/libcni_mocks.go b/agent/ecscni/mocks_libcni/libcni_mocks.go index d9f15e9592d..f4190d4bf00 100644 --- a/agent/ecscni/mocks_libcni/libcni_mocks.go +++ b/agent/ecscni/mocks_libcni/libcni_mocks.go @@ -11,89 +11,76 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/containernetworking/cni/libcni (interfaces: CNI) -// Package mock_libcni is a generated GoMock package. package mock_libcni import ( - reflect "reflect" - libcni "github.com/containernetworking/cni/libcni" types "github.com/containernetworking/cni/pkg/types" gomock "github.com/golang/mock/gomock" ) -// MockCNI is a mock of CNI interface +// Mock of CNI interface type MockCNI struct { ctrl *gomock.Controller - recorder *MockCNIMockRecorder + recorder *_MockCNIRecorder } -// MockCNIMockRecorder is the mock recorder for MockCNI -type MockCNIMockRecorder struct { +// Recorder for MockCNI (not exported) +type _MockCNIRecorder struct { mock *MockCNI } -// NewMockCNI creates a new mock instance func NewMockCNI(ctrl *gomock.Controller) *MockCNI { mock := &MockCNI{ctrl: ctrl} - mock.recorder = &MockCNIMockRecorder{mock} + mock.recorder = &_MockCNIRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockCNI) EXPECT() *MockCNIMockRecorder { - return m.recorder +func (_m *MockCNI) EXPECT() *_MockCNIRecorder { + return _m.recorder } -// AddNetwork mocks base method -func (m *MockCNI) AddNetwork(arg0 *libcni.NetworkConfig, arg1 *libcni.RuntimeConf) (types.Result, error) { - ret := m.ctrl.Call(m, "AddNetwork", arg0, arg1) +func (_m *MockCNI) AddNetwork(_param0 *libcni.NetworkConfig, _param1 *libcni.RuntimeConf) (types.Result, error) { + ret := _m.ctrl.Call(_m, "AddNetwork", _param0, _param1) ret0, _ := ret[0].(types.Result) ret1, _ := ret[1].(error) return ret0, ret1 } -// AddNetwork indicates an expected call of AddNetwork -func (mr *MockCNIMockRecorder) AddNetwork(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetwork", reflect.TypeOf((*MockCNI)(nil).AddNetwork), arg0, arg1) +func (_mr *_MockCNIRecorder) AddNetwork(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddNetwork", arg0, arg1) } -// AddNetworkList mocks base method -func (m *MockCNI) AddNetworkList(arg0 *libcni.NetworkConfigList, arg1 *libcni.RuntimeConf) (types.Result, error) { - ret := m.ctrl.Call(m, "AddNetworkList", arg0, arg1) +func (_m *MockCNI) AddNetworkList(_param0 *libcni.NetworkConfigList, _param1 *libcni.RuntimeConf) (types.Result, error) { + ret := _m.ctrl.Call(_m, "AddNetworkList", _param0, _param1) ret0, _ := ret[0].(types.Result) ret1, _ := ret[1].(error) return ret0, ret1 } -// AddNetworkList indicates an expected call of AddNetworkList -func (mr *MockCNIMockRecorder) AddNetworkList(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetworkList", reflect.TypeOf((*MockCNI)(nil).AddNetworkList), arg0, arg1) +func (_mr *_MockCNIRecorder) AddNetworkList(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddNetworkList", arg0, arg1) } -// DelNetwork mocks base method -func (m *MockCNI) DelNetwork(arg0 *libcni.NetworkConfig, arg1 *libcni.RuntimeConf) error { - ret := m.ctrl.Call(m, "DelNetwork", arg0, arg1) +func (_m *MockCNI) DelNetwork(_param0 *libcni.NetworkConfig, _param1 *libcni.RuntimeConf) error { + ret := _m.ctrl.Call(_m, "DelNetwork", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// DelNetwork indicates an expected call of DelNetwork -func (mr *MockCNIMockRecorder) DelNetwork(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelNetwork", reflect.TypeOf((*MockCNI)(nil).DelNetwork), arg0, arg1) +func (_mr *_MockCNIRecorder) DelNetwork(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNetwork", arg0, arg1) } -// DelNetworkList mocks base method -func (m *MockCNI) DelNetworkList(arg0 *libcni.NetworkConfigList, arg1 *libcni.RuntimeConf) error { - ret := m.ctrl.Call(m, "DelNetworkList", arg0, arg1) +func (_m *MockCNI) DelNetworkList(_param0 *libcni.NetworkConfigList, _param1 *libcni.RuntimeConf) error { + ret := _m.ctrl.Call(_m, "DelNetworkList", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// DelNetworkList indicates an expected call of DelNetworkList -func (mr *MockCNIMockRecorder) DelNetworkList(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelNetworkList", reflect.TypeOf((*MockCNI)(nil).DelNetworkList), arg0, arg1) +func (_mr *_MockCNIRecorder) DelNetworkList(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNetworkList", arg0, arg1) } diff --git a/agent/engine/docker_task_engine_test.go b/agent/engine/docker_task_engine_test.go index 1450577af00..7fcf34d7ae2 100644 --- a/agent/engine/docker_task_engine_test.go +++ b/agent/engine/docker_task_engine_test.go @@ -1863,7 +1863,7 @@ func TestCreateContainerOnAgentRestart(t *testing.T) { } func TestPullCNIImage(t *testing.T) { - ctrl, _, _, privateTaskEngine, _, _ := mocks(t, &config.Config{}) + ctrl, _, _, privateTaskEngine, _, _, _ := mocks(t, &config.Config{}) defer ctrl.Finish() taskEngine, _ := privateTaskEngine.(*DockerTaskEngine) @@ -1878,7 +1878,7 @@ func TestPullCNIImage(t *testing.T) { } func TestPullNormalImage(t *testing.T) { - ctrl, client, _, privateTaskEngine, _, imageManager := mocks(t, &config.Config{}) + ctrl, client, _, privateTaskEngine, _, imageManager, _ := mocks(t, &config.Config{}) defer ctrl.Finish() taskEngine, _ := privateTaskEngine.(*DockerTaskEngine) saver := mock_statemanager.NewMockStateManager(ctrl) diff --git a/agent/engine/docker_task_engine_unix_test.go b/agent/engine/docker_task_engine_unix_test.go index 1e3d5ed5043..02c16d7bcfa 100644 --- a/agent/engine/docker_task_engine_unix_test.go +++ b/agent/engine/docker_task_engine_unix_test.go @@ -26,7 +26,7 @@ import ( ) func TestPullEmptyVolumeImage(t *testing.T) { - ctrl, client, _, privateTaskEngine, _, _ := mocks(t, &config.Config{}) + ctrl, client, _, privateTaskEngine, _, _, _ := mocks(t, &config.Config{}) defer ctrl.Finish() taskEngine, _ := privateTaskEngine.(*DockerTaskEngine) saver := mock_statemanager.NewMockStateManager(ctrl) diff --git a/agent/engine/dockerclient/mocks/dockerclient_mocks.go b/agent/engine/dockerclient/mocks/dockerclient_mocks.go index 6b0e422465a..475e1b99b4d 100644 --- a/agent/engine/dockerclient/mocks/dockerclient_mocks.go +++ b/agent/engine/dockerclient/mocks/dockerclient_mocks.go @@ -11,89 +11,76 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/engine/dockerclient (interfaces: Factory) -// Package mock_dockerclient is a generated GoMock package. package mock_dockerclient import ( - reflect "reflect" - dockerclient "github.com/aws/amazon-ecs-agent/agent/engine/dockerclient" dockeriface "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface" gomock "github.com/golang/mock/gomock" ) -// MockFactory is a mock of Factory interface +// Mock of Factory interface type MockFactory struct { ctrl *gomock.Controller - recorder *MockFactoryMockRecorder + recorder *_MockFactoryRecorder } -// MockFactoryMockRecorder is the mock recorder for MockFactory -type MockFactoryMockRecorder struct { +// Recorder for MockFactory (not exported) +type _MockFactoryRecorder struct { mock *MockFactory } -// NewMockFactory creates a new mock instance func NewMockFactory(ctrl *gomock.Controller) *MockFactory { mock := &MockFactory{ctrl: ctrl} - mock.recorder = &MockFactoryMockRecorder{mock} + mock.recorder = &_MockFactoryRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockFactory) EXPECT() *MockFactoryMockRecorder { - return m.recorder +func (_m *MockFactory) EXPECT() *_MockFactoryRecorder { + return _m.recorder } -// FindKnownAPIVersions mocks base method -func (m *MockFactory) FindKnownAPIVersions() []dockerclient.DockerVersion { - ret := m.ctrl.Call(m, "FindKnownAPIVersions") +func (_m *MockFactory) FindKnownAPIVersions() []dockerclient.DockerVersion { + ret := _m.ctrl.Call(_m, "FindKnownAPIVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -// FindKnownAPIVersions indicates an expected call of FindKnownAPIVersions -func (mr *MockFactoryMockRecorder) FindKnownAPIVersions() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindKnownAPIVersions", reflect.TypeOf((*MockFactory)(nil).FindKnownAPIVersions)) +func (_mr *_MockFactoryRecorder) FindKnownAPIVersions() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "FindKnownAPIVersions") } -// FindSupportedAPIVersions mocks base method -func (m *MockFactory) FindSupportedAPIVersions() []dockerclient.DockerVersion { - ret := m.ctrl.Call(m, "FindSupportedAPIVersions") +func (_m *MockFactory) FindSupportedAPIVersions() []dockerclient.DockerVersion { + ret := _m.ctrl.Call(_m, "FindSupportedAPIVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -// FindSupportedAPIVersions indicates an expected call of FindSupportedAPIVersions -func (mr *MockFactoryMockRecorder) FindSupportedAPIVersions() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindSupportedAPIVersions", reflect.TypeOf((*MockFactory)(nil).FindSupportedAPIVersions)) +func (_mr *_MockFactoryRecorder) FindSupportedAPIVersions() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "FindSupportedAPIVersions") } -// GetClient mocks base method -func (m *MockFactory) GetClient(arg0 dockerclient.DockerVersion) (dockeriface.Client, error) { - ret := m.ctrl.Call(m, "GetClient", arg0) +func (_m *MockFactory) GetClient(_param0 dockerclient.DockerVersion) (dockeriface.Client, error) { + ret := _m.ctrl.Call(_m, "GetClient", _param0) ret0, _ := ret[0].(dockeriface.Client) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetClient indicates an expected call of GetClient -func (mr *MockFactoryMockRecorder) GetClient(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockFactory)(nil).GetClient), arg0) +func (_mr *_MockFactoryRecorder) GetClient(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetClient", arg0) } -// GetDefaultClient mocks base method -func (m *MockFactory) GetDefaultClient() (dockeriface.Client, error) { - ret := m.ctrl.Call(m, "GetDefaultClient") +func (_m *MockFactory) GetDefaultClient() (dockeriface.Client, error) { + ret := _m.ctrl.Call(_m, "GetDefaultClient") ret0, _ := ret[0].(dockeriface.Client) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetDefaultClient indicates an expected call of GetDefaultClient -func (mr *MockFactoryMockRecorder) GetDefaultClient() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultClient", reflect.TypeOf((*MockFactory)(nil).GetDefaultClient)) +func (_mr *_MockFactoryRecorder) GetDefaultClient() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultClient") } diff --git a/agent/engine/dockeriface/mocks/dockeriface_mocks.go b/agent/engine/dockeriface/mocks/dockeriface_mocks.go index d36dfd0e7d6..f22f4122f9f 100644 --- a/agent/engine/dockeriface/mocks/dockeriface_mocks.go +++ b/agent/engine/dockeriface/mocks/dockeriface_mocks.go @@ -11,273 +11,230 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/engine/dockeriface (interfaces: Client) -// Package mock_dockeriface is a generated GoMock package. package mock_dockeriface import ( - reflect "reflect" - go_dockerclient "github.com/fsouza/go-dockerclient" gomock "github.com/golang/mock/gomock" context "golang.org/x/net/context" ) -// MockClient is a mock of Client interface +// Mock of Client interface type MockClient struct { ctrl *gomock.Controller - recorder *MockClientMockRecorder + recorder *_MockClientRecorder } -// MockClientMockRecorder is the mock recorder for MockClient -type MockClientMockRecorder struct { +// Recorder for MockClient (not exported) +type _MockClientRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} - mock.recorder = &MockClientMockRecorder{mock} + mock.recorder = &_MockClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockClient) EXPECT() *MockClientMockRecorder { - return m.recorder +func (_m *MockClient) EXPECT() *_MockClientRecorder { + return _m.recorder } -// AddEventListener mocks base method -func (m *MockClient) AddEventListener(arg0 chan<- *go_dockerclient.APIEvents) error { - ret := m.ctrl.Call(m, "AddEventListener", arg0) +func (_m *MockClient) AddEventListener(_param0 chan<- *go_dockerclient.APIEvents) error { + ret := _m.ctrl.Call(_m, "AddEventListener", _param0) ret0, _ := ret[0].(error) return ret0 } -// AddEventListener indicates an expected call of AddEventListener -func (mr *MockClientMockRecorder) AddEventListener(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventListener", reflect.TypeOf((*MockClient)(nil).AddEventListener), arg0) +func (_mr *_MockClientRecorder) AddEventListener(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddEventListener", arg0) } -// CreateContainer mocks base method -func (m *MockClient) CreateContainer(arg0 go_dockerclient.CreateContainerOptions) (*go_dockerclient.Container, error) { - ret := m.ctrl.Call(m, "CreateContainer", arg0) +func (_m *MockClient) CreateContainer(_param0 go_dockerclient.CreateContainerOptions) (*go_dockerclient.Container, error) { + ret := _m.ctrl.Call(_m, "CreateContainer", _param0) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateContainer indicates an expected call of CreateContainer -func (mr *MockClientMockRecorder) CreateContainer(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockClient)(nil).CreateContainer), arg0) +func (_mr *_MockClientRecorder) CreateContainer(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateContainer", arg0) } -// ImportImage mocks base method -func (m *MockClient) ImportImage(arg0 go_dockerclient.ImportImageOptions) error { - ret := m.ctrl.Call(m, "ImportImage", arg0) +func (_m *MockClient) ImportImage(_param0 go_dockerclient.ImportImageOptions) error { + ret := _m.ctrl.Call(_m, "ImportImage", _param0) ret0, _ := ret[0].(error) return ret0 } -// ImportImage indicates an expected call of ImportImage -func (mr *MockClientMockRecorder) ImportImage(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockClient)(nil).ImportImage), arg0) +func (_mr *_MockClientRecorder) ImportImage(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ImportImage", arg0) } -// InspectContainer mocks base method -func (m *MockClient) InspectContainer(arg0 string) (*go_dockerclient.Container, error) { - ret := m.ctrl.Call(m, "InspectContainer", arg0) +func (_m *MockClient) InspectContainer(_param0 string) (*go_dockerclient.Container, error) { + ret := _m.ctrl.Call(_m, "InspectContainer", _param0) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -// InspectContainer indicates an expected call of InspectContainer -func (mr *MockClientMockRecorder) InspectContainer(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockClient)(nil).InspectContainer), arg0) +func (_mr *_MockClientRecorder) InspectContainer(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0) } -// InspectContainerWithContext mocks base method -func (m *MockClient) InspectContainerWithContext(arg0 string, arg1 context.Context) (*go_dockerclient.Container, error) { - ret := m.ctrl.Call(m, "InspectContainerWithContext", arg0, arg1) +func (_m *MockClient) InspectContainerWithContext(_param0 string, _param1 context.Context) (*go_dockerclient.Container, error) { + ret := _m.ctrl.Call(_m, "InspectContainerWithContext", _param0, _param1) ret0, _ := ret[0].(*go_dockerclient.Container) ret1, _ := ret[1].(error) return ret0, ret1 } -// InspectContainerWithContext indicates an expected call of InspectContainerWithContext -func (mr *MockClientMockRecorder) InspectContainerWithContext(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainerWithContext", reflect.TypeOf((*MockClient)(nil).InspectContainerWithContext), arg0, arg1) +func (_mr *_MockClientRecorder) InspectContainerWithContext(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainerWithContext", arg0, arg1) } -// InspectImage mocks base method -func (m *MockClient) InspectImage(arg0 string) (*go_dockerclient.Image, error) { - ret := m.ctrl.Call(m, "InspectImage", arg0) +func (_m *MockClient) InspectImage(_param0 string) (*go_dockerclient.Image, error) { + ret := _m.ctrl.Call(_m, "InspectImage", _param0) ret0, _ := ret[0].(*go_dockerclient.Image) ret1, _ := ret[1].(error) return ret0, ret1 } -// InspectImage indicates an expected call of InspectImage -func (mr *MockClientMockRecorder) InspectImage(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImage", reflect.TypeOf((*MockClient)(nil).InspectImage), arg0) +func (_mr *_MockClientRecorder) InspectImage(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectImage", arg0) } -// ListContainers mocks base method -func (m *MockClient) ListContainers(arg0 go_dockerclient.ListContainersOptions) ([]go_dockerclient.APIContainers, error) { - ret := m.ctrl.Call(m, "ListContainers", arg0) +func (_m *MockClient) ListContainers(_param0 go_dockerclient.ListContainersOptions) ([]go_dockerclient.APIContainers, error) { + ret := _m.ctrl.Call(_m, "ListContainers", _param0) ret0, _ := ret[0].([]go_dockerclient.APIContainers) ret1, _ := ret[1].(error) return ret0, ret1 } -// ListContainers indicates an expected call of ListContainers -func (mr *MockClientMockRecorder) ListContainers(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockClient)(nil).ListContainers), arg0) +func (_mr *_MockClientRecorder) ListContainers(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ListContainers", arg0) } -// LoadImage mocks base method -func (m *MockClient) LoadImage(arg0 go_dockerclient.LoadImageOptions) error { - ret := m.ctrl.Call(m, "LoadImage", arg0) +func (_m *MockClient) LoadImage(_param0 go_dockerclient.LoadImageOptions) error { + ret := _m.ctrl.Call(_m, "LoadImage", _param0) ret0, _ := ret[0].(error) return ret0 } -// LoadImage indicates an expected call of LoadImage -func (mr *MockClientMockRecorder) LoadImage(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadImage", reflect.TypeOf((*MockClient)(nil).LoadImage), arg0) +func (_mr *_MockClientRecorder) LoadImage(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0) } -// Ping mocks base method -func (m *MockClient) Ping() error { - ret := m.ctrl.Call(m, "Ping") +func (_m *MockClient) Ping() error { + ret := _m.ctrl.Call(_m, "Ping") ret0, _ := ret[0].(error) return ret0 } -// Ping indicates an expected call of Ping -func (mr *MockClientMockRecorder) Ping() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockClient)(nil).Ping)) +func (_mr *_MockClientRecorder) Ping() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Ping") } -// PullImage mocks base method -func (m *MockClient) PullImage(arg0 go_dockerclient.PullImageOptions, arg1 go_dockerclient.AuthConfiguration) error { - ret := m.ctrl.Call(m, "PullImage", arg0, arg1) +func (_m *MockClient) PullImage(_param0 go_dockerclient.PullImageOptions, _param1 go_dockerclient.AuthConfiguration) error { + ret := _m.ctrl.Call(_m, "PullImage", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// PullImage indicates an expected call of PullImage -func (mr *MockClientMockRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockClient)(nil).PullImage), arg0, arg1) +func (_mr *_MockClientRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "PullImage", arg0, arg1) } -// RemoveContainer mocks base method -func (m *MockClient) RemoveContainer(arg0 go_dockerclient.RemoveContainerOptions) error { - ret := m.ctrl.Call(m, "RemoveContainer", arg0) +func (_m *MockClient) RemoveContainer(_param0 go_dockerclient.RemoveContainerOptions) error { + ret := _m.ctrl.Call(_m, "RemoveContainer", _param0) ret0, _ := ret[0].(error) return ret0 } -// RemoveContainer indicates an expected call of RemoveContainer -func (mr *MockClientMockRecorder) RemoveContainer(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockClient)(nil).RemoveContainer), arg0) +func (_mr *_MockClientRecorder) RemoveContainer(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainer", arg0) } -// RemoveEventListener mocks base method -func (m *MockClient) RemoveEventListener(arg0 chan *go_dockerclient.APIEvents) error { - ret := m.ctrl.Call(m, "RemoveEventListener", arg0) +func (_m *MockClient) RemoveEventListener(_param0 chan *go_dockerclient.APIEvents) error { + ret := _m.ctrl.Call(_m, "RemoveEventListener", _param0) ret0, _ := ret[0].(error) return ret0 } -// RemoveEventListener indicates an expected call of RemoveEventListener -func (mr *MockClientMockRecorder) RemoveEventListener(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveEventListener", reflect.TypeOf((*MockClient)(nil).RemoveEventListener), arg0) +func (_mr *_MockClientRecorder) RemoveEventListener(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveEventListener", arg0) } -// RemoveImage mocks base method -func (m *MockClient) RemoveImage(arg0 string) error { - ret := m.ctrl.Call(m, "RemoveImage", arg0) +func (_m *MockClient) RemoveImage(_param0 string) error { + ret := _m.ctrl.Call(_m, "RemoveImage", _param0) ret0, _ := ret[0].(error) return ret0 } -// RemoveImage indicates an expected call of RemoveImage -func (mr *MockClientMockRecorder) RemoveImage(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockClient)(nil).RemoveImage), arg0) +func (_mr *_MockClientRecorder) RemoveImage(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImage", arg0) } -// StartContainer mocks base method -func (m *MockClient) StartContainer(arg0 string, arg1 *go_dockerclient.HostConfig) error { - ret := m.ctrl.Call(m, "StartContainer", arg0, arg1) +func (_m *MockClient) StartContainer(_param0 string, _param1 *go_dockerclient.HostConfig) error { + ret := _m.ctrl.Call(_m, "StartContainer", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// StartContainer indicates an expected call of StartContainer -func (mr *MockClientMockRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockClient)(nil).StartContainer), arg0, arg1) +func (_mr *_MockClientRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainer", arg0, arg1) } -// StartContainerWithContext mocks base method -func (m *MockClient) StartContainerWithContext(arg0 string, arg1 *go_dockerclient.HostConfig, arg2 context.Context) error { - ret := m.ctrl.Call(m, "StartContainerWithContext", arg0, arg1, arg2) +func (_m *MockClient) StartContainerWithContext(_param0 string, _param1 *go_dockerclient.HostConfig, _param2 context.Context) error { + ret := _m.ctrl.Call(_m, "StartContainerWithContext", _param0, _param1, _param2) ret0, _ := ret[0].(error) return ret0 } -// StartContainerWithContext indicates an expected call of StartContainerWithContext -func (mr *MockClientMockRecorder) StartContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainerWithContext", reflect.TypeOf((*MockClient)(nil).StartContainerWithContext), arg0, arg1, arg2) +func (_mr *_MockClientRecorder) StartContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainerWithContext", arg0, arg1, arg2) } -// Stats mocks base method -func (m *MockClient) Stats(arg0 go_dockerclient.StatsOptions) error { - ret := m.ctrl.Call(m, "Stats", arg0) +func (_m *MockClient) Stats(_param0 go_dockerclient.StatsOptions) error { + ret := _m.ctrl.Call(_m, "Stats", _param0) ret0, _ := ret[0].(error) return ret0 } -// Stats indicates an expected call of Stats -func (mr *MockClientMockRecorder) Stats(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockClient)(nil).Stats), arg0) +func (_mr *_MockClientRecorder) Stats(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Stats", arg0) } -// StopContainer mocks base method -func (m *MockClient) StopContainer(arg0 string, arg1 uint) error { - ret := m.ctrl.Call(m, "StopContainer", arg0, arg1) +func (_m *MockClient) StopContainer(_param0 string, _param1 uint) error { + ret := _m.ctrl.Call(_m, "StopContainer", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// StopContainer indicates an expected call of StopContainer -func (mr *MockClientMockRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockClient)(nil).StopContainer), arg0, arg1) +func (_mr *_MockClientRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainer", arg0, arg1) } -// StopContainerWithContext mocks base method -func (m *MockClient) StopContainerWithContext(arg0 string, arg1 uint, arg2 context.Context) error { - ret := m.ctrl.Call(m, "StopContainerWithContext", arg0, arg1, arg2) +func (_m *MockClient) StopContainerWithContext(_param0 string, _param1 uint, _param2 context.Context) error { + ret := _m.ctrl.Call(_m, "StopContainerWithContext", _param0, _param1, _param2) ret0, _ := ret[0].(error) return ret0 } -// StopContainerWithContext indicates an expected call of StopContainerWithContext -func (mr *MockClientMockRecorder) StopContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainerWithContext", reflect.TypeOf((*MockClient)(nil).StopContainerWithContext), arg0, arg1, arg2) +func (_mr *_MockClientRecorder) StopContainerWithContext(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainerWithContext", arg0, arg1, arg2) } -// Version mocks base method -func (m *MockClient) Version() (*go_dockerclient.Env, error) { - ret := m.ctrl.Call(m, "Version") +func (_m *MockClient) Version() (*go_dockerclient.Env, error) { + ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(*go_dockerclient.Env) ret1, _ := ret[1].(error) return ret0, ret1 } -// Version indicates an expected call of Version -func (mr *MockClientMockRecorder) Version() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockClient)(nil).Version)) +func (_mr *_MockClientRecorder) Version() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } diff --git a/agent/engine/dockerstate/mocks/dockerstate_mocks.go b/agent/engine/dockerstate/mocks/dockerstate_mocks.go index a21cb86954b..aa8fb1daccd 100644 --- a/agent/engine/dockerstate/mocks/dockerstate_mocks.go +++ b/agent/engine/dockerstate/mocks/dockerstate_mocks.go @@ -11,258 +11,215 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/engine/dockerstate (interfaces: TaskEngineState) -// Package mock_dockerstate is a generated GoMock package. package mock_dockerstate import ( - reflect "reflect" - api "github.com/aws/amazon-ecs-agent/agent/api" image "github.com/aws/amazon-ecs-agent/agent/engine/image" gomock "github.com/golang/mock/gomock" ) -// MockTaskEngineState is a mock of TaskEngineState interface +// Mock of TaskEngineState interface type MockTaskEngineState struct { ctrl *gomock.Controller - recorder *MockTaskEngineStateMockRecorder + recorder *_MockTaskEngineStateRecorder } -// MockTaskEngineStateMockRecorder is the mock recorder for MockTaskEngineState -type MockTaskEngineStateMockRecorder struct { +// Recorder for MockTaskEngineState (not exported) +type _MockTaskEngineStateRecorder struct { mock *MockTaskEngineState } -// NewMockTaskEngineState creates a new mock instance func NewMockTaskEngineState(ctrl *gomock.Controller) *MockTaskEngineState { mock := &MockTaskEngineState{ctrl: ctrl} - mock.recorder = &MockTaskEngineStateMockRecorder{mock} + mock.recorder = &_MockTaskEngineStateRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTaskEngineState) EXPECT() *MockTaskEngineStateMockRecorder { - return m.recorder +func (_m *MockTaskEngineState) EXPECT() *_MockTaskEngineStateRecorder { + return _m.recorder } -// AddContainer mocks base method -func (m *MockTaskEngineState) AddContainer(arg0 *api.DockerContainer, arg1 *api.Task) { - m.ctrl.Call(m, "AddContainer", arg0, arg1) +func (_m *MockTaskEngineState) AddContainer(_param0 *api.DockerContainer, _param1 *api.Task) { + _m.ctrl.Call(_m, "AddContainer", _param0, _param1) } -// AddContainer indicates an expected call of AddContainer -func (mr *MockTaskEngineStateMockRecorder) AddContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContainer", reflect.TypeOf((*MockTaskEngineState)(nil).AddContainer), arg0, arg1) +func (_mr *_MockTaskEngineStateRecorder) AddContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddContainer", arg0, arg1) } -// AddENIAttachment mocks base method -func (m *MockTaskEngineState) AddENIAttachment(arg0 *api.ENIAttachment) { - m.ctrl.Call(m, "AddENIAttachment", arg0) +func (_m *MockTaskEngineState) AddENIAttachment(_param0 *api.ENIAttachment) { + _m.ctrl.Call(_m, "AddENIAttachment", _param0) } -// AddENIAttachment indicates an expected call of AddENIAttachment -func (mr *MockTaskEngineStateMockRecorder) AddENIAttachment(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddENIAttachment", reflect.TypeOf((*MockTaskEngineState)(nil).AddENIAttachment), arg0) +func (_mr *_MockTaskEngineStateRecorder) AddENIAttachment(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddENIAttachment", arg0) } -// AddImageState mocks base method -func (m *MockTaskEngineState) AddImageState(arg0 *image.ImageState) { - m.ctrl.Call(m, "AddImageState", arg0) +func (_m *MockTaskEngineState) AddImageState(_param0 *image.ImageState) { + _m.ctrl.Call(_m, "AddImageState", _param0) } -// AddImageState indicates an expected call of AddImageState -func (mr *MockTaskEngineStateMockRecorder) AddImageState(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddImageState", reflect.TypeOf((*MockTaskEngineState)(nil).AddImageState), arg0) +func (_mr *_MockTaskEngineStateRecorder) AddImageState(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddImageState", arg0) } -// AddTask mocks base method -func (m *MockTaskEngineState) AddTask(arg0 *api.Task) { - m.ctrl.Call(m, "AddTask", arg0) +func (_m *MockTaskEngineState) AddTask(_param0 *api.Task) { + _m.ctrl.Call(_m, "AddTask", _param0) } -// AddTask indicates an expected call of AddTask -func (mr *MockTaskEngineStateMockRecorder) AddTask(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTask", reflect.TypeOf((*MockTaskEngineState)(nil).AddTask), arg0) +func (_mr *_MockTaskEngineStateRecorder) AddTask(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTask", arg0) } -// AllImageStates mocks base method -func (m *MockTaskEngineState) AllImageStates() []*image.ImageState { - ret := m.ctrl.Call(m, "AllImageStates") +func (_m *MockTaskEngineState) AllImageStates() []*image.ImageState { + ret := _m.ctrl.Call(_m, "AllImageStates") ret0, _ := ret[0].([]*image.ImageState) return ret0 } -// AllImageStates indicates an expected call of AllImageStates -func (mr *MockTaskEngineStateMockRecorder) AllImageStates() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllImageStates", reflect.TypeOf((*MockTaskEngineState)(nil).AllImageStates)) +func (_mr *_MockTaskEngineStateRecorder) AllImageStates() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AllImageStates") } -// AllTasks mocks base method -func (m *MockTaskEngineState) AllTasks() []*api.Task { - ret := m.ctrl.Call(m, "AllTasks") +func (_m *MockTaskEngineState) AllTasks() []*api.Task { + ret := _m.ctrl.Call(_m, "AllTasks") ret0, _ := ret[0].([]*api.Task) return ret0 } -// AllTasks indicates an expected call of AllTasks -func (mr *MockTaskEngineStateMockRecorder) AllTasks() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllTasks", reflect.TypeOf((*MockTaskEngineState)(nil).AllTasks)) +func (_mr *_MockTaskEngineStateRecorder) AllTasks() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AllTasks") } -// ContainerByID mocks base method -func (m *MockTaskEngineState) ContainerByID(arg0 string) (*api.DockerContainer, bool) { - ret := m.ctrl.Call(m, "ContainerByID", arg0) +func (_m *MockTaskEngineState) ContainerByID(_param0 string) (*api.DockerContainer, bool) { + ret := _m.ctrl.Call(_m, "ContainerByID", _param0) ret0, _ := ret[0].(*api.DockerContainer) ret1, _ := ret[1].(bool) return ret0, ret1 } -// ContainerByID indicates an expected call of ContainerByID -func (mr *MockTaskEngineStateMockRecorder) ContainerByID(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerByID", reflect.TypeOf((*MockTaskEngineState)(nil).ContainerByID), arg0) +func (_mr *_MockTaskEngineStateRecorder) ContainerByID(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerByID", arg0) } -// ContainerMapByArn mocks base method -func (m *MockTaskEngineState) ContainerMapByArn(arg0 string) (map[string]*api.DockerContainer, bool) { - ret := m.ctrl.Call(m, "ContainerMapByArn", arg0) +func (_m *MockTaskEngineState) ContainerMapByArn(_param0 string) (map[string]*api.DockerContainer, bool) { + ret := _m.ctrl.Call(_m, "ContainerMapByArn", _param0) ret0, _ := ret[0].(map[string]*api.DockerContainer) ret1, _ := ret[1].(bool) return ret0, ret1 } -// ContainerMapByArn indicates an expected call of ContainerMapByArn -func (mr *MockTaskEngineStateMockRecorder) ContainerMapByArn(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerMapByArn", reflect.TypeOf((*MockTaskEngineState)(nil).ContainerMapByArn), arg0) +func (_mr *_MockTaskEngineStateRecorder) ContainerMapByArn(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerMapByArn", arg0) } -// ENIByMac mocks base method -func (m *MockTaskEngineState) ENIByMac(arg0 string) (*api.ENIAttachment, bool) { - ret := m.ctrl.Call(m, "ENIByMac", arg0) +func (_m *MockTaskEngineState) ENIByMac(_param0 string) (*api.ENIAttachment, bool) { + ret := _m.ctrl.Call(_m, "ENIByMac", _param0) ret0, _ := ret[0].(*api.ENIAttachment) ret1, _ := ret[1].(bool) return ret0, ret1 } -// ENIByMac indicates an expected call of ENIByMac -func (mr *MockTaskEngineStateMockRecorder) ENIByMac(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ENIByMac", reflect.TypeOf((*MockTaskEngineState)(nil).ENIByMac), arg0) +func (_mr *_MockTaskEngineStateRecorder) ENIByMac(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ENIByMac", arg0) } -// GetAllContainerIDs mocks base method -func (m *MockTaskEngineState) GetAllContainerIDs() []string { - ret := m.ctrl.Call(m, "GetAllContainerIDs") +func (_m *MockTaskEngineState) GetAllContainerIDs() []string { + ret := _m.ctrl.Call(_m, "GetAllContainerIDs") ret0, _ := ret[0].([]string) return ret0 } -// GetAllContainerIDs indicates an expected call of GetAllContainerIDs -func (mr *MockTaskEngineStateMockRecorder) GetAllContainerIDs() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllContainerIDs", reflect.TypeOf((*MockTaskEngineState)(nil).GetAllContainerIDs)) +func (_mr *_MockTaskEngineStateRecorder) GetAllContainerIDs() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllContainerIDs") } -// MarshalJSON mocks base method -func (m *MockTaskEngineState) MarshalJSON() ([]byte, error) { - ret := m.ctrl.Call(m, "MarshalJSON") +func (_m *MockTaskEngineState) MarshalJSON() ([]byte, error) { + ret := _m.ctrl.Call(_m, "MarshalJSON") ret0, _ := ret[0].([]byte) ret1, _ := ret[1].(error) return ret0, ret1 } -// MarshalJSON indicates an expected call of MarshalJSON -func (mr *MockTaskEngineStateMockRecorder) MarshalJSON() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalJSON", reflect.TypeOf((*MockTaskEngineState)(nil).MarshalJSON)) +func (_mr *_MockTaskEngineStateRecorder) MarshalJSON() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "MarshalJSON") } -// RemoveENIAttachment mocks base method -func (m *MockTaskEngineState) RemoveENIAttachment(arg0 string) { - m.ctrl.Call(m, "RemoveENIAttachment", arg0) +func (_m *MockTaskEngineState) RemoveENIAttachment(_param0 string) { + _m.ctrl.Call(_m, "RemoveENIAttachment", _param0) } -// RemoveENIAttachment indicates an expected call of RemoveENIAttachment -func (mr *MockTaskEngineStateMockRecorder) RemoveENIAttachment(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveENIAttachment", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveENIAttachment), arg0) +func (_mr *_MockTaskEngineStateRecorder) RemoveENIAttachment(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveENIAttachment", arg0) } -// RemoveImageState mocks base method -func (m *MockTaskEngineState) RemoveImageState(arg0 *image.ImageState) { - m.ctrl.Call(m, "RemoveImageState", arg0) +func (_m *MockTaskEngineState) RemoveImageState(_param0 *image.ImageState) { + _m.ctrl.Call(_m, "RemoveImageState", _param0) } -// RemoveImageState indicates an expected call of RemoveImageState -func (mr *MockTaskEngineStateMockRecorder) RemoveImageState(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImageState", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveImageState), arg0) +func (_mr *_MockTaskEngineStateRecorder) RemoveImageState(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImageState", arg0) } -// RemoveTask mocks base method -func (m *MockTaskEngineState) RemoveTask(arg0 *api.Task) { - m.ctrl.Call(m, "RemoveTask", arg0) +func (_m *MockTaskEngineState) RemoveTask(_param0 *api.Task) { + _m.ctrl.Call(_m, "RemoveTask", _param0) } -// RemoveTask indicates an expected call of RemoveTask -func (mr *MockTaskEngineStateMockRecorder) RemoveTask(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTask", reflect.TypeOf((*MockTaskEngineState)(nil).RemoveTask), arg0) +func (_mr *_MockTaskEngineStateRecorder) RemoveTask(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveTask", arg0) } -// Reset mocks base method -func (m *MockTaskEngineState) Reset() { - m.ctrl.Call(m, "Reset") +func (_m *MockTaskEngineState) Reset() { + _m.ctrl.Call(_m, "Reset") } -// Reset indicates an expected call of Reset -func (mr *MockTaskEngineStateMockRecorder) Reset() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTaskEngineState)(nil).Reset)) +func (_mr *_MockTaskEngineStateRecorder) Reset() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset") } -// TaskByArn mocks base method -func (m *MockTaskEngineState) TaskByArn(arg0 string) (*api.Task, bool) { - ret := m.ctrl.Call(m, "TaskByArn", arg0) +func (_m *MockTaskEngineState) TaskByArn(_param0 string) (*api.Task, bool) { + ret := _m.ctrl.Call(_m, "TaskByArn", _param0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -// TaskByArn indicates an expected call of TaskByArn -func (mr *MockTaskEngineStateMockRecorder) TaskByArn(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskByArn", reflect.TypeOf((*MockTaskEngineState)(nil).TaskByArn), arg0) +func (_mr *_MockTaskEngineStateRecorder) TaskByArn(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "TaskByArn", arg0) } -// TaskByID mocks base method -func (m *MockTaskEngineState) TaskByID(arg0 string) (*api.Task, bool) { - ret := m.ctrl.Call(m, "TaskByID", arg0) +func (_m *MockTaskEngineState) TaskByID(_param0 string) (*api.Task, bool) { + ret := _m.ctrl.Call(_m, "TaskByID", _param0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -// TaskByID indicates an expected call of TaskByID -func (mr *MockTaskEngineStateMockRecorder) TaskByID(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskByID", reflect.TypeOf((*MockTaskEngineState)(nil).TaskByID), arg0) +func (_mr *_MockTaskEngineStateRecorder) TaskByID(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "TaskByID", arg0) } -// TaskByShortID mocks base method -func (m *MockTaskEngineState) TaskByShortID(arg0 string) ([]*api.Task, bool) { - ret := m.ctrl.Call(m, "TaskByShortID", arg0) +func (_m *MockTaskEngineState) TaskByShortID(_param0 string) ([]*api.Task, bool) { + ret := _m.ctrl.Call(_m, "TaskByShortID", _param0) ret0, _ := ret[0].([]*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -// TaskByShortID indicates an expected call of TaskByShortID -func (mr *MockTaskEngineStateMockRecorder) TaskByShortID(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskByShortID", reflect.TypeOf((*MockTaskEngineState)(nil).TaskByShortID), arg0) +func (_mr *_MockTaskEngineStateRecorder) TaskByShortID(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "TaskByShortID", arg0) } -// UnmarshalJSON mocks base method -func (m *MockTaskEngineState) UnmarshalJSON(arg0 []byte) error { - ret := m.ctrl.Call(m, "UnmarshalJSON", arg0) +func (_m *MockTaskEngineState) UnmarshalJSON(_param0 []byte) error { + ret := _m.ctrl.Call(_m, "UnmarshalJSON", _param0) ret0, _ := ret[0].(error) return ret0 } -// UnmarshalJSON indicates an expected call of UnmarshalJSON -func (mr *MockTaskEngineStateMockRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalJSON", reflect.TypeOf((*MockTaskEngineState)(nil).UnmarshalJSON), arg0) +func (_mr *_MockTaskEngineStateRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "UnmarshalJSON", arg0) } diff --git a/agent/engine/engine_mocks.go b/agent/engine/engine_mocks.go index ce3ffeb9523..3541ddd8cf7 100644 --- a/agent/engine/engine_mocks.go +++ b/agent/engine/engine_mocks.go @@ -11,16 +11,14 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/engine (interfaces: TaskEngine,DockerClient,ImageManager) -// Package engine is a generated GoMock package. package engine import ( - context "context" + context0 "context" io "io" - reflect "reflect" time "time" api "github.com/aws/amazon-ecs-agent/agent/api" @@ -30,219 +28,189 @@ import ( statemanager "github.com/aws/amazon-ecs-agent/agent/statemanager" go_dockerclient "github.com/fsouza/go-dockerclient" gomock "github.com/golang/mock/gomock" - context0 "golang.org/x/net/context" + context "golang.org/x/net/context" ) -// MockTaskEngine is a mock of TaskEngine interface +// Mock of TaskEngine interface type MockTaskEngine struct { ctrl *gomock.Controller - recorder *MockTaskEngineMockRecorder + recorder *_MockTaskEngineRecorder } -// MockTaskEngineMockRecorder is the mock recorder for MockTaskEngine -type MockTaskEngineMockRecorder struct { +// Recorder for MockTaskEngine (not exported) +type _MockTaskEngineRecorder struct { mock *MockTaskEngine } -// NewMockTaskEngine creates a new mock instance func NewMockTaskEngine(ctrl *gomock.Controller) *MockTaskEngine { mock := &MockTaskEngine{ctrl: ctrl} - mock.recorder = &MockTaskEngineMockRecorder{mock} + mock.recorder = &_MockTaskEngineRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTaskEngine) EXPECT() *MockTaskEngineMockRecorder { - return m.recorder +func (_m *MockTaskEngine) EXPECT() *_MockTaskEngineRecorder { + return _m.recorder } -// AddTask mocks base method -func (m *MockTaskEngine) AddTask(arg0 *api.Task) error { - ret := m.ctrl.Call(m, "AddTask", arg0) +func (_m *MockTaskEngine) AddTask(_param0 *api.Task) error { + ret := _m.ctrl.Call(_m, "AddTask", _param0) ret0, _ := ret[0].(error) return ret0 } -// AddTask indicates an expected call of AddTask -func (mr *MockTaskEngineMockRecorder) AddTask(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTask", reflect.TypeOf((*MockTaskEngine)(nil).AddTask), arg0) +func (_mr *_MockTaskEngineRecorder) AddTask(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddTask", arg0) } -// Disable mocks base method -func (m *MockTaskEngine) Disable() { - m.ctrl.Call(m, "Disable") +func (_m *MockTaskEngine) Disable() { + _m.ctrl.Call(_m, "Disable") } -// Disable indicates an expected call of Disable -func (mr *MockTaskEngineMockRecorder) Disable() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disable", reflect.TypeOf((*MockTaskEngine)(nil).Disable)) +func (_mr *_MockTaskEngineRecorder) Disable() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Disable") } -// GetTaskByArn mocks base method -func (m *MockTaskEngine) GetTaskByArn(arg0 string) (*api.Task, bool) { - ret := m.ctrl.Call(m, "GetTaskByArn", arg0) +func (_m *MockTaskEngine) GetTaskByArn(_param0 string) (*api.Task, bool) { + ret := _m.ctrl.Call(_m, "GetTaskByArn", _param0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(bool) return ret0, ret1 } -// GetTaskByArn indicates an expected call of GetTaskByArn -func (mr *MockTaskEngineMockRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskByArn", reflect.TypeOf((*MockTaskEngine)(nil).GetTaskByArn), arg0) +func (_mr *_MockTaskEngineRecorder) GetTaskByArn(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTaskByArn", arg0) } -func (_m *MockTaskEngine) Init(_param0 context0.Context) error { +func (_m *MockTaskEngine) Init(_param0 context.Context) error { ret := _m.ctrl.Call(_m, "Init", _param0) ret0, _ := ret[0].(error) return ret0 } -// Init indicates an expected call of Init -func (mr *MockTaskEngineMockRecorder) Init(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTaskEngine)(nil).Init), arg0) +func (_mr *_MockTaskEngineRecorder) Init(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Init", arg0) } -// ListTasks mocks base method -func (m *MockTaskEngine) ListTasks() ([]*api.Task, error) { - ret := m.ctrl.Call(m, "ListTasks") +func (_m *MockTaskEngine) ListTasks() ([]*api.Task, error) { + ret := _m.ctrl.Call(_m, "ListTasks") ret0, _ := ret[0].([]*api.Task) ret1, _ := ret[1].(error) return ret0, ret1 } -// ListTasks indicates an expected call of ListTasks -func (mr *MockTaskEngineMockRecorder) ListTasks() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasks", reflect.TypeOf((*MockTaskEngine)(nil).ListTasks)) +func (_mr *_MockTaskEngineRecorder) ListTasks() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTasks") } -// MarshalJSON mocks base method -func (m *MockTaskEngine) MarshalJSON() ([]byte, error) { - ret := m.ctrl.Call(m, "MarshalJSON") +func (_m *MockTaskEngine) MarshalJSON() ([]byte, error) { + ret := _m.ctrl.Call(_m, "MarshalJSON") ret0, _ := ret[0].([]byte) ret1, _ := ret[1].(error) return ret0, ret1 } -// MarshalJSON indicates an expected call of MarshalJSON -func (mr *MockTaskEngineMockRecorder) MarshalJSON() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalJSON", reflect.TypeOf((*MockTaskEngine)(nil).MarshalJSON)) +func (_mr *_MockTaskEngineRecorder) MarshalJSON() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "MarshalJSON") } -func (_m *MockTaskEngine) MustInit(_param0 context0.Context) { +func (_m *MockTaskEngine) MustInit(_param0 context.Context) { _m.ctrl.Call(_m, "MustInit", _param0) } -// MustInit indicates an expected call of MustInit -func (mr *MockTaskEngineMockRecorder) MustInit(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MustInit", reflect.TypeOf((*MockTaskEngine)(nil).MustInit), arg0) +func (_mr *_MockTaskEngineRecorder) MustInit(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "MustInit", arg0) } -// SetSaver mocks base method -func (m *MockTaskEngine) SetSaver(arg0 statemanager.Saver) { - m.ctrl.Call(m, "SetSaver", arg0) +func (_m *MockTaskEngine) SetSaver(_param0 statemanager.Saver) { + _m.ctrl.Call(_m, "SetSaver", _param0) } -// SetSaver indicates an expected call of SetSaver -func (mr *MockTaskEngineMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSaver", reflect.TypeOf((*MockTaskEngine)(nil).SetSaver), arg0) +func (_mr *_MockTaskEngineRecorder) SetSaver(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) } -// StateChangeEvents mocks base method -func (m *MockTaskEngine) StateChangeEvents() chan statechange.Event { - ret := m.ctrl.Call(m, "StateChangeEvents") +func (_m *MockTaskEngine) StateChangeEvents() chan statechange.Event { + ret := _m.ctrl.Call(_m, "StateChangeEvents") ret0, _ := ret[0].(chan statechange.Event) return ret0 } -// StateChangeEvents indicates an expected call of StateChangeEvents -func (mr *MockTaskEngineMockRecorder) StateChangeEvents() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateChangeEvents", reflect.TypeOf((*MockTaskEngine)(nil).StateChangeEvents)) +func (_mr *_MockTaskEngineRecorder) StateChangeEvents() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StateChangeEvents") } -// UnmarshalJSON mocks base method -func (m *MockTaskEngine) UnmarshalJSON(arg0 []byte) error { - ret := m.ctrl.Call(m, "UnmarshalJSON", arg0) +func (_m *MockTaskEngine) UnmarshalJSON(_param0 []byte) error { + ret := _m.ctrl.Call(_m, "UnmarshalJSON", _param0) ret0, _ := ret[0].(error) return ret0 } -// UnmarshalJSON indicates an expected call of UnmarshalJSON -func (mr *MockTaskEngineMockRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalJSON", reflect.TypeOf((*MockTaskEngine)(nil).UnmarshalJSON), arg0) +func (_mr *_MockTaskEngineRecorder) UnmarshalJSON(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "UnmarshalJSON", arg0) } -// Version mocks base method -func (m *MockTaskEngine) Version() (string, error) { - ret := m.ctrl.Call(m, "Version") +func (_m *MockTaskEngine) Version() (string, error) { + ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// Version indicates an expected call of Version -func (mr *MockTaskEngineMockRecorder) Version() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockTaskEngine)(nil).Version)) +func (_mr *_MockTaskEngineRecorder) Version() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } -// MockDockerClient is a mock of DockerClient interface +// Mock of DockerClient interface type MockDockerClient struct { ctrl *gomock.Controller - recorder *MockDockerClientMockRecorder + recorder *_MockDockerClientRecorder } -// MockDockerClientMockRecorder is the mock recorder for MockDockerClient -type MockDockerClientMockRecorder struct { +// Recorder for MockDockerClient (not exported) +type _MockDockerClientRecorder struct { mock *MockDockerClient } -// NewMockDockerClient creates a new mock instance func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient { mock := &MockDockerClient{ctrl: ctrl} - mock.recorder = &MockDockerClientMockRecorder{mock} + mock.recorder = &_MockDockerClientRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockDockerClient) EXPECT() *MockDockerClientMockRecorder { - return m.recorder +func (_m *MockDockerClient) EXPECT() *_MockDockerClientRecorder { + return _m.recorder } -// ContainerEvents mocks base method -func (m *MockDockerClient) ContainerEvents(arg0 context.Context) (<-chan DockerContainerChangeEvent, error) { - ret := m.ctrl.Call(m, "ContainerEvents", arg0) +func (_m *MockDockerClient) ContainerEvents(_param0 context0.Context) (<-chan DockerContainerChangeEvent, error) { + ret := _m.ctrl.Call(_m, "ContainerEvents", _param0) ret0, _ := ret[0].(<-chan DockerContainerChangeEvent) ret1, _ := ret[1].(error) return ret0, ret1 } -// ContainerEvents indicates an expected call of ContainerEvents -func (mr *MockDockerClientMockRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerEvents", reflect.TypeOf((*MockDockerClient)(nil).ContainerEvents), arg0) +func (_mr *_MockDockerClientRecorder) ContainerEvents(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ContainerEvents", arg0) } -// CreateContainer mocks base method -func (m *MockDockerClient) CreateContainer(arg0 *go_dockerclient.Config, arg1 *go_dockerclient.HostConfig, arg2 string, arg3 time.Duration) DockerContainerMetadata { - ret := m.ctrl.Call(m, "CreateContainer", arg0, arg1, arg2, arg3) +func (_m *MockDockerClient) CreateContainer(_param0 *go_dockerclient.Config, _param1 *go_dockerclient.HostConfig, _param2 string, _param3 time.Duration) DockerContainerMetadata { + ret := _m.ctrl.Call(_m, "CreateContainer", _param0, _param1, _param2, _param3) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// CreateContainer indicates an expected call of CreateContainer -func (mr *MockDockerClientMockRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockDockerClient)(nil).CreateContainer), arg0, arg1, arg2, arg3) +func (_mr *_MockDockerClientRecorder) CreateContainer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateContainer", arg0, arg1, arg2, arg3) } -// DescribeContainer mocks base method -func (m *MockDockerClient) DescribeContainer(arg0 string) (api.ContainerStatus, DockerContainerMetadata) { - ret := m.ctrl.Call(m, "DescribeContainer", arg0) +func (_m *MockDockerClient) DescribeContainer(_param0 string) (api.ContainerStatus, DockerContainerMetadata) { + ret := _m.ctrl.Call(_m, "DescribeContainer", _param0) ret0, _ := ret[0].(api.ContainerStatus) ret1, _ := ret[1].(DockerContainerMetadata) return ret0, ret1 } -// DescribeContainer indicates an expected call of DescribeContainer -func (mr *MockDockerClientMockRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContainer", reflect.TypeOf((*MockDockerClient)(nil).DescribeContainer), arg0) +func (_mr *_MockDockerClientRecorder) DescribeContainer(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeContainer", arg0) } func (_m *MockDockerClient) ImportLocalEmptyVolumeImage() DockerContainerMetadata { @@ -262,254 +230,214 @@ func (_m *MockDockerClient) InspectContainer(_param0 string, _param1 time.Durati return ret0, ret1 } -// InspectContainer indicates an expected call of InspectContainer -func (mr *MockDockerClientMockRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockDockerClient)(nil).InspectContainer), arg0, arg1) +func (_mr *_MockDockerClientRecorder) InspectContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectContainer", arg0, arg1) } -// InspectImage mocks base method -func (m *MockDockerClient) InspectImage(arg0 string) (*go_dockerclient.Image, error) { - ret := m.ctrl.Call(m, "InspectImage", arg0) +func (_m *MockDockerClient) InspectImage(_param0 string) (*go_dockerclient.Image, error) { + ret := _m.ctrl.Call(_m, "InspectImage", _param0) ret0, _ := ret[0].(*go_dockerclient.Image) ret1, _ := ret[1].(error) return ret0, ret1 } -// InspectImage indicates an expected call of InspectImage -func (mr *MockDockerClientMockRecorder) InspectImage(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImage", reflect.TypeOf((*MockDockerClient)(nil).InspectImage), arg0) +func (_mr *_MockDockerClientRecorder) InspectImage(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "InspectImage", arg0) } -// KnownVersions mocks base method -func (m *MockDockerClient) KnownVersions() []dockerclient.DockerVersion { - ret := m.ctrl.Call(m, "KnownVersions") +func (_m *MockDockerClient) KnownVersions() []dockerclient.DockerVersion { + ret := _m.ctrl.Call(_m, "KnownVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -// KnownVersions indicates an expected call of KnownVersions -func (mr *MockDockerClientMockRecorder) KnownVersions() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnownVersions", reflect.TypeOf((*MockDockerClient)(nil).KnownVersions)) +func (_mr *_MockDockerClientRecorder) KnownVersions() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "KnownVersions") } -// ListContainers mocks base method -func (m *MockDockerClient) ListContainers(arg0 bool, arg1 time.Duration) ListContainersResponse { - ret := m.ctrl.Call(m, "ListContainers", arg0, arg1) +func (_m *MockDockerClient) ListContainers(_param0 bool, _param1 time.Duration) ListContainersResponse { + ret := _m.ctrl.Call(_m, "ListContainers", _param0, _param1) ret0, _ := ret[0].(ListContainersResponse) return ret0 } -// ListContainers indicates an expected call of ListContainers -func (mr *MockDockerClientMockRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockDockerClient)(nil).ListContainers), arg0, arg1) +func (_mr *_MockDockerClientRecorder) ListContainers(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ListContainers", arg0, arg1) } -// LoadImage mocks base method -func (m *MockDockerClient) LoadImage(arg0 io.Reader, arg1 time.Duration) error { - ret := m.ctrl.Call(m, "LoadImage", arg0, arg1) +func (_m *MockDockerClient) LoadImage(_param0 io.Reader, _param1 time.Duration) error { + ret := _m.ctrl.Call(_m, "LoadImage", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// LoadImage indicates an expected call of LoadImage -func (mr *MockDockerClientMockRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadImage", reflect.TypeOf((*MockDockerClient)(nil).LoadImage), arg0, arg1) +func (_mr *_MockDockerClientRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0, arg1) } -// PullImage mocks base method -func (m *MockDockerClient) PullImage(arg0 string, arg1 *api.RegistryAuthenticationData) DockerContainerMetadata { - ret := m.ctrl.Call(m, "PullImage", arg0, arg1) +func (_m *MockDockerClient) PullImage(_param0 string, _param1 *api.RegistryAuthenticationData) DockerContainerMetadata { + ret := _m.ctrl.Call(_m, "PullImage", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// PullImage indicates an expected call of PullImage -func (mr *MockDockerClientMockRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockDockerClient)(nil).PullImage), arg0, arg1) +func (_mr *_MockDockerClientRecorder) PullImage(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "PullImage", arg0, arg1) } -// RemoveContainer mocks base method -func (m *MockDockerClient) RemoveContainer(arg0 string, arg1 time.Duration) error { - ret := m.ctrl.Call(m, "RemoveContainer", arg0, arg1) +func (_m *MockDockerClient) RemoveContainer(_param0 string, _param1 time.Duration) error { + ret := _m.ctrl.Call(_m, "RemoveContainer", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// RemoveContainer indicates an expected call of RemoveContainer -func (mr *MockDockerClientMockRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockDockerClient)(nil).RemoveContainer), arg0, arg1) +func (_mr *_MockDockerClientRecorder) RemoveContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainer", arg0, arg1) } -// RemoveImage mocks base method -func (m *MockDockerClient) RemoveImage(arg0 string, arg1 time.Duration) error { - ret := m.ctrl.Call(m, "RemoveImage", arg0, arg1) +func (_m *MockDockerClient) RemoveImage(_param0 string, _param1 time.Duration) error { + ret := _m.ctrl.Call(_m, "RemoveImage", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// RemoveImage indicates an expected call of RemoveImage -func (mr *MockDockerClientMockRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockDockerClient)(nil).RemoveImage), arg0, arg1) +func (_mr *_MockDockerClientRecorder) RemoveImage(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveImage", arg0, arg1) } -// StartContainer mocks base method -func (m *MockDockerClient) StartContainer(arg0 string, arg1 time.Duration) DockerContainerMetadata { - ret := m.ctrl.Call(m, "StartContainer", arg0, arg1) +func (_m *MockDockerClient) StartContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { + ret := _m.ctrl.Call(_m, "StartContainer", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// StartContainer indicates an expected call of StartContainer -func (mr *MockDockerClientMockRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockDockerClient)(nil).StartContainer), arg0, arg1) +func (_mr *_MockDockerClientRecorder) StartContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StartContainer", arg0, arg1) } -// Stats mocks base method -func (m *MockDockerClient) Stats(arg0 string, arg1 context.Context) (<-chan *go_dockerclient.Stats, error) { - ret := m.ctrl.Call(m, "Stats", arg0, arg1) +func (_m *MockDockerClient) Stats(_param0 string, _param1 context0.Context) (<-chan *go_dockerclient.Stats, error) { + ret := _m.ctrl.Call(_m, "Stats", _param0, _param1) ret0, _ := ret[0].(<-chan *go_dockerclient.Stats) ret1, _ := ret[1].(error) return ret0, ret1 } -// Stats indicates an expected call of Stats -func (mr *MockDockerClientMockRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockDockerClient)(nil).Stats), arg0, arg1) +func (_mr *_MockDockerClientRecorder) Stats(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Stats", arg0, arg1) } -// StopContainer mocks base method -func (m *MockDockerClient) StopContainer(arg0 string, arg1 time.Duration) DockerContainerMetadata { - ret := m.ctrl.Call(m, "StopContainer", arg0, arg1) +func (_m *MockDockerClient) StopContainer(_param0 string, _param1 time.Duration) DockerContainerMetadata { + ret := _m.ctrl.Call(_m, "StopContainer", _param0, _param1) ret0, _ := ret[0].(DockerContainerMetadata) return ret0 } -// StopContainer indicates an expected call of StopContainer -func (mr *MockDockerClientMockRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockDockerClient)(nil).StopContainer), arg0, arg1) +func (_mr *_MockDockerClientRecorder) StopContainer(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StopContainer", arg0, arg1) } -// SupportedVersions mocks base method -func (m *MockDockerClient) SupportedVersions() []dockerclient.DockerVersion { - ret := m.ctrl.Call(m, "SupportedVersions") +func (_m *MockDockerClient) SupportedVersions() []dockerclient.DockerVersion { + ret := _m.ctrl.Call(_m, "SupportedVersions") ret0, _ := ret[0].([]dockerclient.DockerVersion) return ret0 } -// SupportedVersions indicates an expected call of SupportedVersions -func (mr *MockDockerClientMockRecorder) SupportedVersions() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportedVersions", reflect.TypeOf((*MockDockerClient)(nil).SupportedVersions)) +func (_mr *_MockDockerClientRecorder) SupportedVersions() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SupportedVersions") } -// Version mocks base method -func (m *MockDockerClient) Version() (string, error) { - ret := m.ctrl.Call(m, "Version") +func (_m *MockDockerClient) Version() (string, error) { + ret := _m.ctrl.Call(_m, "Version") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// Version indicates an expected call of Version -func (mr *MockDockerClientMockRecorder) Version() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockDockerClient)(nil).Version)) +func (_mr *_MockDockerClientRecorder) Version() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Version") } -// WithVersion mocks base method -func (m *MockDockerClient) WithVersion(arg0 dockerclient.DockerVersion) DockerClient { - ret := m.ctrl.Call(m, "WithVersion", arg0) +func (_m *MockDockerClient) WithVersion(_param0 dockerclient.DockerVersion) DockerClient { + ret := _m.ctrl.Call(_m, "WithVersion", _param0) ret0, _ := ret[0].(DockerClient) return ret0 } -// WithVersion indicates an expected call of WithVersion -func (mr *MockDockerClientMockRecorder) WithVersion(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithVersion", reflect.TypeOf((*MockDockerClient)(nil).WithVersion), arg0) +func (_mr *_MockDockerClientRecorder) WithVersion(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "WithVersion", arg0) } -// MockImageManager is a mock of ImageManager interface +// Mock of ImageManager interface type MockImageManager struct { ctrl *gomock.Controller - recorder *MockImageManagerMockRecorder + recorder *_MockImageManagerRecorder } -// MockImageManagerMockRecorder is the mock recorder for MockImageManager -type MockImageManagerMockRecorder struct { +// Recorder for MockImageManager (not exported) +type _MockImageManagerRecorder struct { mock *MockImageManager } -// NewMockImageManager creates a new mock instance func NewMockImageManager(ctrl *gomock.Controller) *MockImageManager { mock := &MockImageManager{ctrl: ctrl} - mock.recorder = &MockImageManagerMockRecorder{mock} + mock.recorder = &_MockImageManagerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockImageManager) EXPECT() *MockImageManagerMockRecorder { - return m.recorder +func (_m *MockImageManager) EXPECT() *_MockImageManagerRecorder { + return _m.recorder } -// AddAllImageStates mocks base method -func (m *MockImageManager) AddAllImageStates(arg0 []*image.ImageState) { - m.ctrl.Call(m, "AddAllImageStates", arg0) +func (_m *MockImageManager) AddAllImageStates(_param0 []*image.ImageState) { + _m.ctrl.Call(_m, "AddAllImageStates", _param0) } -// AddAllImageStates indicates an expected call of AddAllImageStates -func (mr *MockImageManagerMockRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAllImageStates", reflect.TypeOf((*MockImageManager)(nil).AddAllImageStates), arg0) +func (_mr *_MockImageManagerRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddAllImageStates", arg0) } -// GetImageStateFromImageName mocks base method -func (m *MockImageManager) GetImageStateFromImageName(arg0 string) *image.ImageState { - ret := m.ctrl.Call(m, "GetImageStateFromImageName", arg0) +func (_m *MockImageManager) GetImageStateFromImageName(_param0 string) *image.ImageState { + ret := _m.ctrl.Call(_m, "GetImageStateFromImageName", _param0) ret0, _ := ret[0].(*image.ImageState) return ret0 } -// GetImageStateFromImageName indicates an expected call of GetImageStateFromImageName -func (mr *MockImageManagerMockRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageStateFromImageName", reflect.TypeOf((*MockImageManager)(nil).GetImageStateFromImageName), arg0) +func (_mr *_MockImageManagerRecorder) GetImageStateFromImageName(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetImageStateFromImageName", arg0) } -// RecordContainerReference mocks base method -func (m *MockImageManager) RecordContainerReference(arg0 *api.Container) error { - ret := m.ctrl.Call(m, "RecordContainerReference", arg0) +func (_m *MockImageManager) RecordContainerReference(_param0 *api.Container) error { + ret := _m.ctrl.Call(_m, "RecordContainerReference", _param0) ret0, _ := ret[0].(error) return ret0 } -// RecordContainerReference indicates an expected call of RecordContainerReference -func (mr *MockImageManagerMockRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordContainerReference", reflect.TypeOf((*MockImageManager)(nil).RecordContainerReference), arg0) +func (_mr *_MockImageManagerRecorder) RecordContainerReference(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RecordContainerReference", arg0) } -// RemoveContainerReferenceFromImageState mocks base method -func (m *MockImageManager) RemoveContainerReferenceFromImageState(arg0 *api.Container) error { - ret := m.ctrl.Call(m, "RemoveContainerReferenceFromImageState", arg0) +func (_m *MockImageManager) RemoveContainerReferenceFromImageState(_param0 *api.Container) error { + ret := _m.ctrl.Call(_m, "RemoveContainerReferenceFromImageState", _param0) ret0, _ := ret[0].(error) return ret0 } -// RemoveContainerReferenceFromImageState indicates an expected call of RemoveContainerReferenceFromImageState -func (mr *MockImageManagerMockRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainerReferenceFromImageState", reflect.TypeOf((*MockImageManager)(nil).RemoveContainerReferenceFromImageState), arg0) +func (_mr *_MockImageManagerRecorder) RemoveContainerReferenceFromImageState(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveContainerReferenceFromImageState", arg0) } -// SetSaver mocks base method -func (m *MockImageManager) SetSaver(arg0 statemanager.Saver) { - m.ctrl.Call(m, "SetSaver", arg0) +func (_m *MockImageManager) SetSaver(_param0 statemanager.Saver) { + _m.ctrl.Call(_m, "SetSaver", _param0) } -// SetSaver indicates an expected call of SetSaver -func (mr *MockImageManagerMockRecorder) SetSaver(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSaver", reflect.TypeOf((*MockImageManager)(nil).SetSaver), arg0) +func (_mr *_MockImageManagerRecorder) SetSaver(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetSaver", arg0) } -func (_m *MockImageManager) StartImageCleanupProcess(_param0 context0.Context) { +func (_m *MockImageManager) StartImageCleanupProcess(_param0 context.Context) { _m.ctrl.Call(_m, "StartImageCleanupProcess", _param0) } -// StartImageCleanupProcess indicates an expected call of StartImageCleanupProcess -func (mr *MockImageManagerMockRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartImageCleanupProcess", reflect.TypeOf((*MockImageManager)(nil).StartImageCleanupProcess), arg0) +func (_mr *_MockImageManagerRecorder) StartImageCleanupProcess(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "StartImageCleanupProcess", arg0) } diff --git a/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go b/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go index 0d7406b0664..ba7c578d551 100644 --- a/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go +++ b/agent/eni/netlinkwrapper/mocks/mock_netlinkwrapper_linux.go @@ -11,64 +11,55 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/eni/netlinkwrapper (interfaces: NetLink) -// Package mock_netlinkwrapper is a generated GoMock package. package mock_netlinkwrapper import ( - reflect "reflect" - gomock "github.com/golang/mock/gomock" netlink "github.com/vishvananda/netlink" ) -// MockNetLink is a mock of NetLink interface +// Mock of NetLink interface type MockNetLink struct { ctrl *gomock.Controller - recorder *MockNetLinkMockRecorder + recorder *_MockNetLinkRecorder } -// MockNetLinkMockRecorder is the mock recorder for MockNetLink -type MockNetLinkMockRecorder struct { +// Recorder for MockNetLink (not exported) +type _MockNetLinkRecorder struct { mock *MockNetLink } -// NewMockNetLink creates a new mock instance func NewMockNetLink(ctrl *gomock.Controller) *MockNetLink { mock := &MockNetLink{ctrl: ctrl} - mock.recorder = &MockNetLinkMockRecorder{mock} + mock.recorder = &_MockNetLinkRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockNetLink) EXPECT() *MockNetLinkMockRecorder { - return m.recorder +func (_m *MockNetLink) EXPECT() *_MockNetLinkRecorder { + return _m.recorder } -// LinkByName mocks base method -func (m *MockNetLink) LinkByName(arg0 string) (netlink.Link, error) { - ret := m.ctrl.Call(m, "LinkByName", arg0) +func (_m *MockNetLink) LinkByName(_param0 string) (netlink.Link, error) { + ret := _m.ctrl.Call(_m, "LinkByName", _param0) ret0, _ := ret[0].(netlink.Link) ret1, _ := ret[1].(error) return ret0, ret1 } -// LinkByName indicates an expected call of LinkByName -func (mr *MockNetLinkMockRecorder) LinkByName(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkByName", reflect.TypeOf((*MockNetLink)(nil).LinkByName), arg0) +func (_mr *_MockNetLinkRecorder) LinkByName(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "LinkByName", arg0) } -// LinkList mocks base method -func (m *MockNetLink) LinkList() ([]netlink.Link, error) { - ret := m.ctrl.Call(m, "LinkList") +func (_m *MockNetLink) LinkList() ([]netlink.Link, error) { + ret := _m.ctrl.Call(_m, "LinkList") ret0, _ := ret[0].([]netlink.Link) ret1, _ := ret[1].(error) return ret0, ret1 } -// LinkList indicates an expected call of LinkList -func (mr *MockNetLinkMockRecorder) LinkList() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkList", reflect.TypeOf((*MockNetLink)(nil).LinkList)) +func (_mr *_MockNetLinkRecorder) LinkList() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "LinkList") } diff --git a/agent/eni/pause/mocks/load_mocks.go b/agent/eni/pause/mocks/load_mocks.go index 484e546abc9..31a04f6e1ef 100644 --- a/agent/eni/pause/mocks/load_mocks.go +++ b/agent/eni/pause/mocks/load_mocks.go @@ -11,53 +11,46 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/eni/pause (interfaces: Loader) -// Package mock_pause is a generated GoMock package. package mock_pause import ( - reflect "reflect" - config "github.com/aws/amazon-ecs-agent/agent/config" engine "github.com/aws/amazon-ecs-agent/agent/engine" go_dockerclient "github.com/fsouza/go-dockerclient" gomock "github.com/golang/mock/gomock" ) -// MockLoader is a mock of Loader interface +// Mock of Loader interface type MockLoader struct { ctrl *gomock.Controller - recorder *MockLoaderMockRecorder + recorder *_MockLoaderRecorder } -// MockLoaderMockRecorder is the mock recorder for MockLoader -type MockLoaderMockRecorder struct { +// Recorder for MockLoader (not exported) +type _MockLoaderRecorder struct { mock *MockLoader } -// NewMockLoader creates a new mock instance func NewMockLoader(ctrl *gomock.Controller) *MockLoader { mock := &MockLoader{ctrl: ctrl} - mock.recorder = &MockLoaderMockRecorder{mock} + mock.recorder = &_MockLoaderRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockLoader) EXPECT() *MockLoaderMockRecorder { - return m.recorder +func (_m *MockLoader) EXPECT() *_MockLoaderRecorder { + return _m.recorder } -// LoadImage mocks base method -func (m *MockLoader) LoadImage(arg0 *config.Config, arg1 engine.DockerClient) (*go_dockerclient.Image, error) { - ret := m.ctrl.Call(m, "LoadImage", arg0, arg1) +func (_m *MockLoader) LoadImage(_param0 *config.Config, _param1 engine.DockerClient) (*go_dockerclient.Image, error) { + ret := _m.ctrl.Call(_m, "LoadImage", _param0, _param1) ret0, _ := ret[0].(*go_dockerclient.Image) ret1, _ := ret[1].(error) return ret0, ret1 } -// LoadImage indicates an expected call of LoadImage -func (mr *MockLoaderMockRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadImage", reflect.TypeOf((*MockLoader)(nil).LoadImage), arg0, arg1) +func (_mr *_MockLoaderRecorder) LoadImage(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "LoadImage", arg0, arg1) } diff --git a/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go b/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go index 61e50d4e8bb..d82440896cc 100644 --- a/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go +++ b/agent/eni/udevwrapper/mocks/mock_udevwrapper_linux.go @@ -11,62 +11,53 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/eni/udevwrapper (interfaces: Udev) -// Package mock_udevwrapper is a generated GoMock package. package mock_udevwrapper import ( - reflect "reflect" - udev "github.com/deniswernert/udev" gomock "github.com/golang/mock/gomock" ) -// MockUdev is a mock of Udev interface +// Mock of Udev interface type MockUdev struct { ctrl *gomock.Controller - recorder *MockUdevMockRecorder + recorder *_MockUdevRecorder } -// MockUdevMockRecorder is the mock recorder for MockUdev -type MockUdevMockRecorder struct { +// Recorder for MockUdev (not exported) +type _MockUdevRecorder struct { mock *MockUdev } -// NewMockUdev creates a new mock instance func NewMockUdev(ctrl *gomock.Controller) *MockUdev { mock := &MockUdev{ctrl: ctrl} - mock.recorder = &MockUdevMockRecorder{mock} + mock.recorder = &_MockUdevRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockUdev) EXPECT() *MockUdevMockRecorder { - return m.recorder +func (_m *MockUdev) EXPECT() *_MockUdevRecorder { + return _m.recorder } -// Close mocks base method -func (m *MockUdev) Close() error { - ret := m.ctrl.Call(m, "Close") +func (_m *MockUdev) Close() error { + ret := _m.ctrl.Call(_m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close -func (mr *MockUdevMockRecorder) Close() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockUdev)(nil).Close)) +func (_mr *_MockUdevRecorder) Close() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") } -// Monitor mocks base method -func (m *MockUdev) Monitor(arg0 chan *udev.UEvent) chan bool { - ret := m.ctrl.Call(m, "Monitor", arg0) +func (_m *MockUdev) Monitor(_param0 chan *udev.UEvent) chan bool { + ret := _m.ctrl.Call(_m, "Monitor", _param0) ret0, _ := ret[0].(chan bool) return ret0 } -// Monitor indicates an expected call of Monitor -func (mr *MockUdevMockRecorder) Monitor(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Monitor", reflect.TypeOf((*MockUdev)(nil).Monitor), arg0) +func (_mr *_MockUdevRecorder) Monitor(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Monitor", arg0) } diff --git a/agent/handlers/mocks/handlers_mocks.go b/agent/handlers/mocks/handlers_mocks.go index 459cd5ace44..b63b06a375e 100644 --- a/agent/handlers/mocks/handlers_mocks.go +++ b/agent/handlers/mocks/handlers_mocks.go @@ -11,50 +11,43 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/handlers (interfaces: DockerStateResolver) -// Package mock_handlers is a generated GoMock package. package mock_handlers import ( - reflect "reflect" - dockerstate "github.com/aws/amazon-ecs-agent/agent/engine/dockerstate" gomock "github.com/golang/mock/gomock" ) -// MockDockerStateResolver is a mock of DockerStateResolver interface +// Mock of DockerStateResolver interface type MockDockerStateResolver struct { ctrl *gomock.Controller - recorder *MockDockerStateResolverMockRecorder + recorder *_MockDockerStateResolverRecorder } -// MockDockerStateResolverMockRecorder is the mock recorder for MockDockerStateResolver -type MockDockerStateResolverMockRecorder struct { +// Recorder for MockDockerStateResolver (not exported) +type _MockDockerStateResolverRecorder struct { mock *MockDockerStateResolver } -// NewMockDockerStateResolver creates a new mock instance func NewMockDockerStateResolver(ctrl *gomock.Controller) *MockDockerStateResolver { mock := &MockDockerStateResolver{ctrl: ctrl} - mock.recorder = &MockDockerStateResolverMockRecorder{mock} + mock.recorder = &_MockDockerStateResolverRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockDockerStateResolver) EXPECT() *MockDockerStateResolverMockRecorder { - return m.recorder +func (_m *MockDockerStateResolver) EXPECT() *_MockDockerStateResolverRecorder { + return _m.recorder } -// State mocks base method -func (m *MockDockerStateResolver) State() dockerstate.TaskEngineState { - ret := m.ctrl.Call(m, "State") +func (_m *MockDockerStateResolver) State() dockerstate.TaskEngineState { + ret := _m.ctrl.Call(_m, "State") ret0, _ := ret[0].(dockerstate.TaskEngineState) return ret0 } -// State indicates an expected call of State -func (mr *MockDockerStateResolverMockRecorder) State() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "State", reflect.TypeOf((*MockDockerStateResolver)(nil).State)) +func (_mr *_MockDockerStateResolverRecorder) State() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "State") } diff --git a/agent/handlers/mocks/http/handlers_mocks.go b/agent/handlers/mocks/http/handlers_mocks.go index e4e28f56e30..9881a07cacc 100644 --- a/agent/handlers/mocks/http/handlers_mocks.go +++ b/agent/handlers/mocks/http/handlers_mocks.go @@ -11,73 +11,63 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: net/http (interfaces: ResponseWriter) -// Package mock_http is a generated GoMock package. package mock_http import ( http "net/http" - reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// MockResponseWriter is a mock of ResponseWriter interface +// Mock of ResponseWriter interface type MockResponseWriter struct { ctrl *gomock.Controller - recorder *MockResponseWriterMockRecorder + recorder *_MockResponseWriterRecorder } -// MockResponseWriterMockRecorder is the mock recorder for MockResponseWriter -type MockResponseWriterMockRecorder struct { +// Recorder for MockResponseWriter (not exported) +type _MockResponseWriterRecorder struct { mock *MockResponseWriter } -// NewMockResponseWriter creates a new mock instance func NewMockResponseWriter(ctrl *gomock.Controller) *MockResponseWriter { mock := &MockResponseWriter{ctrl: ctrl} - mock.recorder = &MockResponseWriterMockRecorder{mock} + mock.recorder = &_MockResponseWriterRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockResponseWriter) EXPECT() *MockResponseWriterMockRecorder { - return m.recorder +func (_m *MockResponseWriter) EXPECT() *_MockResponseWriterRecorder { + return _m.recorder } -// Header mocks base method -func (m *MockResponseWriter) Header() http.Header { - ret := m.ctrl.Call(m, "Header") +func (_m *MockResponseWriter) Header() http.Header { + ret := _m.ctrl.Call(_m, "Header") ret0, _ := ret[0].(http.Header) return ret0 } -// Header indicates an expected call of Header -func (mr *MockResponseWriterMockRecorder) Header() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockResponseWriter)(nil).Header)) +func (_mr *_MockResponseWriterRecorder) Header() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Header") } -// Write mocks base method -func (m *MockResponseWriter) Write(arg0 []byte) (int, error) { - ret := m.ctrl.Call(m, "Write", arg0) +func (_m *MockResponseWriter) Write(_param0 []byte) (int, error) { + ret := _m.ctrl.Call(_m, "Write", _param0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) return ret0, ret1 } -// Write indicates an expected call of Write -func (mr *MockResponseWriterMockRecorder) Write(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockResponseWriter)(nil).Write), arg0) +func (_mr *_MockResponseWriterRecorder) Write(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0) } -// WriteHeader mocks base method -func (m *MockResponseWriter) WriteHeader(arg0 int) { - m.ctrl.Call(m, "WriteHeader", arg0) +func (_m *MockResponseWriter) WriteHeader(_param0 int) { + _m.ctrl.Call(_m, "WriteHeader", _param0) } -// WriteHeader indicates an expected call of WriteHeader -func (mr *MockResponseWriterMockRecorder) WriteHeader(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteHeader", reflect.TypeOf((*MockResponseWriter)(nil).WriteHeader), arg0) +func (_mr *_MockResponseWriterRecorder) WriteHeader(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteHeader", arg0) } diff --git a/agent/httpclient/mock/httpclient.go b/agent/httpclient/mock/httpclient.go index f973bd42560..40af7d40cad 100644 --- a/agent/httpclient/mock/httpclient.go +++ b/agent/httpclient/mock/httpclient.go @@ -11,51 +11,45 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: net/http (interfaces: RoundTripper) -// Package mock_http is a generated GoMock package. package mock_http import ( http "net/http" - reflect "reflect" gomock "github.com/golang/mock/gomock" ) -// MockRoundTripper is a mock of RoundTripper interface +// Mock of RoundTripper interface type MockRoundTripper struct { ctrl *gomock.Controller - recorder *MockRoundTripperMockRecorder + recorder *_MockRoundTripperRecorder } -// MockRoundTripperMockRecorder is the mock recorder for MockRoundTripper -type MockRoundTripperMockRecorder struct { +// Recorder for MockRoundTripper (not exported) +type _MockRoundTripperRecorder struct { mock *MockRoundTripper } -// NewMockRoundTripper creates a new mock instance func NewMockRoundTripper(ctrl *gomock.Controller) *MockRoundTripper { mock := &MockRoundTripper{ctrl: ctrl} - mock.recorder = &MockRoundTripperMockRecorder{mock} + mock.recorder = &_MockRoundTripperRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockRoundTripper) EXPECT() *MockRoundTripperMockRecorder { - return m.recorder +func (_m *MockRoundTripper) EXPECT() *_MockRoundTripperRecorder { + return _m.recorder } -// RoundTrip mocks base method -func (m *MockRoundTripper) RoundTrip(arg0 *http.Request) (*http.Response, error) { - ret := m.ctrl.Call(m, "RoundTrip", arg0) +func (_m *MockRoundTripper) RoundTrip(_param0 *http.Request) (*http.Response, error) { + ret := _m.ctrl.Call(_m, "RoundTrip", _param0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } -// RoundTrip indicates an expected call of RoundTrip -func (mr *MockRoundTripperMockRecorder) RoundTrip(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoundTrip", reflect.TypeOf((*MockRoundTripper)(nil).RoundTrip), arg0) +func (_mr *_MockRoundTripperRecorder) RoundTrip(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RoundTrip", arg0) } diff --git a/agent/logger/audit/mocks/audit_log_mocks.go b/agent/logger/audit/mocks/audit_log_mocks.go index 842fc9e0ff8..76faa0aeb01 100644 --- a/agent/logger/audit/mocks/audit_log_mocks.go +++ b/agent/logger/audit/mocks/audit_log_mocks.go @@ -11,109 +11,94 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/logger/audit (interfaces: AuditLogger,InfoLogger) -// Package mock_audit is a generated GoMock package. package mock_audit import ( - reflect "reflect" - request "github.com/aws/amazon-ecs-agent/agent/logger/audit/request" gomock "github.com/golang/mock/gomock" ) -// MockAuditLogger is a mock of AuditLogger interface +// Mock of AuditLogger interface type MockAuditLogger struct { ctrl *gomock.Controller - recorder *MockAuditLoggerMockRecorder + recorder *_MockAuditLoggerRecorder } -// MockAuditLoggerMockRecorder is the mock recorder for MockAuditLogger -type MockAuditLoggerMockRecorder struct { +// Recorder for MockAuditLogger (not exported) +type _MockAuditLoggerRecorder struct { mock *MockAuditLogger } -// NewMockAuditLogger creates a new mock instance func NewMockAuditLogger(ctrl *gomock.Controller) *MockAuditLogger { mock := &MockAuditLogger{ctrl: ctrl} - mock.recorder = &MockAuditLoggerMockRecorder{mock} + mock.recorder = &_MockAuditLoggerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockAuditLogger) EXPECT() *MockAuditLoggerMockRecorder { - return m.recorder +func (_m *MockAuditLogger) EXPECT() *_MockAuditLoggerRecorder { + return _m.recorder } -// GetCluster mocks base method -func (m *MockAuditLogger) GetCluster() string { - ret := m.ctrl.Call(m, "GetCluster") +func (_m *MockAuditLogger) GetCluster() string { + ret := _m.ctrl.Call(_m, "GetCluster") ret0, _ := ret[0].(string) return ret0 } -// GetCluster indicates an expected call of GetCluster -func (mr *MockAuditLoggerMockRecorder) GetCluster() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockAuditLogger)(nil).GetCluster)) +func (_mr *_MockAuditLoggerRecorder) GetCluster() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCluster") } -// GetContainerInstanceArn mocks base method -func (m *MockAuditLogger) GetContainerInstanceArn() string { - ret := m.ctrl.Call(m, "GetContainerInstanceArn") +func (_m *MockAuditLogger) GetContainerInstanceArn() string { + ret := _m.ctrl.Call(_m, "GetContainerInstanceArn") ret0, _ := ret[0].(string) return ret0 } -// GetContainerInstanceArn indicates an expected call of GetContainerInstanceArn -func (mr *MockAuditLoggerMockRecorder) GetContainerInstanceArn() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInstanceArn", reflect.TypeOf((*MockAuditLogger)(nil).GetContainerInstanceArn)) +func (_mr *_MockAuditLoggerRecorder) GetContainerInstanceArn() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetContainerInstanceArn") } -// Log mocks base method -func (m *MockAuditLogger) Log(arg0 request.LogRequest, arg1 int, arg2 string) { - m.ctrl.Call(m, "Log", arg0, arg1, arg2) +func (_m *MockAuditLogger) Log(_param0 request.LogRequest, _param1 int, _param2 string) { + _m.ctrl.Call(_m, "Log", _param0, _param1, _param2) } -// Log indicates an expected call of Log -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) +func (_mr *_MockAuditLoggerRecorder) Log(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Log", arg0, arg1, arg2) } -// MockInfoLogger is a mock of InfoLogger interface +// Mock of InfoLogger interface type MockInfoLogger struct { ctrl *gomock.Controller - recorder *MockInfoLoggerMockRecorder + recorder *_MockInfoLoggerRecorder } -// MockInfoLoggerMockRecorder is the mock recorder for MockInfoLogger -type MockInfoLoggerMockRecorder struct { +// Recorder for MockInfoLogger (not exported) +type _MockInfoLoggerRecorder struct { mock *MockInfoLogger } -// NewMockInfoLogger creates a new mock instance func NewMockInfoLogger(ctrl *gomock.Controller) *MockInfoLogger { mock := &MockInfoLogger{ctrl: ctrl} - mock.recorder = &MockInfoLoggerMockRecorder{mock} + mock.recorder = &_MockInfoLoggerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockInfoLogger) EXPECT() *MockInfoLoggerMockRecorder { - return m.recorder +func (_m *MockInfoLogger) EXPECT() *_MockInfoLoggerRecorder { + return _m.recorder } -// Info mocks base method -func (m *MockInfoLogger) Info(arg0 ...interface{}) { - varargs := []interface{}{} - for _, a := range arg0 { - varargs = append(varargs, a) +func (_m *MockInfoLogger) Info(_param0 ...interface{}) { + _s := []interface{}{} + for _, _x := range _param0 { + _s = append(_s, _x) } - m.ctrl.Call(m, "Info", varargs...) + _m.ctrl.Call(_m, "Info", _s...) } -// Info indicates an expected call of Info -func (mr *MockInfoLoggerMockRecorder) Info(arg0 ...interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockInfoLogger)(nil).Info), arg0...) +func (_mr *_MockInfoLoggerRecorder) Info(arg0 ...interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Info", arg0...) } diff --git a/agent/statemanager/mocks/statemanager_mocks.go b/agent/statemanager/mocks/statemanager_mocks.go index a4333ed5ea4..f96d573d787 100644 --- a/agent/statemanager/mocks/statemanager_mocks.go +++ b/agent/statemanager/mocks/statemanager_mocks.go @@ -11,73 +11,62 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/statemanager (interfaces: StateManager) -// Package mock_statemanager is a generated GoMock package. package mock_statemanager import ( - reflect "reflect" - gomock "github.com/golang/mock/gomock" ) -// MockStateManager is a mock of StateManager interface +// Mock of StateManager interface type MockStateManager struct { ctrl *gomock.Controller - recorder *MockStateManagerMockRecorder + recorder *_MockStateManagerRecorder } -// MockStateManagerMockRecorder is the mock recorder for MockStateManager -type MockStateManagerMockRecorder struct { +// Recorder for MockStateManager (not exported) +type _MockStateManagerRecorder struct { mock *MockStateManager } -// NewMockStateManager creates a new mock instance func NewMockStateManager(ctrl *gomock.Controller) *MockStateManager { mock := &MockStateManager{ctrl: ctrl} - mock.recorder = &MockStateManagerMockRecorder{mock} + mock.recorder = &_MockStateManagerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockStateManager) EXPECT() *MockStateManagerMockRecorder { - return m.recorder +func (_m *MockStateManager) EXPECT() *_MockStateManagerRecorder { + return _m.recorder } -// ForceSave mocks base method -func (m *MockStateManager) ForceSave() error { - ret := m.ctrl.Call(m, "ForceSave") +func (_m *MockStateManager) ForceSave() error { + ret := _m.ctrl.Call(_m, "ForceSave") ret0, _ := ret[0].(error) return ret0 } -// ForceSave indicates an expected call of ForceSave -func (mr *MockStateManagerMockRecorder) ForceSave() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceSave", reflect.TypeOf((*MockStateManager)(nil).ForceSave)) +func (_mr *_MockStateManagerRecorder) ForceSave() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ForceSave") } -// Load mocks base method -func (m *MockStateManager) Load() error { - ret := m.ctrl.Call(m, "Load") +func (_m *MockStateManager) Load() error { + ret := _m.ctrl.Call(_m, "Load") ret0, _ := ret[0].(error) return ret0 } -// Load indicates an expected call of Load -func (mr *MockStateManagerMockRecorder) Load() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockStateManager)(nil).Load)) +func (_mr *_MockStateManagerRecorder) Load() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Load") } -// Save mocks base method -func (m *MockStateManager) Save() error { - ret := m.ctrl.Call(m, "Save") +func (_m *MockStateManager) Save() error { + ret := _m.ctrl.Call(_m, "Save") ret0, _ := ret[0].(error) return ret0 } -// Save indicates an expected call of Save -func (mr *MockStateManagerMockRecorder) Save() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStateManager)(nil).Save)) +func (_mr *_MockStateManagerRecorder) Save() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Save") } diff --git a/agent/stats/mock/engine.go b/agent/stats/mock/engine.go index 22127ca68e3..c6b64a110b2 100644 --- a/agent/stats/mock/engine.go +++ b/agent/stats/mock/engine.go @@ -11,52 +11,45 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/stats (interfaces: Engine) -// Package mock_stats is a generated GoMock package. package mock_stats import ( - reflect "reflect" - ecstcs "github.com/aws/amazon-ecs-agent/agent/tcs/model/ecstcs" gomock "github.com/golang/mock/gomock" ) -// MockEngine is a mock of Engine interface +// Mock of Engine interface type MockEngine struct { ctrl *gomock.Controller - recorder *MockEngineMockRecorder + recorder *_MockEngineRecorder } -// MockEngineMockRecorder is the mock recorder for MockEngine -type MockEngineMockRecorder struct { +// Recorder for MockEngine (not exported) +type _MockEngineRecorder struct { mock *MockEngine } -// NewMockEngine creates a new mock instance func NewMockEngine(ctrl *gomock.Controller) *MockEngine { mock := &MockEngine{ctrl: ctrl} - mock.recorder = &MockEngineMockRecorder{mock} + mock.recorder = &_MockEngineRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockEngine) EXPECT() *MockEngineMockRecorder { - return m.recorder +func (_m *MockEngine) EXPECT() *_MockEngineRecorder { + return _m.recorder } -// GetInstanceMetrics mocks base method -func (m *MockEngine) GetInstanceMetrics() (*ecstcs.MetricsMetadata, []*ecstcs.TaskMetric, error) { - ret := m.ctrl.Call(m, "GetInstanceMetrics") +func (_m *MockEngine) GetInstanceMetrics() (*ecstcs.MetricsMetadata, []*ecstcs.TaskMetric, error) { + ret := _m.ctrl.Call(_m, "GetInstanceMetrics") ret0, _ := ret[0].(*ecstcs.MetricsMetadata) ret1, _ := ret[1].([]*ecstcs.TaskMetric) ret2, _ := ret[2].(error) return ret0, ret1, ret2 } -// GetInstanceMetrics indicates an expected call of GetInstanceMetrics -func (mr *MockEngineMockRecorder) GetInstanceMetrics() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMetrics", reflect.TypeOf((*MockEngine)(nil).GetInstanceMetrics)) +func (_mr *_MockEngineRecorder) GetInstanceMetrics() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetInstanceMetrics") } diff --git a/agent/stats/resolver/mock/resolver.go b/agent/stats/resolver/mock/resolver.go index 9f890d23585..74ee5c3c46e 100644 --- a/agent/stats/resolver/mock/resolver.go +++ b/agent/stats/resolver/mock/resolver.go @@ -11,64 +11,55 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/stats/resolver (interfaces: ContainerMetadataResolver) -// Package mock_resolver is a generated GoMock package. package mock_resolver import ( - reflect "reflect" - api "github.com/aws/amazon-ecs-agent/agent/api" gomock "github.com/golang/mock/gomock" ) -// MockContainerMetadataResolver is a mock of ContainerMetadataResolver interface +// Mock of ContainerMetadataResolver interface type MockContainerMetadataResolver struct { ctrl *gomock.Controller - recorder *MockContainerMetadataResolverMockRecorder + recorder *_MockContainerMetadataResolverRecorder } -// MockContainerMetadataResolverMockRecorder is the mock recorder for MockContainerMetadataResolver -type MockContainerMetadataResolverMockRecorder struct { +// Recorder for MockContainerMetadataResolver (not exported) +type _MockContainerMetadataResolverRecorder struct { mock *MockContainerMetadataResolver } -// NewMockContainerMetadataResolver creates a new mock instance func NewMockContainerMetadataResolver(ctrl *gomock.Controller) *MockContainerMetadataResolver { mock := &MockContainerMetadataResolver{ctrl: ctrl} - mock.recorder = &MockContainerMetadataResolverMockRecorder{mock} + mock.recorder = &_MockContainerMetadataResolverRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockContainerMetadataResolver) EXPECT() *MockContainerMetadataResolverMockRecorder { - return m.recorder +func (_m *MockContainerMetadataResolver) EXPECT() *_MockContainerMetadataResolverRecorder { + return _m.recorder } -// ResolveContainer mocks base method -func (m *MockContainerMetadataResolver) ResolveContainer(arg0 string) (*api.DockerContainer, error) { - ret := m.ctrl.Call(m, "ResolveContainer", arg0) +func (_m *MockContainerMetadataResolver) ResolveContainer(_param0 string) (*api.DockerContainer, error) { + ret := _m.ctrl.Call(_m, "ResolveContainer", _param0) ret0, _ := ret[0].(*api.DockerContainer) ret1, _ := ret[1].(error) return ret0, ret1 } -// ResolveContainer indicates an expected call of ResolveContainer -func (mr *MockContainerMetadataResolverMockRecorder) ResolveContainer(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveContainer", reflect.TypeOf((*MockContainerMetadataResolver)(nil).ResolveContainer), arg0) +func (_mr *_MockContainerMetadataResolverRecorder) ResolveContainer(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ResolveContainer", arg0) } -// ResolveTask mocks base method -func (m *MockContainerMetadataResolver) ResolveTask(arg0 string) (*api.Task, error) { - ret := m.ctrl.Call(m, "ResolveTask", arg0) +func (_m *MockContainerMetadataResolver) ResolveTask(_param0 string) (*api.Task, error) { + ret := _m.ctrl.Call(_m, "ResolveTask", _param0) ret0, _ := ret[0].(*api.Task) ret1, _ := ret[1].(error) return ret0, ret1 } -// ResolveTask indicates an expected call of ResolveTask -func (mr *MockContainerMetadataResolverMockRecorder) ResolveTask(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveTask", reflect.TypeOf((*MockContainerMetadataResolver)(nil).ResolveTask), arg0) +func (_mr *_MockContainerMetadataResolverRecorder) ResolveTask(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ResolveTask", arg0) } diff --git a/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go index 163fd4164a7..88e928cd9e7 100644 --- a/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go +++ b/agent/utils/ioutilwrapper/mocks/ioutilwrapper_mocks.go @@ -11,51 +11,44 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/utils/ioutilwrapper (interfaces: IOUtil) -// Package mock_ioutilwrapper is a generated GoMock package. package mock_ioutilwrapper import ( - reflect "reflect" - oswrapper "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" gomock "github.com/golang/mock/gomock" ) -// MockIOUtil is a mock of IOUtil interface +// Mock of IOUtil interface type MockIOUtil struct { ctrl *gomock.Controller - recorder *MockIOUtilMockRecorder + recorder *_MockIOUtilRecorder } -// MockIOUtilMockRecorder is the mock recorder for MockIOUtil -type MockIOUtilMockRecorder struct { +// Recorder for MockIOUtil (not exported) +type _MockIOUtilRecorder struct { mock *MockIOUtil } -// NewMockIOUtil creates a new mock instance func NewMockIOUtil(ctrl *gomock.Controller) *MockIOUtil { mock := &MockIOUtil{ctrl: ctrl} - mock.recorder = &MockIOUtilMockRecorder{mock} + mock.recorder = &_MockIOUtilRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockIOUtil) EXPECT() *MockIOUtilMockRecorder { - return m.recorder +func (_m *MockIOUtil) EXPECT() *_MockIOUtilRecorder { + return _m.recorder } -// TempFile mocks base method -func (m *MockIOUtil) TempFile(arg0, arg1 string) (oswrapper.File, error) { - ret := m.ctrl.Call(m, "TempFile", arg0, arg1) +func (_m *MockIOUtil) TempFile(_param0 string, _param1 string) (oswrapper.File, error) { + ret := _m.ctrl.Call(_m, "TempFile", _param0, _param1) ret0, _ := ret[0].(oswrapper.File) ret1, _ := ret[1].(error) return ret0, ret1 } -// TempFile indicates an expected call of TempFile -func (mr *MockIOUtilMockRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TempFile", reflect.TypeOf((*MockIOUtil)(nil).TempFile), arg0, arg1) +func (_mr *_MockIOUtilRecorder) TempFile(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "TempFile", arg0, arg1) } diff --git a/agent/utils/mocks/utils_mocks.go b/agent/utils/mocks/utils_mocks.go index bcb83fccefc..1d7b8b26bdf 100644 --- a/agent/utils/mocks/utils_mocks.go +++ b/agent/utils/mocks/utils_mocks.go @@ -11,96 +11,84 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/utils (interfaces: LicenseProvider,Backoff) -// Package mock_utils is a generated GoMock package. package mock_utils import ( - reflect "reflect" time "time" gomock "github.com/golang/mock/gomock" ) -// MockLicenseProvider is a mock of LicenseProvider interface +// Mock of LicenseProvider interface type MockLicenseProvider struct { ctrl *gomock.Controller - recorder *MockLicenseProviderMockRecorder + recorder *_MockLicenseProviderRecorder } -// MockLicenseProviderMockRecorder is the mock recorder for MockLicenseProvider -type MockLicenseProviderMockRecorder struct { +// Recorder for MockLicenseProvider (not exported) +type _MockLicenseProviderRecorder struct { mock *MockLicenseProvider } -// NewMockLicenseProvider creates a new mock instance func NewMockLicenseProvider(ctrl *gomock.Controller) *MockLicenseProvider { mock := &MockLicenseProvider{ctrl: ctrl} - mock.recorder = &MockLicenseProviderMockRecorder{mock} + mock.recorder = &_MockLicenseProviderRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockLicenseProvider) EXPECT() *MockLicenseProviderMockRecorder { - return m.recorder +func (_m *MockLicenseProvider) EXPECT() *_MockLicenseProviderRecorder { + return _m.recorder } -// GetText mocks base method -func (m *MockLicenseProvider) GetText() (string, error) { - ret := m.ctrl.Call(m, "GetText") +func (_m *MockLicenseProvider) GetText() (string, error) { + ret := _m.ctrl.Call(_m, "GetText") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetText indicates an expected call of GetText -func (mr *MockLicenseProviderMockRecorder) GetText() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetText", reflect.TypeOf((*MockLicenseProvider)(nil).GetText)) +func (_mr *_MockLicenseProviderRecorder) GetText() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "GetText") } -// MockBackoff is a mock of Backoff interface +// Mock of Backoff interface type MockBackoff struct { ctrl *gomock.Controller - recorder *MockBackoffMockRecorder + recorder *_MockBackoffRecorder } -// MockBackoffMockRecorder is the mock recorder for MockBackoff -type MockBackoffMockRecorder struct { +// Recorder for MockBackoff (not exported) +type _MockBackoffRecorder struct { mock *MockBackoff } -// NewMockBackoff creates a new mock instance func NewMockBackoff(ctrl *gomock.Controller) *MockBackoff { mock := &MockBackoff{ctrl: ctrl} - mock.recorder = &MockBackoffMockRecorder{mock} + mock.recorder = &_MockBackoffRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockBackoff) EXPECT() *MockBackoffMockRecorder { - return m.recorder +func (_m *MockBackoff) EXPECT() *_MockBackoffRecorder { + return _m.recorder } -// Duration mocks base method -func (m *MockBackoff) Duration() time.Duration { - ret := m.ctrl.Call(m, "Duration") +func (_m *MockBackoff) Duration() time.Duration { + ret := _m.ctrl.Call(_m, "Duration") ret0, _ := ret[0].(time.Duration) return ret0 } -// Duration indicates an expected call of Duration -func (mr *MockBackoffMockRecorder) Duration() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Duration", reflect.TypeOf((*MockBackoff)(nil).Duration)) +func (_mr *_MockBackoffRecorder) Duration() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Duration") } -// Reset mocks base method -func (m *MockBackoff) Reset() { - m.ctrl.Call(m, "Reset") +func (_m *MockBackoff) Reset() { + _m.ctrl.Call(_m, "Reset") } -// Reset indicates an expected call of Reset -func (mr *MockBackoffMockRecorder) Reset() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockBackoff)(nil).Reset)) +func (_mr *_MockBackoffRecorder) Reset() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset") } diff --git a/agent/utils/oswrapper/mocks/oswrapper_mocks.go b/agent/utils/oswrapper/mocks/oswrapper_mocks.go index 163da2179af..d567e39566d 100644 --- a/agent/utils/oswrapper/mocks/oswrapper_mocks.go +++ b/agent/utils/oswrapper/mocks/oswrapper_mocks.go @@ -11,197 +11,169 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/utils/oswrapper (interfaces: File,OS) -// Package mock_oswrapper is a generated GoMock package. package mock_oswrapper import ( os "os" - reflect "reflect" oswrapper "github.com/aws/amazon-ecs-agent/agent/utils/oswrapper" gomock "github.com/golang/mock/gomock" ) -// MockFile is a mock of File interface +// Mock of File interface type MockFile struct { ctrl *gomock.Controller - recorder *MockFileMockRecorder + recorder *_MockFileRecorder } -// MockFileMockRecorder is the mock recorder for MockFile -type MockFileMockRecorder struct { +// Recorder for MockFile (not exported) +type _MockFileRecorder struct { mock *MockFile } -// NewMockFile creates a new mock instance func NewMockFile(ctrl *gomock.Controller) *MockFile { mock := &MockFile{ctrl: ctrl} - mock.recorder = &MockFileMockRecorder{mock} + mock.recorder = &_MockFileRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockFile) EXPECT() *MockFileMockRecorder { - return m.recorder +func (_m *MockFile) EXPECT() *_MockFileRecorder { + return _m.recorder } -// Chmod mocks base method -func (m *MockFile) Chmod(arg0 os.FileMode) error { - ret := m.ctrl.Call(m, "Chmod", arg0) +func (_m *MockFile) Chmod(_param0 os.FileMode) error { + ret := _m.ctrl.Call(_m, "Chmod", _param0) ret0, _ := ret[0].(error) return ret0 } -// Chmod indicates an expected call of Chmod -func (mr *MockFileMockRecorder) Chmod(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFile)(nil).Chmod), arg0) +func (_mr *_MockFileRecorder) Chmod(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Chmod", arg0) } -// Close mocks base method -func (m *MockFile) Close() error { - ret := m.ctrl.Call(m, "Close") +func (_m *MockFile) Close() error { + ret := _m.ctrl.Call(_m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close -func (mr *MockFileMockRecorder) Close() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFile)(nil).Close)) +func (_mr *_MockFileRecorder) Close() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") } -// Name mocks base method -func (m *MockFile) Name() string { - ret := m.ctrl.Call(m, "Name") +func (_m *MockFile) Name() string { + ret := _m.ctrl.Call(_m, "Name") ret0, _ := ret[0].(string) return ret0 } -// Name indicates an expected call of Name -func (mr *MockFileMockRecorder) Name() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFile)(nil).Name)) +func (_mr *_MockFileRecorder) Name() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Name") } -// Sync mocks base method -func (m *MockFile) Sync() error { - ret := m.ctrl.Call(m, "Sync") +func (_m *MockFile) Sync() error { + ret := _m.ctrl.Call(_m, "Sync") ret0, _ := ret[0].(error) return ret0 } -// Sync indicates an expected call of Sync -func (mr *MockFileMockRecorder) Sync() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockFile)(nil).Sync)) +func (_mr *_MockFileRecorder) Sync() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Sync") } -// Write mocks base method -func (m *MockFile) Write(arg0 []byte) (int, error) { - ret := m.ctrl.Call(m, "Write", arg0) +func (_m *MockFile) Write(_param0 []byte) (int, error) { + ret := _m.ctrl.Call(_m, "Write", _param0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) return ret0, ret1 } -// Write indicates an expected call of Write -func (mr *MockFileMockRecorder) Write(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockFile)(nil).Write), arg0) +func (_mr *_MockFileRecorder) Write(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0) } -// MockOS is a mock of OS interface +// Mock of OS interface type MockOS struct { ctrl *gomock.Controller - recorder *MockOSMockRecorder + recorder *_MockOSRecorder } -// MockOSMockRecorder is the mock recorder for MockOS -type MockOSMockRecorder struct { +// Recorder for MockOS (not exported) +type _MockOSRecorder struct { mock *MockOS } -// NewMockOS creates a new mock instance func NewMockOS(ctrl *gomock.Controller) *MockOS { mock := &MockOS{ctrl: ctrl} - mock.recorder = &MockOSMockRecorder{mock} + mock.recorder = &_MockOSRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockOS) EXPECT() *MockOSMockRecorder { - return m.recorder +func (_m *MockOS) EXPECT() *_MockOSRecorder { + return _m.recorder } -// Create mocks base method -func (m *MockOS) Create(arg0 string) (oswrapper.File, error) { - ret := m.ctrl.Call(m, "Create", arg0) +func (_m *MockOS) Create(_param0 string) (oswrapper.File, error) { + ret := _m.ctrl.Call(_m, "Create", _param0) ret0, _ := ret[0].(oswrapper.File) ret1, _ := ret[1].(error) return ret0, ret1 } -// Create indicates an expected call of Create -func (mr *MockOSMockRecorder) Create(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOS)(nil).Create), arg0) +func (_mr *_MockOSRecorder) Create(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0) } -// IsNotExist mocks base method -func (m *MockOS) IsNotExist(arg0 error) bool { - ret := m.ctrl.Call(m, "IsNotExist", arg0) +func (_m *MockOS) IsNotExist(_param0 error) bool { + ret := _m.ctrl.Call(_m, "IsNotExist", _param0) ret0, _ := ret[0].(bool) return ret0 } -// IsNotExist indicates an expected call of IsNotExist -func (mr *MockOSMockRecorder) IsNotExist(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNotExist", reflect.TypeOf((*MockOS)(nil).IsNotExist), arg0) +func (_mr *_MockOSRecorder) IsNotExist(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "IsNotExist", arg0) } -// MkdirAll mocks base method -func (m *MockOS) MkdirAll(arg0 string, arg1 os.FileMode) error { - ret := m.ctrl.Call(m, "MkdirAll", arg0, arg1) +func (_m *MockOS) MkdirAll(_param0 string, _param1 os.FileMode) error { + ret := _m.ctrl.Call(_m, "MkdirAll", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// MkdirAll indicates an expected call of MkdirAll -func (mr *MockOSMockRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockOS)(nil).MkdirAll), arg0, arg1) +func (_mr *_MockOSRecorder) MkdirAll(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "MkdirAll", arg0, arg1) } -// OpenFile mocks base method -func (m *MockOS) OpenFile(arg0 string, arg1 int, arg2 os.FileMode) (oswrapper.File, error) { - ret := m.ctrl.Call(m, "OpenFile", arg0, arg1, arg2) +func (_m *MockOS) OpenFile(_param0 string, _param1 int, _param2 os.FileMode) (oswrapper.File, error) { + ret := _m.ctrl.Call(_m, "OpenFile", _param0, _param1, _param2) ret0, _ := ret[0].(oswrapper.File) ret1, _ := ret[1].(error) return ret0, ret1 } -// OpenFile indicates an expected call of OpenFile -func (mr *MockOSMockRecorder) OpenFile(arg0, arg1, arg2 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenFile", reflect.TypeOf((*MockOS)(nil).OpenFile), arg0, arg1, arg2) +func (_mr *_MockOSRecorder) OpenFile(arg0, arg1, arg2 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "OpenFile", arg0, arg1, arg2) } -// RemoveAll mocks base method -func (m *MockOS) RemoveAll(arg0 string) error { - ret := m.ctrl.Call(m, "RemoveAll", arg0) +func (_m *MockOS) RemoveAll(_param0 string) error { + ret := _m.ctrl.Call(_m, "RemoveAll", _param0) ret0, _ := ret[0].(error) return ret0 } -// RemoveAll indicates an expected call of RemoveAll -func (mr *MockOSMockRecorder) RemoveAll(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAll", reflect.TypeOf((*MockOS)(nil).RemoveAll), arg0) +func (_mr *_MockOSRecorder) RemoveAll(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveAll", arg0) } -// Rename mocks base method -func (m *MockOS) Rename(arg0, arg1 string) error { - ret := m.ctrl.Call(m, "Rename", arg0, arg1) +func (_m *MockOS) Rename(_param0 string, _param1 string) error { + ret := _m.ctrl.Call(_m, "Rename", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } -// Rename indicates an expected call of Rename -func (mr *MockOSMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockOS)(nil).Rename), arg0, arg1) +func (_mr *_MockOSRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Rename", arg0, arg1) } diff --git a/agent/utils/ttime/mocks/time_mocks.go b/agent/utils/ttime/mocks/time_mocks.go index 9f970652adb..3a2b1ae88e5 100644 --- a/agent/utils/ttime/mocks/time_mocks.go +++ b/agent/utils/ttime/mocks/time_mocks.go @@ -11,132 +11,114 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/utils/ttime (interfaces: Time,Timer) -// Package mock_ttime is a generated GoMock package. package mock_ttime import ( - reflect "reflect" time "time" ttime "github.com/aws/amazon-ecs-agent/agent/utils/ttime" gomock "github.com/golang/mock/gomock" ) -// MockTime is a mock of Time interface +// Mock of Time interface type MockTime struct { ctrl *gomock.Controller - recorder *MockTimeMockRecorder + recorder *_MockTimeRecorder } -// MockTimeMockRecorder is the mock recorder for MockTime -type MockTimeMockRecorder struct { +// Recorder for MockTime (not exported) +type _MockTimeRecorder struct { mock *MockTime } -// NewMockTime creates a new mock instance func NewMockTime(ctrl *gomock.Controller) *MockTime { mock := &MockTime{ctrl: ctrl} - mock.recorder = &MockTimeMockRecorder{mock} + mock.recorder = &_MockTimeRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTime) EXPECT() *MockTimeMockRecorder { - return m.recorder +func (_m *MockTime) EXPECT() *_MockTimeRecorder { + return _m.recorder } -// After mocks base method -func (m *MockTime) After(arg0 time.Duration) <-chan time.Time { - ret := m.ctrl.Call(m, "After", arg0) +func (_m *MockTime) After(_param0 time.Duration) <-chan time.Time { + ret := _m.ctrl.Call(_m, "After", _param0) ret0, _ := ret[0].(<-chan time.Time) return ret0 } -// After indicates an expected call of After -func (mr *MockTimeMockRecorder) After(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "After", reflect.TypeOf((*MockTime)(nil).After), arg0) +func (_mr *_MockTimeRecorder) After(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "After", arg0) } -// AfterFunc mocks base method -func (m *MockTime) AfterFunc(arg0 time.Duration, arg1 func()) ttime.Timer { - ret := m.ctrl.Call(m, "AfterFunc", arg0, arg1) +func (_m *MockTime) AfterFunc(_param0 time.Duration, _param1 func()) ttime.Timer { + ret := _m.ctrl.Call(_m, "AfterFunc", _param0, _param1) ret0, _ := ret[0].(ttime.Timer) return ret0 } -// AfterFunc indicates an expected call of AfterFunc -func (mr *MockTimeMockRecorder) AfterFunc(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AfterFunc", reflect.TypeOf((*MockTime)(nil).AfterFunc), arg0, arg1) +func (_mr *_MockTimeRecorder) AfterFunc(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AfterFunc", arg0, arg1) } -// Now mocks base method -func (m *MockTime) Now() time.Time { - ret := m.ctrl.Call(m, "Now") +func (_m *MockTime) Now() time.Time { + ret := _m.ctrl.Call(_m, "Now") ret0, _ := ret[0].(time.Time) return ret0 } -// Now indicates an expected call of Now -func (mr *MockTimeMockRecorder) Now() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Now", reflect.TypeOf((*MockTime)(nil).Now)) +func (_mr *_MockTimeRecorder) Now() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Now") } -// Sleep mocks base method -func (m *MockTime) Sleep(arg0 time.Duration) { - m.ctrl.Call(m, "Sleep", arg0) +func (_m *MockTime) Sleep(_param0 time.Duration) { + _m.ctrl.Call(_m, "Sleep", _param0) } -// Sleep indicates an expected call of Sleep -func (mr *MockTimeMockRecorder) Sleep(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sleep", reflect.TypeOf((*MockTime)(nil).Sleep), arg0) +func (_mr *_MockTimeRecorder) Sleep(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Sleep", arg0) } -// MockTimer is a mock of Timer interface +// Mock of Timer interface type MockTimer struct { ctrl *gomock.Controller - recorder *MockTimerMockRecorder + recorder *_MockTimerRecorder } -// MockTimerMockRecorder is the mock recorder for MockTimer -type MockTimerMockRecorder struct { +// Recorder for MockTimer (not exported) +type _MockTimerRecorder struct { mock *MockTimer } -// NewMockTimer creates a new mock instance func NewMockTimer(ctrl *gomock.Controller) *MockTimer { mock := &MockTimer{ctrl: ctrl} - mock.recorder = &MockTimerMockRecorder{mock} + mock.recorder = &_MockTimerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockTimer) EXPECT() *MockTimerMockRecorder { - return m.recorder +func (_m *MockTimer) EXPECT() *_MockTimerRecorder { + return _m.recorder } -// Reset mocks base method -func (m *MockTimer) Reset(arg0 time.Duration) bool { - ret := m.ctrl.Call(m, "Reset", arg0) +func (_m *MockTimer) Reset(_param0 time.Duration) bool { + ret := _m.ctrl.Call(_m, "Reset", _param0) ret0, _ := ret[0].(bool) return ret0 } -// Reset indicates an expected call of Reset -func (mr *MockTimerMockRecorder) Reset(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTimer)(nil).Reset), arg0) +func (_mr *_MockTimerRecorder) Reset(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset", arg0) } -// Stop mocks base method -func (m *MockTimer) Stop() bool { - ret := m.ctrl.Call(m, "Stop") +func (_m *MockTimer) Stop() bool { + ret := _m.ctrl.Call(_m, "Stop") ret0, _ := ret[0].(bool) return ret0 } -// Stop indicates an expected call of Stop -func (mr *MockTimerMockRecorder) Stop() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockTimer)(nil).Stop)) +func (_mr *_MockTimerRecorder) Stop() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Stop") } diff --git a/agent/wsclient/mock/client.go b/agent/wsclient/mock/client.go index 65b66db374d..e49ea719ca4 100644 --- a/agent/wsclient/mock/client.go +++ b/agent/wsclient/mock/client.go @@ -11,147 +11,125 @@ // express or implied. See the License for the specific language governing // permissions and limitations under the License. -// Code generated by MockGen. DO NOT EDIT. +// Automatically generated by MockGen. DO NOT EDIT! // Source: github.com/aws/amazon-ecs-agent/agent/wsclient (interfaces: ClientServer,WebsocketConn) -// Package mock_wsclient is a generated GoMock package. package mock_wsclient import ( - reflect "reflect" time "time" wsclient "github.com/aws/amazon-ecs-agent/agent/wsclient" gomock "github.com/golang/mock/gomock" ) -// MockClientServer is a mock of ClientServer interface +// Mock of ClientServer interface type MockClientServer struct { ctrl *gomock.Controller - recorder *MockClientServerMockRecorder + recorder *_MockClientServerRecorder } -// MockClientServerMockRecorder is the mock recorder for MockClientServer -type MockClientServerMockRecorder struct { +// Recorder for MockClientServer (not exported) +type _MockClientServerRecorder struct { mock *MockClientServer } -// NewMockClientServer creates a new mock instance func NewMockClientServer(ctrl *gomock.Controller) *MockClientServer { mock := &MockClientServer{ctrl: ctrl} - mock.recorder = &MockClientServerMockRecorder{mock} + mock.recorder = &_MockClientServerRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockClientServer) EXPECT() *MockClientServerMockRecorder { - return m.recorder +func (_m *MockClientServer) EXPECT() *_MockClientServerRecorder { + return _m.recorder } -// AddRequestHandler mocks base method -func (m *MockClientServer) AddRequestHandler(arg0 wsclient.RequestHandler) { - m.ctrl.Call(m, "AddRequestHandler", arg0) +func (_m *MockClientServer) AddRequestHandler(_param0 wsclient.RequestHandler) { + _m.ctrl.Call(_m, "AddRequestHandler", _param0) } -// AddRequestHandler indicates an expected call of AddRequestHandler -func (mr *MockClientServerMockRecorder) AddRequestHandler(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRequestHandler", reflect.TypeOf((*MockClientServer)(nil).AddRequestHandler), arg0) +func (_mr *_MockClientServerRecorder) AddRequestHandler(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "AddRequestHandler", arg0) } -// Close mocks base method -func (m *MockClientServer) Close() error { - ret := m.ctrl.Call(m, "Close") +func (_m *MockClientServer) Close() error { + ret := _m.ctrl.Call(_m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close -func (mr *MockClientServerMockRecorder) Close() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClientServer)(nil).Close)) +func (_mr *_MockClientServerRecorder) Close() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") } -// Connect mocks base method -func (m *MockClientServer) Connect() error { - ret := m.ctrl.Call(m, "Connect") +func (_m *MockClientServer) Connect() error { + ret := _m.ctrl.Call(_m, "Connect") ret0, _ := ret[0].(error) return ret0 } -// Connect indicates an expected call of Connect -func (mr *MockClientServerMockRecorder) Connect() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockClientServer)(nil).Connect)) +func (_mr *_MockClientServerRecorder) Connect() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Connect") } -// Disconnect mocks base method -func (m *MockClientServer) Disconnect(arg0 ...interface{}) error { - varargs := []interface{}{} - for _, a := range arg0 { - varargs = append(varargs, a) +func (_m *MockClientServer) Disconnect(_param0 ...interface{}) error { + _s := []interface{}{} + for _, _x := range _param0 { + _s = append(_s, _x) } - ret := m.ctrl.Call(m, "Disconnect", varargs...) + ret := _m.ctrl.Call(_m, "Disconnect", _s...) ret0, _ := ret[0].(error) return ret0 } -// Disconnect indicates an expected call of Disconnect -func (mr *MockClientServerMockRecorder) Disconnect(arg0 ...interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disconnect", reflect.TypeOf((*MockClientServer)(nil).Disconnect), arg0...) +func (_mr *_MockClientServerRecorder) Disconnect(arg0 ...interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Disconnect", arg0...) } -// IsConnected mocks base method -func (m *MockClientServer) IsConnected() bool { - ret := m.ctrl.Call(m, "IsConnected") +func (_m *MockClientServer) IsConnected() bool { + ret := _m.ctrl.Call(_m, "IsConnected") ret0, _ := ret[0].(bool) return ret0 } -// IsConnected indicates an expected call of IsConnected -func (mr *MockClientServerMockRecorder) IsConnected() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockClientServer)(nil).IsConnected)) +func (_mr *_MockClientServerRecorder) IsConnected() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "IsConnected") } -// MakeRequest mocks base method -func (m *MockClientServer) MakeRequest(arg0 interface{}) error { - ret := m.ctrl.Call(m, "MakeRequest", arg0) +func (_m *MockClientServer) MakeRequest(_param0 interface{}) error { + ret := _m.ctrl.Call(_m, "MakeRequest", _param0) ret0, _ := ret[0].(error) return ret0 } -// MakeRequest indicates an expected call of MakeRequest -func (mr *MockClientServerMockRecorder) MakeRequest(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeRequest", reflect.TypeOf((*MockClientServer)(nil).MakeRequest), arg0) +func (_mr *_MockClientServerRecorder) MakeRequest(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "MakeRequest", arg0) } -// Serve mocks base method -func (m *MockClientServer) Serve() error { - ret := m.ctrl.Call(m, "Serve") +func (_m *MockClientServer) Serve() error { + ret := _m.ctrl.Call(_m, "Serve") ret0, _ := ret[0].(error) return ret0 } -// Serve indicates an expected call of Serve -func (mr *MockClientServerMockRecorder) Serve() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Serve", reflect.TypeOf((*MockClientServer)(nil).Serve)) +func (_mr *_MockClientServerRecorder) Serve() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Serve") } -// SetAnyRequestHandler mocks base method -func (m *MockClientServer) SetAnyRequestHandler(arg0 wsclient.RequestHandler) { - m.ctrl.Call(m, "SetAnyRequestHandler", arg0) +func (_m *MockClientServer) SetAnyRequestHandler(_param0 wsclient.RequestHandler) { + _m.ctrl.Call(_m, "SetAnyRequestHandler", _param0) } -// SetAnyRequestHandler indicates an expected call of SetAnyRequestHandler -func (mr *MockClientServerMockRecorder) SetAnyRequestHandler(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAnyRequestHandler", reflect.TypeOf((*MockClientServer)(nil).SetAnyRequestHandler), arg0) +func (_mr *_MockClientServerRecorder) SetAnyRequestHandler(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetAnyRequestHandler", arg0) } -// SetConnection mocks base method -func (m *MockClientServer) SetConnection(arg0 wsclient.WebsocketConn) { - m.ctrl.Call(m, "SetConnection", arg0) +func (_m *MockClientServer) SetConnection(_param0 wsclient.WebsocketConn) { + _m.ctrl.Call(_m, "SetConnection", _param0) } -// SetConnection indicates an expected call of SetConnection -func (mr *MockClientServerMockRecorder) SetConnection(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConnection", reflect.TypeOf((*MockClientServer)(nil).SetConnection), arg0) +func (_mr *_MockClientServerRecorder) SetConnection(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "SetConnection", arg0) } func (_m *MockClientServer) SetReadDeadline(_param0 time.Time) error { @@ -170,58 +148,51 @@ func (_m *MockClientServer) WriteMessage(_param0 []byte) error { return ret0 } -// WriteMessage indicates an expected call of WriteMessage -func (mr *MockClientServerMockRecorder) WriteMessage(arg0 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMessage", reflect.TypeOf((*MockClientServer)(nil).WriteMessage), arg0) +func (_mr *_MockClientServerRecorder) WriteMessage(arg0 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessage", arg0) } -// MockWebsocketConn is a mock of WebsocketConn interface +// Mock of WebsocketConn interface type MockWebsocketConn struct { ctrl *gomock.Controller - recorder *MockWebsocketConnMockRecorder + recorder *_MockWebsocketConnRecorder } -// MockWebsocketConnMockRecorder is the mock recorder for MockWebsocketConn -type MockWebsocketConnMockRecorder struct { +// Recorder for MockWebsocketConn (not exported) +type _MockWebsocketConnRecorder struct { mock *MockWebsocketConn } -// NewMockWebsocketConn creates a new mock instance func NewMockWebsocketConn(ctrl *gomock.Controller) *MockWebsocketConn { mock := &MockWebsocketConn{ctrl: ctrl} - mock.recorder = &MockWebsocketConnMockRecorder{mock} + mock.recorder = &_MockWebsocketConnRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockWebsocketConn) EXPECT() *MockWebsocketConnMockRecorder { - return m.recorder +func (_m *MockWebsocketConn) EXPECT() *_MockWebsocketConnRecorder { + return _m.recorder } -// Close mocks base method -func (m *MockWebsocketConn) Close() error { - ret := m.ctrl.Call(m, "Close") +func (_m *MockWebsocketConn) Close() error { + ret := _m.ctrl.Call(_m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close -func (mr *MockWebsocketConnMockRecorder) Close() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockWebsocketConn)(nil).Close)) +func (_mr *_MockWebsocketConnRecorder) Close() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "Close") } -// ReadMessage mocks base method -func (m *MockWebsocketConn) ReadMessage() (int, []byte, error) { - ret := m.ctrl.Call(m, "ReadMessage") +func (_m *MockWebsocketConn) ReadMessage() (int, []byte, error) { + ret := _m.ctrl.Call(_m, "ReadMessage") ret0, _ := ret[0].(int) ret1, _ := ret[1].([]byte) ret2, _ := ret[2].(error) return ret0, ret1, ret2 } -// ReadMessage indicates an expected call of ReadMessage -func (mr *MockWebsocketConnMockRecorder) ReadMessage() *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessage", reflect.TypeOf((*MockWebsocketConn)(nil).ReadMessage)) +func (_mr *_MockWebsocketConnRecorder) ReadMessage() *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessage") } func (_m *MockWebsocketConn) SetReadDeadline(_param0 time.Time) error { @@ -250,7 +221,6 @@ func (_m *MockWebsocketConn) WriteMessage(_param0 int, _param1 []byte) error { return ret0 } -// WriteMessage indicates an expected call of WriteMessage -func (mr *MockWebsocketConnMockRecorder) WriteMessage(arg0, arg1 interface{}) *gomock.Call { - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMessage", reflect.TypeOf((*MockWebsocketConn)(nil).WriteMessage), arg0, arg1) +func (_mr *_MockWebsocketConnRecorder) WriteMessage(arg0, arg1 interface{}) *gomock.Call { + return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessage", arg0, arg1) } From 508d9e53e898fd5e4aff39044c06e6d640dd15ce Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Wed, 4 Oct 2017 14:42:28 -0700 Subject: [PATCH 14/58] containermetadata: extract duplicated parsing code --- agent/containermetadata/manager.go | 30 ++++++++++++------- .../containermetadata/write_metadata_unix.go | 3 +- 2 files changed, 21 insertions(+), 12 deletions(-) diff --git a/agent/containermetadata/manager.go b/agent/containermetadata/manager.go index 5dcb543db81..10efec463c5 100644 --- a/agent/containermetadata/manager.go +++ b/agent/containermetadata/manager.go @@ -114,13 +114,7 @@ func (manager *metadataManager) Create(config *docker.Config, hostConfig *docker // Acquire the metadata then write it in JSON format to the file metadata := manager.parseMetadataAtContainerCreate(taskARN, containerName) - data, err := json.MarshalIndent(metadata, "", "\t") - if err != nil { - return fmt.Errorf("create metadata for task %s container %s: %v", taskARN, containerName, err) - } - - // Write the metadata to file - err = writeToMetadataFile(manager.osWrap, manager.ioutilWrap, data, taskARN, containerName, manager.dataDir) + err = manager.marshalAndWrite(metadata, taskARN, containerName) if err != nil { return err } @@ -148,12 +142,11 @@ func (manager *metadataManager) Update(dockerID string, taskARN string, containe // Acquire the metadata then write it in JSON format to the file metadata := manager.parseMetadata(dockerContainer, taskARN, containerName) - data, err := json.MarshalIndent(metadata, "", "\t") + err = manager.marshalAndWrite(metadata, taskARN, containerName) if err != nil { - return fmt.Errorf("update metadata for task %s container %s: %v", taskARN, containerName, err) + return err } - - return writeToMetadataFile(manager.osWrap, manager.ioutilWrap, data, taskARN, containerName, manager.dataDir) + return nil } // Clean removes the metadata files of all containers associated with a task @@ -164,3 +157,18 @@ func (manager *metadataManager) Clean(taskARN string) error { } return manager.osWrap.RemoveAll(metadataPath) } + +func (manager *metadataManager) marshalAndWrite(metadata Metadata, taskARN string, containerName string) error { + data, err := json.MarshalIndent(metadata, "", "\t") + if err != nil { + return fmt.Errorf("create metadata for task %s container %s: %v", taskARN, containerName, err) + } + + // Write the metadata to file + err = writeToMetadataFile(manager.osWrap, manager.ioutilWrap, data, taskARN, containerName, manager.dataDir) + if err != nil { + return err + } + + return nil +} diff --git a/agent/containermetadata/write_metadata_unix.go b/agent/containermetadata/write_metadata_unix.go index bce4e046146..d629524bca4 100644 --- a/agent/containermetadata/write_metadata_unix.go +++ b/agent/containermetadata/write_metadata_unix.go @@ -27,6 +27,7 @@ import ( const ( mountPoint = "/opt/ecs/metadata" + tempFile = "temp_metadata_file" ) // createBindsEnv will do the appropriate formatting to add a new mount in a container's HostConfig @@ -51,7 +52,7 @@ func writeToMetadataFile(osWrap oswrapper.OS, ioutilWrap ioutilwrapper.IOUtil, d } metadataFileName := filepath.Join(metadataFileDir, metadataFile) - temp, err := ioutilWrap.TempFile(metadataFileDir, "temp_metadata_file") + temp, err := ioutilWrap.TempFile(metadataFileDir, tempFile) if err != nil { return err } From a50aad7cc8aa2d2ad747c6b7218c366494241528 Mon Sep 17 00:00:00 2001 From: Goodhart Date: Thu, 7 Sep 2017 14:48:05 -0700 Subject: [PATCH 15/58] Do not explicitly set host IP to 0.0.0.0 for Linux, defer to Docker ---* Motivation *--- By hardcoding the host IP as 0.0.0.0, the agent is removing the ability for customers to specify specific host IP addresses (such as when there are multiple network interfaces). By default, the docker daemon defaults to 0.0.0.0, but this value may be overridden by launching the daemon with a --ip flag. https://docs.docker.com/engine/reference/commandline/dockerd/ This also has an implication for the CloudWatch Events published by ECS. Specifically, prior to this change the 'bindIP' field in the ECS Task Status events always contains '0.0.0.0'. This change will benefit the following customer use cases: * https://github.com/aws/amazon-ecs-agent/issues/426 * https://forums.aws.amazon.com/thread.jspa?threadID=173250 * https://serverfault.com/questions/695393/amazon-ecs-docker-binding-container-to-specific-ip-address ---* Detailed Description *--- Do not explicitly set the HostIP property when starting containers and instead defer to the daemon's default. --- agent/api/task.go | 4 ++-- agent/api/task_test.go | 2 -- agent/api/task_unix.go | 2 -- agent/api/task_windows.go | 2 -- 4 files changed, 2 insertions(+), 8 deletions(-) diff --git a/agent/api/task.go b/agent/api/task.go index 2ecbb8afbb8..21ea21e43f5 100644 --- a/agent/api/task.go +++ b/agent/api/task.go @@ -624,9 +624,9 @@ func (task *Task) dockerPortMap(container *Container) map[docker.Port][]docker.P dockerPort := docker.Port(strconv.Itoa(int(portBinding.ContainerPort)) + "/" + portBinding.Protocol.String()) currentMappings, existing := dockerPortMap[dockerPort] if existing { - dockerPortMap[dockerPort] = append(currentMappings, docker.PortBinding{HostIP: portBindingHostIP, HostPort: strconv.Itoa(int(portBinding.HostPort))}) + dockerPortMap[dockerPort] = append(currentMappings, docker.PortBinding{HostPort: strconv.Itoa(int(portBinding.HostPort))}) } else { - dockerPortMap[dockerPort] = []docker.PortBinding{{HostIP: portBindingHostIP, HostPort: strconv.Itoa(int(portBinding.HostPort))}} + dockerPortMap[dockerPort] = []docker.PortBinding{{HostPort: strconv.Itoa(int(portBinding.HostPort))}} } } return dockerPortMap diff --git a/agent/api/task_test.go b/agent/api/task_test.go index 9369bd48682..48d9688cc85 100644 --- a/agent/api/task_test.go +++ b/agent/api/task_test.go @@ -158,13 +158,11 @@ func TestDockerHostConfigPortBinding(t *testing.T) { assert.True(t, ok, "Could not get port bindings") assert.Equal(t, 1, len(bindings), "Wrong number of bindings") assert.Equal(t, "10", bindings[0].HostPort, "Wrong hostport") - assert.Equal(t, portBindingHostIP, bindings[0].HostIP, "Wrong hostIP") bindings, ok = config.PortBindings["20/udp"] assert.True(t, ok, "Could not get port bindings") assert.Equal(t, 1, len(bindings), "Wrong number of bindings") assert.Equal(t, "20", bindings[0].HostPort, "Wrong hostport") - assert.Equal(t, portBindingHostIP, bindings[0].HostIP, "Wrong hostIP") } func TestDockerHostConfigVolumesFrom(t *testing.T) { diff --git a/agent/api/task_unix.go b/agent/api/task_unix.go index 68bfcf56d49..8fe1ca1101a 100644 --- a/agent/api/task_unix.go +++ b/agent/api/task_unix.go @@ -20,8 +20,6 @@ import ( ) const ( - portBindingHostIP = "0.0.0.0" - //memorySwappinessDefault is the expected default value for this platform. This is used in task_windows.go //and is maintained here for unix default. Also used for testing memorySwappinessDefault = 0 diff --git a/agent/api/task_windows.go b/agent/api/task_windows.go index 92d9ea8bf9c..8755115694f 100644 --- a/agent/api/task_windows.go +++ b/agent/api/task_windows.go @@ -23,8 +23,6 @@ import ( ) const ( - portBindingHostIP = "" - //memorySwappinessDefault is the expected default value for this platform memorySwappinessDefault = -1 ) From de5fa33a47c2aba2058f437ebe65dfb2a785cd64 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Thu, 5 Oct 2017 11:18:26 -0700 Subject: [PATCH 16/58] containermetadata: use iotas for status --- agent/containermetadata/manager.go | 15 ------ .../containermetadata/parse_metadata_test.go | 28 +++++++--- agent/containermetadata/types.go | 51 +++++++++++++++++++ agent/engine/docker_task_engine.go | 2 +- 4 files changed, 73 insertions(+), 23 deletions(-) diff --git a/agent/containermetadata/manager.go b/agent/containermetadata/manager.go index 10efec463c5..534b38b4d86 100644 --- a/agent/containermetadata/manager.go +++ b/agent/containermetadata/manager.go @@ -31,23 +31,8 @@ const ( inspectContainerTimeout = 30 * time.Second metadataFile = "ecs-container-metadata.json" metadataPerm = 0644 - // MetadataInitial is the initial state of the metadata file which - // contains metadata provided by the ECS Agent - MetadataInitial = "INITIAL" - // MetadataReady is the final state of the metadata file which indicates - // it has acquired all the data it needs (Currently from the Agent and Docker) - MetadataReady = "READY" ) -// MetadataStatus specifies the current update status of the metadata file. -// The purpose of this status is for users to check if the metadata file has -// reached the stage they need before they read the rest of the file to avoid -// race conditions (Since the final stage will need to be after the container -// starts up -// In the future the metadata may require multiple stages of update and these -// statuses should amended/appended accordingly. -type MetadataStatus string - // Manager is an interface that allows us to abstract away the metadata // operations type Manager interface { diff --git a/agent/containermetadata/parse_metadata_test.go b/agent/containermetadata/parse_metadata_test.go index bd75ad8754f..34f261a998d 100644 --- a/agent/containermetadata/parse_metadata_test.go +++ b/agent/containermetadata/parse_metadata_test.go @@ -32,6 +32,8 @@ func TestParseContainerCreate(t *testing.T) { mockCluster := cluster mockContainerInstanceARN := containerInstanceARN + expectedStatus := string(MetadataInitial) + newManager := &metadataManager{ cluster: mockCluster, containerInstanceARN: mockContainerInstanceARN, @@ -42,7 +44,7 @@ func TestParseContainerCreate(t *testing.T) { assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) - assert.Equal(t, string(metadata.metadataStatus), "INITIAL", "Expected status "+MetadataInitial) + assert.Equal(t, string(metadata.metadataStatus), expectedStatus, "Expected status "+expectedStatus) } func TestParseHasNoContainer(t *testing.T) { @@ -51,6 +53,8 @@ func TestParseHasNoContainer(t *testing.T) { mockCluster := cluster mockContainerInstanceARN := containerInstanceARN + expectedStatus := string(MetadataReady) + newManager := &metadataManager{ cluster: mockCluster, containerInstanceARN: mockContainerInstanceARN, @@ -61,7 +65,7 @@ func TestParseHasNoContainer(t *testing.T) { assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) - assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, string(metadata.metadataStatus), expectedStatus, "Expected status "+expectedStatus) assert.Equal(t, metadata.dockerContainerMetadata.containerID, "", "Expected empty container metadata") assert.Equal(t, metadata.dockerContainerMetadata.dockerContainerName, "", "Expected empty container metadata") assert.Equal(t, metadata.dockerContainerMetadata.imageID, "", "Expected empty container metadata") @@ -77,6 +81,8 @@ func TestParseHasConfig(t *testing.T) { mockConfig := &docker.Config{Image: "image"} mockContainer := &docker.Container{Config: mockConfig} + expectedStatus := string(MetadataReady) + newManager := &metadataManager{ cluster: mockCluster, containerInstanceARN: mockContainerInstanceARN, @@ -87,7 +93,7 @@ func TestParseHasConfig(t *testing.T) { assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) - assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, string(metadata.metadataStatus), expectedStatus, "Expected status "+expectedStatus) assert.Equal(t, metadata.dockerContainerMetadata.imageName, "image", "Expected nonempty imageID") } @@ -104,6 +110,8 @@ func TestParseHasHostConfigPortBindsError(t *testing.T) { mockHostConfig := &docker.HostConfig{PortBindings: mockPorts} mockContainer := &docker.Container{HostConfig: mockHostConfig} + expectedStatus := string(MetadataReady) + newManager := &metadataManager{ cluster: mockCluster, containerInstanceARN: mockContainerInstanceARN, @@ -114,7 +122,7 @@ func TestParseHasHostConfigPortBindsError(t *testing.T) { assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) - assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, string(metadata.metadataStatus), expectedStatus, "Expected status "+expectedStatus) assert.Equal(t, len(metadata.dockerContainerMetadata.ports), 0, "Expected empty list of ports") } @@ -131,6 +139,8 @@ func TestParseHasHostConfigPortBindsNoError(t *testing.T) { mockHostConfig := &docker.HostConfig{PortBindings: mockPorts} mockContainer := &docker.Container{HostConfig: mockHostConfig} + expectedStatus := string(MetadataReady) + newManager := &metadataManager{ cluster: mockCluster, containerInstanceARN: mockContainerInstanceARN, @@ -141,7 +151,7 @@ func TestParseHasHostConfigPortBindsNoError(t *testing.T) { assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) - assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, string(metadata.metadataStatus), expectedStatus, "Expected status "+expectedStatus) assert.Equal(t, len(metadata.dockerContainerMetadata.ports), 1, "Expected empty list of ports") } @@ -155,6 +165,8 @@ func TestParseHasNetworkSettingsNetworksEmpty(t *testing.T) { mockNetworkSettings := &docker.NetworkSettings{IPAddress: "0.0.0.0"} mockContainer := &docker.Container{HostConfig: mockHostConfig, NetworkSettings: mockNetworkSettings} + expectedStatus := string(MetadataReady) + newManager := &metadataManager{ cluster: mockCluster, containerInstanceARN: mockContainerInstanceARN, @@ -165,7 +177,7 @@ func TestParseHasNetworkSettingsNetworksEmpty(t *testing.T) { assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) - assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, string(metadata.metadataStatus), expectedStatus, "Expected status "+expectedStatus) assert.Equal(t, len(metadata.dockerContainerMetadata.networkInfo.networks), 1, "Expected one network") } @@ -182,6 +194,8 @@ func TestParseHasNetworkSettingsNetworksNonEmpty(t *testing.T) { mockNetworkSettings := &docker.NetworkSettings{Networks: mockNetworks} mockContainer := &docker.Container{HostConfig: mockHostConfig, NetworkSettings: mockNetworkSettings} + expectedStatus := string(MetadataReady) + newManager := &metadataManager{ cluster: mockCluster, containerInstanceARN: mockContainerInstanceARN, @@ -192,6 +206,6 @@ func TestParseHasNetworkSettingsNetworksNonEmpty(t *testing.T) { assert.Equal(t, metadata.taskMetadata.containerName, mockContainerName, "Expcted container name "+mockContainerName) assert.Equal(t, metadata.taskMetadata.taskARN, mockTaskARN, "Expcted task ARN "+mockTaskARN) assert.Equal(t, metadata.containerInstanceARN, mockContainerInstanceARN, "Expcted container instance ARN "+mockContainerInstanceARN) - assert.Equal(t, string(metadata.metadataStatus), "READY", "Expected status "+MetadataInitial) + assert.Equal(t, string(metadata.metadataStatus), expectedStatus, "Expected status "+expectedStatus) assert.Equal(t, len(metadata.dockerContainerMetadata.networkInfo.networks), 2, "Expected two networks") } diff --git a/agent/containermetadata/types.go b/agent/containermetadata/types.go index 01a3baa7a8b..de960f05424 100644 --- a/agent/containermetadata/types.go +++ b/agent/containermetadata/types.go @@ -15,6 +15,7 @@ package containermetadata import ( "encoding/json" + "fmt" "time" "github.com/aws/amazon-ecs-agent/agent/api" @@ -22,6 +23,56 @@ import ( docker "github.com/fsouza/go-dockerclient" ) +const ( + // MetadataInitial is the initial state of the metadata file which + // contains metadata provided by the ECS Agent + MetadataInitialText = "INITIAL" + // MetadataReady is the final state of the metadata file which indicates + // it has acquired all the data it needs (Currently from the Agent and Docker) + MetadataReadyText = "READY" +) + +const ( + MetadataInitial MetadataStatus = iota + MetadataReady +) + +// MetadataStatus specifies the current update status of the metadata file. +// The purpose of this status is for users to check if the metadata file has +// reached the stage they need before they read the rest of the file to avoid +// race conditions (Since the final stage will need to be after the container +// starts up +// In the future the metadata may require multiple stages of update and these +// statuses should amended/appended accordingly. +type MetadataStatus int32 + +func (status MetadataStatus) MarshalText() (text []byte, err error) { + switch status { + case MetadataInitial: + text = []byte(MetadataInitialText) + case MetadataReady: + text = []byte(MetadataReadyText) + default: + return nil, fmt.Errorf("failed marshalling MetadataStatus %v", status) + } + return +} + +func (status *MetadataStatus) UnmarshalText(text []byte) error { + var err error + t := string(text) + + switch t { + case MetadataInitialText: + *status = MetadataInitial + case MetadataReadyText: + *status = MetadataReady + default: + return fmt.Errorf("failed unmarshalling MetadataStatus %s", text) + } + return err +} + // DockerMetadataClient is a wrapper for the docker interface functions we need // We use this as a dummy type to be able to pass in engine.DockerClient to // our functions without creating import cycles diff --git a/agent/engine/docker_task_engine.go b/agent/engine/docker_task_engine.go index e200598ff1c..9f1e051031e 100644 --- a/agent/engine/docker_task_engine.go +++ b/agent/engine/docker_task_engine.go @@ -343,7 +343,7 @@ func (engine *DockerTaskEngine) sweepTask(task *api.Task) { if engine.cfg.ContainerMetadataEnabled { err := engine.metadataManager.Clean(task.Arn) if err != nil { - seelog.Warnf("Clean task metadata failed for task %s: %v", task, err) + seelog.Warnf("Clean task metadata failed for task %s: %v", task.Arn, err) } } engine.saver.Save() From d5146c595e2aba4cc7d3f2ea48d21f9328171407 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Fri, 6 Oct 2017 12:16:19 -0700 Subject: [PATCH 17/58] engine: fix windows test to include metedata mock --- agent/engine/docker_task_engine_windows_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/agent/engine/docker_task_engine_windows_test.go b/agent/engine/docker_task_engine_windows_test.go index 3d3897365da..0811e59a808 100644 --- a/agent/engine/docker_task_engine_windows_test.go +++ b/agent/engine/docker_task_engine_windows_test.go @@ -26,7 +26,7 @@ import ( ) func TestPullEmptyVolumeImage(t *testing.T) { - ctrl, client, _, privateTaskEngine, _, _ := mocks(t, &config.Config{}) + ctrl, client, _, privateTaskEngine, _, _, _ := mocks(t, &config.Config{}) defer ctrl.Finish() taskEngine, _ := privateTaskEngine.(*DockerTaskEngine) saver := mock_statemanager.NewMockStateManager(ctrl) From ed1cd673f0640bad262076b2a47062c28da4d4df Mon Sep 17 00:00:00 2001 From: Aithal Date: Wed, 4 Oct 2017 16:39:43 -0700 Subject: [PATCH 18/58] eni attachment state change: ignore expired This change fixes a bug with the Agent's event submission logic, where if the ENI attachment is ignored if the ack time sent by the backend has expired. Not doing this will result in the Agent forever trying to send the attachment event to the backend as we can't reliably distinguish between throttle errors and invalid input errors from SubmitTaskStateChange response. --- agent/api/eniattachment.go | 9 ++ agent/api/eniattachment_test.go | 23 +++ agent/ecscni/plugin.go | 2 +- agent/eni/watcher/watcher_linux.go | 60 +++---- agent/eni/watcher/watcher_linux_test.go | 93 ++++++----- agent/eventhandler/handler_test.go | 14 -- agent/eventhandler/task_handler_types.go | 1 + agent/eventhandler/task_handler_types_test.go | 153 ++++++++++++++++++ 8 files changed, 268 insertions(+), 87 deletions(-) create mode 100644 agent/eventhandler/task_handler_types_test.go diff --git a/agent/api/eniattachment.go b/agent/api/eniattachment.go index e0de3257467..548124c5c17 100644 --- a/agent/api/eniattachment.go +++ b/agent/api/eniattachment.go @@ -90,6 +90,15 @@ func (eni *ENIAttachment) StopAckTimer() { eni.ackTimer.Stop() } +// HasExpired returns true if the ENI attachment object has exceeded the +// threshold for notifying the backend of the attachment +func (eni *ENIAttachment) HasExpired() bool { + eni.guard.RLock() + defer eni.guard.RUnlock() + + return time.Now().After(eni.ExpiresAt) +} + // String returns a string representation of the ENI Attachment func (eni *ENIAttachment) String() string { eni.guard.RLock() diff --git a/agent/api/eniattachment_test.go b/agent/api/eniattachment_test.go index 19df2ed15e5..28527bc100f 100644 --- a/agent/api/eniattachment_test.go +++ b/agent/api/eniattachment_test.go @@ -68,3 +68,26 @@ func TestStartTimerErrorWhenExpiresAtIsInThePast(t *testing.T) { } assert.Error(t, attachment.StartTimer(func() {})) } + +func TestHasExpired(t *testing.T) { + for _, tc := range []struct { + expiresAt int64 + expected bool + name string + }{ + {time.Now().Unix() - 1, true, "expiresAt in past returns true"}, + {time.Now().Unix() + 10, false, "expiresAt in future returns false"}, + } { + t.Run(tc.name, func(t *testing.T) { + attachment := &ENIAttachment{ + TaskARN: taskARN, + AttachmentARN: attachmentARN, + AttachStatusSent: attachSent, + MACAddress: mac, + Status: ENIAttachmentNone, + ExpiresAt: time.Unix(tc.expiresAt, 0), + } + assert.Equal(t, tc.expected, attachment.HasExpired()) + }) + } +} diff --git a/agent/ecscni/plugin.go b/agent/ecscni/plugin.go index 21f65a3e4ea..5bacc3705d9 100644 --- a/agent/ecscni/plugin.go +++ b/agent/ecscni/plugin.go @@ -124,7 +124,7 @@ func (client *cniClient) ReleaseIPResource(cfg *Config) error { Plugins: []*libcni.NetworkConfig{ipamConfig}, } - seelog.Debugf("Releasing the ip resource from ipam db, id: [%s], ip: [%s]", cfg.ID, cfg.IPAMV4Address) + seelog.Debugf("Releasing the ip resource from ipam db, id: [%s], ip: [%v]", cfg.ID, cfg.IPAMV4Address) os.Setenv("ECS_CNI_LOGLEVEL", logger.GetLevel()) defer os.Unsetenv("ECS_CNI_LOGLEVEL") return client.libcni.DelNetworkList(networkConfigList, cns) diff --git a/agent/eni/watcher/watcher_linux.go b/agent/eni/watcher/watcher_linux.go index 06f242a0a75..41eaa2fda3c 100644 --- a/agent/eni/watcher/watcher_linux.go +++ b/agent/eni/watcher/watcher_linux.go @@ -139,46 +139,46 @@ func (udevWatcher *UdevWatcher) reconcileOnce() error { // Add new interfaces next for mac, _ := range currentState { - udevWatcher.sendENIStateChange(mac) + if err := udevWatcher.sendENIStateChange(mac); err != nil { + log.Warnf("Udev watcher reconciliation: unable to send state change: %v", err) + } } return nil } // sendENIStateChange handles the eni event from udev or reconcile phase -func (udevWatcher *UdevWatcher) sendENIStateChange(mac string) { - eniAttachment, ok := udevWatcher.shouldSendENIStateChange(mac) - if ok { - go func(eni *api.ENIAttachment) { - eni.Status = api.ENIAttached - log.Infof("Emitting ENI change event for: %v", eni) - udevWatcher.eniChangeEvent <- api.TaskStateChange{ - TaskARN: eni.TaskARN, - Attachment: eni, - } - }(eniAttachment) - } -} - -// shouldSendENIStateChange checks whether this eni is managed by ecs -// and if its status should be sent to backend -func (udevWatcher *UdevWatcher) shouldSendENIStateChange(macAddress string) (*api.ENIAttachment, bool) { - if macAddress == "" { - log.Warn("ENI state manager: device with empty mac address") - return nil, false +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(macAddress) + eni, ok := udevWatcher.agentState.ENIByMac(mac) if !ok { - log.Infof("ENI state manager: eni not managed by ecs: %s", macAddress) - return nil, false + return errors.Errorf("udev watcher send ENI state change: eni not managed by ecs: %s", mac) } - if eni.IsSent() { - log.Infof("ENI state manager: eni attach status has already sent: %s", macAddress) - return eni, false + return errors.Errorf("udev watcher send ENI state change: eni status already sent: %s", eni.String()) + } + if eni.HasExpired() { + // Agent is aware of 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()) } - return eni, true + // We found an ENI, which has the expiration time set in future and + // needs to be acknowledged as having been 'attached' to the Instance + go func(eni *api.ENIAttachment) { + eni.Status = api.ENIAttached + log.Infof("Emitting ENI change event for: %s", eni.String()) + udevWatcher.eniChangeEvent <- api.TaskStateChange{ + TaskARN: eni.TaskARN, + Attachment: eni, + } + }(eni) + return nil } // buildState is used to build a state of the system for reconciliation @@ -227,7 +227,9 @@ func (udevWatcher *UdevWatcher) eventHandler() { log.Warnf("Udev watcher event-handler: error obtaining MACAddress for interface %s", netInterface) continue } - udevWatcher.sendENIStateChange(macAddress) + if err := udevWatcher.sendENIStateChange(macAddress); err != nil { + log.Warnf("Udev watcher event-handler: unable to send state change: %v", err) + } case <-udevWatcher.ctx.Done(): log.Info("Stopping udev event handler") // Send the shutdown signal and close the connection diff --git a/agent/eni/watcher/watcher_linux_test.go b/agent/eni/watcher/watcher_linux_test.go index f29694ed9e0..328f03f25d7 100644 --- a/agent/eni/watcher/watcher_linux_test.go +++ b/agent/eni/watcher/watcher_linux_test.go @@ -18,10 +18,10 @@ package watcher import ( "context" "errors" - "fmt" "net" "sync" "testing" + "time" "github.com/deniswernert/udev" "github.com/golang/mock/gomock" @@ -63,6 +63,7 @@ func TestWatcherInit(t *testing.T) { taskEngineState.AddENIAttachment(&api.ENIAttachment{ MACAddress: randomMAC, AttachStatusSent: false, + ExpiresAt: time.Unix(time.Now().Unix()+10, 0), }) eventChannel := make(chan statechange.Event) @@ -164,6 +165,7 @@ func TestReconcileENIs(t *testing.T) { taskEngineState.AddENIAttachment(&api.ENIAttachment{ MACAddress: randomMAC, AttachStatusSent: false, + ExpiresAt: time.Unix(time.Now().Unix()+10, 0), }) mockNetlink.EXPECT().LinkList().Return([]netlink.Link{ @@ -293,7 +295,7 @@ func TestUdevAddEvent(t *testing.T) { }, }, nil), mockStateManager.EXPECT().ENIByMac(randomMAC).Return( - &api.ENIAttachment{}, true), + &api.ENIAttachment{ExpiresAt: time.Unix(time.Now().Unix()+10, 0)}, true), ) // Spin off event handler @@ -452,7 +454,9 @@ func TestSendENIStateChange(t *testing.T) { watcher := newWatcher(context.TODO(), primaryMAC, nil, nil, mockStateManager, eventChannel) - mockStateManager.EXPECT().ENIByMac(randomMAC).Return(&api.ENIAttachment{}, true) + mockStateManager.EXPECT().ENIByMac(randomMAC).Return(&api.ENIAttachment{ + ExpiresAt: time.Unix(time.Now().Unix()+10, 0), + }, true) go watcher.sendENIStateChange(randomMAC) @@ -462,46 +466,49 @@ func TestSendENIStateChange(t *testing.T) { assert.Equal(t, api.ENIAttached, taskStateChange.Attachment.Status) } -func TestShouldSendENIStateChange(t *testing.T) { - testCases := []struct { - eniAttachment *api.ENIAttachment - eniByMACExists bool - expectStateChange bool - }{ - { - &api.ENIAttachment{}, - true, - true, - }, - { +func TestSendENIStateChangeUnmanaged(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockStateManager := mock_dockerstate.NewMockTaskEngineState(mockCtrl) + watcher := newWatcher(context.TODO(), primaryMAC, nil, nil, mockStateManager, nil) + + mockStateManager.EXPECT().ENIByMac(randomMAC).Return(nil, false) + assert.Error(t, watcher.sendENIStateChange(randomMAC)) +} + +func TestSendENIStateChangeAlreadySent(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockStateManager := mock_dockerstate.NewMockTaskEngineState(mockCtrl) + watcher := newWatcher(context.TODO(), primaryMAC, nil, nil, mockStateManager, nil) + + mockStateManager.EXPECT().ENIByMac(randomMAC).Return(&api.ENIAttachment{ + AttachStatusSent: true, + ExpiresAt: time.Unix(time.Now().Unix()+10, 0), + MACAddress: randomMAC, + }, true) + + assert.Error(t, watcher.sendENIStateChange(randomMAC)) +} + +func TestSendENIStateChangeExpired(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockStateManager := mock_dockerstate.NewMockTaskEngineState(mockCtrl) + watcher := newWatcher(context.TODO(), primaryMAC, nil, nil, mockStateManager, nil) + + gomock.InOrder( + mockStateManager.EXPECT().ENIByMac(randomMAC).Return( &api.ENIAttachment{ - AttachStatusSent: true, - }, - true, - false, - }, - { - &api.ENIAttachment{}, - false, - false, - }, - } - for _, tc := range testCases { - t.Run( - fmt.Sprintf("return %t when exists is %t and sent is %s", - tc.expectStateChange, tc.eniByMACExists, tc.eniAttachment.Status.String()), - func(t *testing.T) { - - mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() - - mockStateManager := mock_dockerstate.NewMockTaskEngineState(mockCtrl) - watcher := newWatcher(context.TODO(), primaryMAC, nil, nil, mockStateManager, nil) - - mockStateManager.EXPECT().ENIByMac(randomMAC).Return(tc.eniAttachment, tc.eniByMACExists) - _, ok := watcher.shouldSendENIStateChange(randomMAC) - assert.Equal(t, tc.expectStateChange, ok) - }) - } + AttachStatusSent: false, + ExpiresAt: time.Unix(time.Now().Unix()-10, 0), + MACAddress: randomMAC, + }, true), + mockStateManager.EXPECT().RemoveENIAttachment(randomMAC), + ) + assert.Error(t, watcher.sendENIStateChange(randomMAC)) } diff --git a/agent/eventhandler/handler_test.go b/agent/eventhandler/handler_test.go index 4beb69e3041..15b3460f1cc 100644 --- a/agent/eventhandler/handler_test.go +++ b/agent/eventhandler/handler_test.go @@ -277,20 +277,6 @@ func TestCleanupTaskEventAfterSubmit(t *testing.T) { assert.Len(t, handler.tasksToEvents, 0) } -func TestShouldBeSent(t *testing.T) { - sendableEvent := newSendableContainerEvent(api.ContainerStateChange{ - Status: api.ContainerStopped, - }) - - if sendableEvent.taskShouldBeSent() { - t.Error("Container event should not be sent as a task") - } - - if !sendableEvent.containerShouldBeSent() { - t.Error("Container should be sent if it's the first try") - } -} - func containerEvent(arn string) statechange.Event { return api.ContainerStateChange{TaskArn: arn, ContainerName: "containerName", Status: api.ContainerRunning, Container: &api.Container{}} } diff --git a/agent/eventhandler/task_handler_types.go b/agent/eventhandler/task_handler_types.go index e7bbefc0548..0f36bc681d0 100644 --- a/agent/eventhandler/task_handler_types.go +++ b/agent/eventhandler/task_handler_types.go @@ -93,6 +93,7 @@ func (event *sendableEvent) taskAttachmentShouldBeSent() bool { tevent := event.taskChange return tevent.Status == api.TaskStatusNone && // Task Status is not set for attachments as task record has yet to be streamed down tevent.Attachment != nil && // Task has attachment records + !tevent.Attachment.HasExpired() && // ENI attachment ack timestamp hasn't expired !tevent.Attachment.IsSent() // Task status hasn't already been sent } diff --git a/agent/eventhandler/task_handler_types_test.go b/agent/eventhandler/task_handler_types_test.go new file mode 100644 index 00000000000..3cb257a4999 --- /dev/null +++ b/agent/eventhandler/task_handler_types_test.go @@ -0,0 +1,153 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package eventhandler + +import ( + "fmt" + "testing" + "time" + + "github.com/aws/amazon-ecs-agent/agent/api" + "github.com/stretchr/testify/assert" +) + +func TestShouldContainerEventBeSent(t *testing.T) { + event := newSendableContainerEvent(api.ContainerStateChange{ + Status: api.ContainerStopped, + }) + assert.Equal(t, true, event.containerShouldBeSent()) + assert.Equal(t, false, event.taskShouldBeSent()) +} + +func TestShouldTaskEventBeSent(t *testing.T) { + for _, tc := range []struct { + event *sendableEvent + shouldBeSent bool + }{ + { + // We don't send a task event to backend if task status == NONE + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskStatusNone, + }), + shouldBeSent: false, + }, + { + // task status == RUNNING should be sent to backend + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskRunning, + }), + shouldBeSent: true, + }, + { + // task event will not be sent if sent status >= task status + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskRunning, + Task: &api.Task{ + SentStatusUnsafe: api.TaskRunning, + }, + }), + shouldBeSent: false, + }, + { + // this is a valid event as task status >= sent status + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskStopped, + Task: &api.Task{ + SentStatusUnsafe: api.TaskRunning, + }, + }), + shouldBeSent: true, + }, + } { + t.Run(fmt.Sprintf("Event[%s] should be sent[%t]", tc.event.String(), tc.shouldBeSent), func(t *testing.T) { + assert.Equal(t, tc.shouldBeSent, tc.event.taskShouldBeSent()) + assert.Equal(t, false, tc.event.containerShouldBeSent()) + assert.Equal(t, false, tc.event.taskAttachmentShouldBeSent()) + }) + } +} + +func TestShouldTaskAttachmentEventBeSent(t *testing.T) { + for _, tc := range []struct { + event *sendableEvent + attachmentShouldBeSent bool + taskShouldBeSent bool + }{ + { + // ENI Attachment is only sent if task status == NONE + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskStopped, + }), + attachmentShouldBeSent: false, + taskShouldBeSent: true, + }, + { + // ENI Attachment is only sent if task status == NONE and if + // the event has a non nil attachment object + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskStatusNone, + }), + attachmentShouldBeSent: false, + taskShouldBeSent: false, + }, + { + // ENI Attachment is only sent if task status == NONE and if + // the event has a non nil attachment object and if expiration + // ack timeout is set for future + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskStatusNone, + Attachment: &api.ENIAttachment{ + ExpiresAt: time.Unix(time.Now().Unix()-1, 0), + AttachStatusSent: false, + }, + }), + attachmentShouldBeSent: false, + taskShouldBeSent: false, + }, + { + // ENI Attachment is only sent if task status == NONE and if + // the event has a non nil attachment object and if expiration + // ack timeout is set for future and if attachment status hasn't + // already been sent + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskStatusNone, + Attachment: &api.ENIAttachment{ + ExpiresAt: time.Unix(time.Now().Unix()+10, 0), + AttachStatusSent: true, + }, + }), + attachmentShouldBeSent: false, + taskShouldBeSent: false, + }, + { + // Valid attachment event, ensure that its sent + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskStatusNone, + Attachment: &api.ENIAttachment{ + ExpiresAt: time.Unix(time.Now().Unix()+10, 0), + AttachStatusSent: false, + }, + }), + attachmentShouldBeSent: true, + taskShouldBeSent: false, + }, + } { + t.Run(fmt.Sprintf("Event[%s] should be sent[attachment=%t;task=%t]", + tc.event.String(), tc.attachmentShouldBeSent, tc.taskShouldBeSent), func(t *testing.T) { + assert.Equal(t, tc.attachmentShouldBeSent, tc.event.taskAttachmentShouldBeSent()) + assert.Equal(t, tc.taskShouldBeSent, tc.event.taskShouldBeSent()) + assert.Equal(t, false, tc.event.containerShouldBeSent()) + }) + } +} From 13fb7585e98befe20edc4b137e777c7a41caec0b Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 9 Oct 2017 09:06:12 -0700 Subject: [PATCH 19/58] engine: reduce logging verbosity this change also includes minor changes to addresses cr --- agent/containermetadata/types.go | 4 +--- agent/engine/docker_task_engine.go | 18 +++++++++--------- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/agent/containermetadata/types.go b/agent/containermetadata/types.go index de960f05424..fe88b5fdd5d 100644 --- a/agent/containermetadata/types.go +++ b/agent/containermetadata/types.go @@ -59,9 +59,7 @@ func (status MetadataStatus) MarshalText() (text []byte, err error) { } func (status *MetadataStatus) UnmarshalText(text []byte) error { - var err error t := string(text) - switch t { case MetadataInitialText: *status = MetadataInitial @@ -70,7 +68,7 @@ func (status *MetadataStatus) UnmarshalText(text []byte) error { default: return fmt.Errorf("failed unmarshalling MetadataStatus %s", text) } - return err + return nil } // DockerMetadataClient is a wrapper for the docker interface functions we need diff --git a/agent/engine/docker_task_engine.go b/agent/engine/docker_task_engine.go index 9f1e051031e..61ce15d1857 100644 --- a/agent/engine/docker_task_engine.go +++ b/agent/engine/docker_task_engine.go @@ -662,7 +662,7 @@ func (engine *DockerTaskEngine) createContainer(task *api.Task, container *api.C // we die before 'createContainer' returns because we can inspect by // name engine.state.AddContainer(&api.DockerContainer{DockerName: dockerContainerName, Container: container}, task) - seelog.Infof("Created container name mapping for task %s - %s -> %s", task.Arn, container, dockerContainerName) + seelog.Infof("Created container name mapping for task %s - %s -> %s", task.Arn, container.Name, dockerContainerName) engine.saver.ForceSave() } @@ -671,7 +671,7 @@ func (engine *DockerTaskEngine) createContainer(task *api.Task, container *api.C if engine.cfg.ContainerMetadataEnabled && !container.IsInternal() { mderr := engine.metadataManager.Create(config, hostConfig, task.Arn, container.Name) if mderr != nil { - seelog.Warnf("Create metadata failed for container %s of task %s: %v", container, task, mderr) + seelog.Warnf("Create metadata failed for container %s of task %s: %v", container.Name, task.Arn, mderr) } } @@ -679,7 +679,7 @@ func (engine *DockerTaskEngine) createContainer(task *api.Task, container *api.C if metadata.DockerID != "" { engine.state.AddContainer(&api.DockerContainer{DockerID: metadata.DockerID, DockerName: dockerContainerName, Container: container}, task) } - seelog.Infof("Created docker container for task %s: %s -> %s", task, container, metadata.DockerID) + seelog.Infof("Created docker container for task %s: %s -> %s", task.Arn, container.Name, metadata.DockerID) return metadata } @@ -713,11 +713,11 @@ func (engine *DockerTaskEngine) startContainer(task *api.Task, container *api.Co go func() { err := engine.metadataManager.Update(dockerContainer.DockerID, task.Arn, container.Name) if err != nil { - seelog.Warnf("Update metadata file failed for container %s of task %s: %v", container, task, err) - } else { - container.SetMetadataFileUpdated() - seelog.Debugf("Updated metadata file for container %s of task %s", container, task) + seelog.Warnf("Update metadata file failed for container %s of task %s: %v", container.Name, task.Arn, err) + return } + container.SetMetadataFileUpdated() + seelog.Debugf("Updated metadata file for container %s of task %s", container.Name, task.Arn) }() } return dockerContainerMD @@ -959,9 +959,9 @@ func (engine *DockerTaskEngine) isParallelPullCompatible() bool { func (engine *DockerTaskEngine) updateMetadataFile(task *api.Task, cont *api.DockerContainer) { err := engine.metadataManager.Update(cont.DockerID, task.Arn, cont.Container.Name) if err != nil { - seelog.Errorf("Update metadata file failed for container %s of task %s: %v", cont.Container, task, err) + seelog.Errorf("Update metadata file failed for container %s of task %s: %v", cont.Container.Name, task.Arn, err) } else { cont.Container.SetMetadataFileUpdated() - seelog.Debugf("Updated metadata file for container %s of task %s", cont.Container, task) + seelog.Debugf("Updated metadata file for container %s of task %s", cont.Container.Name, task.Arn) } } From 68fa765985c7a0ed1aa59a78e955a62a9c0791cf Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 9 Oct 2017 10:39:07 -0700 Subject: [PATCH 20/58] containermetadata: add unit tests for un/marshal --- agent/containermetadata/types_test.go | 63 +++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 agent/containermetadata/types_test.go diff --git a/agent/containermetadata/types_test.go b/agent/containermetadata/types_test.go new file mode 100644 index 00000000000..f19803ec9ae --- /dev/null +++ b/agent/containermetadata/types_test.go @@ -0,0 +1,63 @@ +// +build !integration +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package containermetadata + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestUnMarshalText(t *testing.T) { + + var nilMs MetadataStatus + + testCases := []struct { + param []byte + expectedReturn MetadataStatus + name string + }{ + {[]byte(""), nilMs, "unmarshal MetadataStatus from empty string"}, + {[]byte("Malformed"), nilMs, "unmarshal MetadataStatus from malformed string"}, + {[]byte(MetadataInitialText), MetadataInitial, "unmarshal MetadataInitial from string"}, + {[]byte(MetadataReadyText), MetadataReady, "unmarshal MetadataReady from string"}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + var ms MetadataStatus + ms.UnmarshalText(tc.param) + assert.Equal(t, tc.expectedReturn, ms, tc.name) + }) + } +} + +func TestMarshalText(t *testing.T) { + + testCases := []struct { + param MetadataStatus + expectedReturn []byte + name string + }{ + {MetadataInitial, []byte(MetadataInitialText), "marshal MetadataInitial to text"}, + {MetadataReady, []byte(MetadataReadyText), "marshal MetadataReady to text"}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + ret, _ := tc.param.MarshalText() + assert.Equal(t, tc.expectedReturn, ret, tc.name) + }) + } +} From b4f68c6306efb3c501ef0c9dc28a7464179915ce Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 9 Oct 2017 12:24:09 -0700 Subject: [PATCH 21/58] statemanger: version bump to 7 --- agent/statemanager/state_manager.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/agent/statemanager/state_manager.go b/agent/statemanager/state_manager.go index f59b359aa43..76afcbbb4b5 100644 --- a/agent/statemanager/state_manager.go +++ b/agent/statemanager/state_manager.go @@ -49,8 +49,9 @@ const ( // c) Add 'SteadyStateStatus' field to 'Container' struct // d) Add 'ENIAttachments' struct // e) Deprecate 'SteadyStateDependencies' in favor of 'TransitionDependencySet' - // f) Add 'MetadataUpdated' field to 'api.Container' - ECSDataVersion = 6 + // 7) + // a) Add 'MetadataUpdated' field to 'api.Container' + ECSDataVersion = 7 // ecsDataFile specifies the filename in the ECS_DATADIR ecsDataFile = "ecs_agent_data.json" From e9fd7cf609b5c8a6e550b4471c07b2934fc8b4f9 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Mon, 9 Oct 2017 12:23:18 -0700 Subject: [PATCH 22/58] containermetadata: refactored unit tests unit tests no manager_test.go no longer depend on error message format. --- agent/containermetadata/manager.go | 19 +++++-------------- agent/containermetadata/manager_test.go | 18 ++++-------------- 2 files changed, 9 insertions(+), 28 deletions(-) diff --git a/agent/containermetadata/manager.go b/agent/containermetadata/manager.go index 534b38b4d86..dc40abb76d1 100644 --- a/agent/containermetadata/manager.go +++ b/agent/containermetadata/manager.go @@ -122,23 +122,19 @@ func (manager *metadataManager) Update(dockerID string, taskARN string, containe // Ensure we do not update a container that is invalid or is not running if dockerContainer == nil || !dockerContainer.State.Running { - return fmt.Errorf("container metadata update for task %s container %s: container not running or invalid", taskARN, containerName) + return fmt.Errorf("container metadata update for contiainer %s in task %s: container not running or invalid", containerName, taskARN) } // Acquire the metadata then write it in JSON format to the file metadata := manager.parseMetadata(dockerContainer, taskARN, containerName) - err = manager.marshalAndWrite(metadata, taskARN, containerName) - if err != nil { - return err - } - return nil + return manager.marshalAndWrite(metadata, taskARN, containerName) } // Clean removes the metadata files of all containers associated with a task func (manager *metadataManager) Clean(taskARN string) error { metadataPath, err := getTaskMetadataDir(taskARN, manager.dataDir) if err != nil { - return fmt.Errorf("clean task %s: %v", taskARN, err) + return fmt.Errorf("clean task metadata: unable to get metadata directory for task %s: %v", taskARN, err) } return manager.osWrap.RemoveAll(metadataPath) } @@ -146,14 +142,9 @@ func (manager *metadataManager) Clean(taskARN string) error { func (manager *metadataManager) marshalAndWrite(metadata Metadata, taskARN string, containerName string) error { data, err := json.MarshalIndent(metadata, "", "\t") if err != nil { - return fmt.Errorf("create metadata for task %s container %s: %v", taskARN, containerName, err) + return fmt.Errorf("create metadata for container %s in task %s: failed to marshal metadata: %v", containerName, taskARN, err) } // Write the metadata to file - err = writeToMetadataFile(manager.osWrap, manager.ioutilWrap, data, taskARN, containerName, manager.dataDir) - if err != nil { - return err - } - - return nil + return writeToMetadataFile(manager.osWrap, manager.ioutilWrap, data, taskARN, containerName, manager.dataDir) } diff --git a/agent/containermetadata/manager_test.go b/agent/containermetadata/manager_test.go index 813f8010639..d9aa12ee44e 100644 --- a/agent/containermetadata/manager_test.go +++ b/agent/containermetadata/manager_test.go @@ -16,7 +16,6 @@ package containermetadata import ( "errors" - "fmt" "testing" "github.com/aws/amazon-ecs-agent/agent/containermetadata/mocks" @@ -68,9 +67,7 @@ func TestCreateMalformedFilepath(t *testing.T) { newManager := &metadataManager{} err := newManager.Create(nil, nil, mockTaskARN, mockContainerName) - expectErrorMessage := fmt.Sprintf("container metadata create for task %s container %s: get metdata file path of task %s container %s: get task ARN: invalid TaskARN %s", mockTaskARN, mockContainerName, mockTaskARN, mockContainerName, mockTaskARN) - - assert.Equal(t, expectErrorMessage, err.Error()) + assert.Error(t, err) } // TestCreateMkdirAllFail checks case when MkdirAll call fails @@ -89,9 +86,7 @@ func TestCreateMkdirAllFail(t *testing.T) { osWrap: mockOS, } err := newManager.Create(nil, nil, mockTaskARN, mockContainerName) - expectErrorMessage := fmt.Sprintf("creating metadata directory for task %s: err", mockTaskARN) - - assert.Equal(t, expectErrorMessage, err.Error()) + assert.Error(t, err) } // TestUpdateInspectFail checks case when Inspect call fails @@ -134,9 +129,7 @@ func TestUpdateNotRunningFail(t *testing.T) { mockClient.EXPECT().InspectContainer(mockDockerID, inspectContainerTimeout).Return(mockContainer, nil) err := newManager.Update(mockDockerID, mockTaskARN, mockContainerName) - expectErrorMessage := fmt.Sprintf("container metadata update for task %s container %s: container not running or invalid", mockTaskARN, mockContainerName) - - assert.Equal(t, expectErrorMessage, err.Error()) + assert.Error(t, err) } // TestMalformedFilepath checks case where ARN is invalid @@ -148,9 +141,7 @@ func TestMalformedFilepath(t *testing.T) { newManager := &metadataManager{} err := newManager.Clean(mockTaskARN) - expectErrorMessage := fmt.Sprintf("clean task %s: get task ARN: invalid TaskARN invalidARN", mockTaskARN) - - assert.Equal(t, expectErrorMessage, err.Error()) + assert.Error(t, err) } // TestHappyPath is the mainline case for metadata create @@ -168,6 +159,5 @@ func TestHappyPath(t *testing.T) { mockOS.EXPECT().RemoveAll(gomock.Any()).Return(nil), ) err := newManager.Clean(mockTaskARN) - assert.NoError(t, err) } From be6fdadc9aa02bb1bd108d599912d5298cfe37c5 Mon Sep 17 00:00:00 2001 From: richardpen Date: Mon, 18 Sep 2017 18:38:11 +0000 Subject: [PATCH 23/58] update go docker client --- agent/Godeps/Godeps.json | 3 +- .../fsouza/go-dockerclient/.travis.yml | 14 ++-- .../github.com/fsouza/go-dockerclient/AUTHORS | 7 ++ .../fsouza/go-dockerclient/README.markdown | 13 ++++ .../fsouza/go-dockerclient/appveyor.yml | 8 +-- .../fsouza/go-dockerclient/client.go | 51 +++++++++++++- .../fsouza/go-dockerclient/client_unix.go | 6 +- .../fsouza/go-dockerclient/client_windows.go | 3 +- .../fsouza/go-dockerclient/container.go | 67 +++++++++++++++++-- .../fsouza/go-dockerclient/event.go | 16 +++-- .../github.com/fsouza/go-dockerclient/exec.go | 5 ++ .../fsouza/go-dockerclient/network.go | 5 +- .../fsouza/go-dockerclient/service.go | 47 +++++++++++++ 13 files changed, 209 insertions(+), 36 deletions(-) diff --git a/agent/Godeps/Godeps.json b/agent/Godeps/Godeps.json index 75604dbc9ae..de3bfff850a 100644 --- a/agent/Godeps/Godeps.json +++ b/agent/Godeps/Godeps.json @@ -325,7 +325,8 @@ }, { "ImportPath": "github.com/fsouza/go-dockerclient", - "Rev": "9e921e30db8bcc1221fa0485ad9ce5b195fb4445" + "Comment": "docker-1.9/go-1.4-421-g98edf3e", + "Rev": "98edf3edfae6a6500fecc69d2bcccf1302544004" }, { "ImportPath": "github.com/go-ini/ini", diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/.travis.yml b/agent/vendor/github.com/fsouza/go-dockerclient/.travis.yml index fb371c52f16..e768e88ba8a 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/.travis.yml +++ b/agent/vendor/github.com/fsouza/go-dockerclient/.travis.yml @@ -1,18 +1,18 @@ language: go sudo: required go: - - 1.7.x - 1.8.x + - 1.9 - tip os: - linux - osx env: matrix: - - GOARCH=amd64 DOCKER_VERSION=1.12.6 - - GOARCH=386 DOCKER_VERSION=1.12.6 - - GOARCH=amd64 DOCKER_VERSION=1.13.1 - - GOARCH=386 DOCKER_VERSION=1.13.1 + - GOARCH=amd64 DOCKER_PKG_VERSION=17.06.0~ce-0~ubuntu + - GOARCH=386 DOCKER_PKG_VERSION=17.06.0~ce-0~ubuntu + - GOARCH=amd64 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty + - GOARCH=386 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty global: - GO_TEST_FLAGS=-race - DOCKER_HOST=tcp://127.0.0.1:2375 @@ -27,6 +27,6 @@ matrix: fast_finish: true exclude: - os: osx - env: GOARCH=amd64 DOCKER_VERSION=1.12.6 + env: GOARCH=amd64 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty - os: osx - env: GOARCH=386 DOCKER_VERSION=1.12.6 + env: GOARCH=386 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/AUTHORS b/agent/vendor/github.com/fsouza/go-dockerclient/AUTHORS index b1ba43b86f3..55dd8e3b371 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/AUTHORS +++ b/agent/vendor/github.com/fsouza/go-dockerclient/AUTHORS @@ -36,7 +36,10 @@ Changping Chen Cheah Chu Yeow cheneydeng Chris Bednarski +Chris Stavropoulos Christian Stewart +Christophe Mourette +Clint Armstrong CMGS Colin Hebert Craig Jellick @@ -45,6 +48,7 @@ Dan Williams Daniel, Dao Quang Minh Daniel Garcia Daniel Hiltgen +Daniel Tsui Darren Shepherd Dave Choi David Huie @@ -56,6 +60,7 @@ Ed Elias G. Schneevoigt Erez Horev Eric Anderson +Eric J. Holmes Eric Mountain Erwin van Eyk Ethan Mosbaugh @@ -76,6 +81,7 @@ He Simei Ivan Mikushin James Bardin James Nugent +Jamie Snell Januar Wayong Jari Kolehmainen Jason Wilder @@ -87,6 +93,7 @@ Jen Andre Jérôme Laurens Jim Minter Johan Euphrosine +Johannes Scheuermann John Hughes Jorge Marey Julian Einwag diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/README.markdown b/agent/vendor/github.com/fsouza/go-dockerclient/README.markdown index 68434a03ceb..a9ffc17a0f6 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/README.markdown +++ b/agent/vendor/github.com/fsouza/go-dockerclient/README.markdown @@ -110,3 +110,16 @@ Commited code must pass: Running `make test` will check all of these. If your editor does not automatically call ``gofmt -s``, `make fmt` will format all go files in this repository. + +## Using with Docker 1.9 and Go 1.4 + +There's a tag for using go-dockerclient with Docker 1.9 (which requires +compiling go-dockerclient with Go 1.4), the tag name is ``docker-1.9/go-1.4``. + +The instructions below can be used to get a version of go-dockerclient that compiles with Go 1.4: + +``` +% git clone -b docker-1.9/go-1.4 https://github.com/fsouza/go-dockerclient.git $GOPATH/src/github.com/fsouza/go-dockerclient +% git clone -b v1.9.1 https://github.com/docker/docker.git $GOPATH/src/github.com/docker/docker +% go get github.com/fsouza/go-dockerclient +``` diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/appveyor.yml b/agent/vendor/github.com/fsouza/go-dockerclient/appveyor.yml index 85a2c94e10a..3d8e319cd90 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/appveyor.yml +++ b/agent/vendor/github.com/fsouza/go-dockerclient/appveyor.yml @@ -5,16 +5,16 @@ clone_folder: c:\gopath\src\github.com\fsouza\go-dockerclient environment: GOPATH: c:\gopath matrix: - - GOVERSION: 1.7.5 - - GOVERSION: 1.8.1 + - GOVERSION: 1.8.3 + - GOVERSION: 1.9 install: - set PATH=%GOPATH%\bin;c:\go\bin;%PATH% - rmdir c:\go /s /q - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.zip - 7z x go%GOVERSION%.windows-amd64.zip -y -oC:\ > NUL build_script: - - go get -d -t ./... + - go get -race -d -t ./... test_script: - - go test -v ./... + - go test -race ./... matrix: fast_finish: true diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/client.go b/agent/vendor/github.com/fsouza/go-dockerclient/client.go index 3527adf769b..625d4cd5a7d 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/client.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/client.go @@ -24,6 +24,7 @@ import ( "os" "path/filepath" "reflect" + "runtime" "strconv" "strings" "sync/atomic" @@ -33,7 +34,6 @@ import ( "github.com/docker/docker/pkg/homedir" "github.com/docker/docker/pkg/jsonmessage" "github.com/docker/docker/pkg/stdcopy" - "github.com/hashicorp/go-cleanhttp" "golang.org/x/net/context" "golang.org/x/net/context/ctxhttp" ) @@ -212,7 +212,7 @@ func NewVersionedClient(endpoint string, apiVersionString string) (*Client, erro } } c := &Client{ - HTTPClient: cleanhttp.DefaultClient(), + HTTPClient: defaultClient(), Dialer: &net.Dialer{}, endpoint: endpoint, endpointURL: u, @@ -326,7 +326,7 @@ func NewVersionedTLSClientFromBytes(endpoint string, certPEMBlock, keyPEMBlock, } tlsConfig.RootCAs = caPool } - tr := cleanhttp.DefaultTransport() + tr := defaultTransport() tr.TLSClientConfig = tlsConfig if err != nil { return nil, err @@ -498,6 +498,7 @@ type streamOptions struct { in io.Reader stdout io.Writer stderr io.Writer + reqSent chan struct{} // timeout is the initial connection timeout timeout time.Duration // Timeout with no data is received, it's reset every time new data @@ -576,6 +577,9 @@ func (c *Client) stream(method, path string, streamOptions streamOptions) error dial.SetDeadline(time.Now().Add(streamOptions.timeout)) } + if streamOptions.reqSent != nil { + close(streamOptions.reqSent) + } if resp, err = http.ReadResponse(breader, req); err != nil { // Cancel timeout for future I/O operations if streamOptions.timeout > 0 { @@ -594,6 +598,9 @@ func (c *Client) stream(method, path string, streamOptions streamOptions) error } return chooseError(subCtx, err) } + if streamOptions.reqSent != nil { + close(streamOptions.reqSent) + } } defer resp.Body.Close() if resp.StatusCode < 200 || resp.StatusCode >= 400 { @@ -1033,3 +1040,41 @@ func getDockerEnv() (*dockerEnv, error) { dockerCertPath: dockerCertPath, }, nil } + +// defaultTransport returns a new http.Transport with similar default values to +// http.DefaultTransport, but with idle connections and keepalives disabled. +func defaultTransport() *http.Transport { + transport := defaultPooledTransport() + transport.DisableKeepAlives = true + transport.MaxIdleConnsPerHost = -1 + return transport +} + +// defaultPooledTransport returns a new http.Transport with similar default +// values to http.DefaultTransport. Do not use this for transient transports as +// it can leak file descriptors over time. Only use this for transports that +// will be re-used for the same host(s). +func defaultPooledTransport() *http.Transport { + transport := &http.Transport{ + Proxy: http.ProxyFromEnvironment, + DialContext: (&net.Dialer{ + Timeout: 30 * time.Second, + KeepAlive: 30 * time.Second, + }).DialContext, + MaxIdleConns: 100, + IdleConnTimeout: 90 * time.Second, + TLSHandshakeTimeout: 10 * time.Second, + ExpectContinueTimeout: 1 * time.Second, + MaxIdleConnsPerHost: runtime.GOMAXPROCS(0) + 1, + } + return transport +} + +// defaultClient returns a new http.Client with similar default values to +// http.Client, but with a non-shared Transport, idle connections disabled, and +// keepalives disabled. +func defaultClient() *http.Client { + return &http.Client{ + Transport: defaultTransport(), + } +} diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/client_unix.go b/agent/vendor/github.com/fsouza/go-dockerclient/client_unix.go index dd153348cbc..b578e03037b 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/client_unix.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/client_unix.go @@ -10,8 +10,6 @@ import ( "context" "net" "net/http" - - "github.com/hashicorp/go-cleanhttp" ) // initializeNativeClient initializes the native Unix domain socket client on @@ -21,9 +19,9 @@ func (c *Client) initializeNativeClient() { return } socketPath := c.endpointURL.Path - tr := cleanhttp.DefaultTransport() + tr := defaultTransport() tr.Dial = func(network, addr string) (net.Conn, error) { - return c.Dialer.Dial(network, addr) + return c.Dialer.Dial(unixProtocol, socketPath) } tr.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) { return c.Dialer.Dial(unixProtocol, socketPath) diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/client_windows.go b/agent/vendor/github.com/fsouza/go-dockerclient/client_windows.go index 95ef56b4c3c..c863fb05faa 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/client_windows.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/client_windows.go @@ -13,7 +13,6 @@ import ( "time" "github.com/Microsoft/go-winio" - "github.com/hashicorp/go-cleanhttp" ) const namedPipeConnectTimeout = 2 * time.Second @@ -36,7 +35,7 @@ func (c *Client) initializeNativeClient() { timeout := namedPipeConnectTimeout return winio.DialPipe(namedPipePath, &timeout) } - tr := cleanhttp.DefaultTransport() + tr := defaultTransport() tr.Dial = dialFunc tr.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) { return dialFunc(network, addr) diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/container.go b/agent/vendor/github.com/fsouza/go-dockerclient/container.go index af1cd41ca6c..652deee8f80 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/container.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/container.go @@ -204,7 +204,7 @@ func (s *State) StateString() string { // PortBinding represents the host/container port mapping as returned in the // `docker inspect` json type PortBinding struct { - HostIP string `json:"HostIP,omitempty" yaml:"HostIP,omitempty" toml:"HostIP,omitempty"` + HostIP string `json:"HostIp,omitempty" yaml:"HostIp,omitempty" toml:"HostIp,omitempty"` HostPort string `json:"HostPort,omitempty" yaml:"HostPort,omitempty" toml:"HostPort,omitempty"` } @@ -328,6 +328,43 @@ type Config struct { VolumesFrom string `json:"VolumesFrom,omitempty" yaml:"VolumesFrom,omitempty" toml:"VolumesFrom,omitempty"` } +// HostMount represents a mount point in the container in HostConfig. +// +// It has been added in the version 1.25 of the Docker API +type HostMount struct { + Target string `json:"Target,omitempty" yaml:"Target,omitempty" toml:"Target,omitempty"` + Source string `json:"Source,omitempty" yaml:"Source,omitempty" toml:"Source,omitempty"` + Type string `json:"Type,omitempty" yaml:"Type,omitempty" toml:"Type,omitempty"` + ReadOnly bool `json:"ReadOnly,omitempty" yaml:"ReadOnly,omitempty" toml:"ReadOnly,omitempty"` + BindOptions *BindOptions `json:"BindOptions,omitempty" yaml:"BindOptions,omitempty" toml:"BindOptions,omitempty"` + VolumeOptions *VolumeOptions `json:"VolumeOptions,omitempty" yaml:"VolumeOptions,omitempty" toml:"VolumeOptions,omitempty"` + TempfsOptions *TempfsOptions `json:"TempfsOptions,omitempty" yaml:"TempfsOptions,omitempty" toml:"TempfsOptions,omitempty"` +} + +// BindOptions contains optional configuration for the bind type +type BindOptions struct { + Propagation string `json:"Propagation,omitempty" yaml:"Propagation,omitempty" toml:"Propagation,omitempty"` +} + +// VolumeOptions contains optional configuration for the volume type +type VolumeOptions struct { + NoCopy bool `json:"NoCopy,omitempty" yaml:"NoCopy,omitempty" toml:"NoCopy,omitempty"` + Labels map[string]string `json:"Labels,omitempty" yaml:"Labels,omitempty" toml:"Labels,omitempty"` + DriverConfig VolumeDriverConfig `json:"DriverConfig,omitempty" yaml:"DriverConfig,omitempty" toml:"DriverConfig,omitempty"` +} + +// TempfsOptions contains optional configuration for the tempfs type +type TempfsOptions struct { + SizeBytes int64 `json:"SizeBytes,omitempty" yaml:"SizeBytes,omitempty" toml:"SizeBytes,omitempty"` + Mode int `json:"Mode,omitempty" yaml:"Mode,omitempty" toml:"Mode,omitempty"` +} + +// VolumeDriverConfig holds a map of volume driver specific options +type VolumeDriverConfig struct { + Name string `json:"Name,omitempty" yaml:"Name,omitempty" toml:"Name,omitempty"` + Options map[string]string `json:"Options,omitempty" yaml:"Options,omitempty" toml:"Options,omitempty"` +} + // Mount represents a mount point in the container. // // It has been added in the version 1.20 of the Docker API, available since @@ -740,6 +777,8 @@ type HostConfig struct { CPUPercent int64 `json:"CpuPercent,omitempty" yaml:"CpuPercent,omitempty"` IOMaximumBandwidth int64 `json:"IOMaximumBandwidth,omitempty" yaml:"IOMaximumBandwidth,omitempty"` IOMaximumIOps int64 `json:"IOMaximumIOps,omitempty" yaml:"IOMaximumIOps,omitempty"` + Mounts []HostMount `json:"Mounts,omitempty" yaml:"Mounts,omitempty" toml:"Mounts,omitempty"` + Init bool `json:",omitempty" yaml:",omitempty"` } // NetworkingConfig represents the container's networking configuration for each of its interfaces @@ -915,6 +954,8 @@ func (c *Client) TopContainer(id string, psArgs string) (TopResult, error) { // See https://goo.gl/Dk3Xio for more details. type Stats struct { Read time.Time `json:"read,omitempty" yaml:"read,omitempty" toml:"read,omitempty"` + PreRead time.Time `json:"preread,omitempty" yaml:"preread,omitempty" toml:"preread,omitempty"` + NumProcs uint32 `json:"num_procs" yaml:"num_procs" toml:"num_procs"` PidsStats struct { Current uint64 `json:"current,omitempty" yaml:"current,omitempty"` } `json:"pids_stats,omitempty" yaml:"pids_stats,omitempty" toml:"pids_stats,omitempty"` @@ -954,10 +995,13 @@ type Stats struct { HierarchicalMemswLimit uint64 `json:"hierarchical_memsw_limit,omitempty" yaml:"hierarchical_memsw_limit,omitempty" toml:"hierarchical_memsw_limit,omitempty"` Swap uint64 `json:"swap,omitempty" yaml:"swap,omitempty" toml:"swap,omitempty"` } `json:"stats,omitempty" yaml:"stats,omitempty" toml:"stats,omitempty"` - MaxUsage uint64 `json:"max_usage,omitempty" yaml:"max_usage,omitempty" toml:"max_usage,omitempty"` - Usage uint64 `json:"usage,omitempty" yaml:"usage,omitempty" toml:"usage,omitempty"` - Failcnt uint64 `json:"failcnt,omitempty" yaml:"failcnt,omitempty" toml:"failcnt,omitempty"` - Limit uint64 `json:"limit,omitempty" yaml:"limit,omitempty" toml:"limit,omitempty"` + MaxUsage uint64 `json:"max_usage,omitempty" yaml:"max_usage,omitempty" toml:"max_usage,omitempty"` + Usage uint64 `json:"usage,omitempty" yaml:"usage,omitempty" toml:"usage,omitempty"` + Failcnt uint64 `json:"failcnt,omitempty" yaml:"failcnt,omitempty" toml:"failcnt,omitempty"` + Limit uint64 `json:"limit,omitempty" yaml:"limit,omitempty" toml:"limit,omitempty"` + Commit uint64 `json:"commitbytes,omitempty" yaml:"commitbytes,omitempty" toml:"privateworkingset,omitempty"` + CommitPeak uint64 `json:"commitpeakbytes,omitempty" yaml:"commitpeakbytes,omitempty" toml:"commitpeakbytes,omitempty"` + PrivateWorkingSet uint64 `json:"privateworkingset,omitempty" yaml:"privateworkingset,omitempty" toml:"privateworkingset,omitempty"` } `json:"memory_stats,omitempty" yaml:"memory_stats,omitempty" toml:"memory_stats,omitempty"` BlkioStats struct { IOServiceBytesRecursive []BlkioStatsEntry `json:"io_service_bytes_recursive,omitempty" yaml:"io_service_bytes_recursive,omitempty" toml:"io_service_bytes_recursive,omitempty"` @@ -969,8 +1013,14 @@ type Stats struct { IOTimeRecursive []BlkioStatsEntry `json:"io_time_recursive,omitempty" yaml:"io_time_recursive,omitempty" toml:"io_time_recursive,omitempty"` SectorsRecursive []BlkioStatsEntry `json:"sectors_recursive,omitempty" yaml:"sectors_recursive,omitempty" toml:"sectors_recursive,omitempty"` } `json:"blkio_stats,omitempty" yaml:"blkio_stats,omitempty" toml:"blkio_stats,omitempty"` - CPUStats CPUStats `json:"cpu_stats,omitempty" yaml:"cpu_stats,omitempty" toml:"cpu_stats,omitempty"` - PreCPUStats CPUStats `json:"precpu_stats,omitempty"` + CPUStats CPUStats `json:"cpu_stats,omitempty" yaml:"cpu_stats,omitempty" toml:"cpu_stats,omitempty"` + PreCPUStats CPUStats `json:"precpu_stats,omitempty"` + StorageStats struct { + ReadCountNormalized uint64 `json:"read_count_normalized,omitempty" yaml:"read_count_normalized,omitempty" toml:"read_count_normalized,omitempty"` + ReadSizeBytes uint64 `json:"read_size_bytes,omitempty" yaml:"read_size_bytes,omitempty" toml:"read_size_bytes,omitempty"` + WriteCountNormalized uint64 `json:"write_count_normalized,omitempty" yaml:"write_count_normalized,omitempty" toml:"write_count_normalized,omitempty"` + WriteSizeBytes uint64 `json:"write_size_bytes,omitempty" yaml:"write_size_bytes,omitempty" toml:"write_size_bytes,omitempty"` + } `json:"storage_stats,omitempty" yaml:"storage_stats,omitempty" toml:"storage_stats,omitempty"` } // NetworkStats is a stats entry for network stats @@ -1056,6 +1106,7 @@ func (c *Client) Stats(opts StatsOptions) (retErr error) { } }() + reqSent := make(chan struct{}) go func() { err := c.stream("GET", fmt.Sprintf("/containers/%s/stats?stream=%v", opts.ID, opts.Stream), streamOptions{ rawJSONStream: true, @@ -1064,6 +1115,7 @@ func (c *Client) Stats(opts StatsOptions) (retErr error) { timeout: opts.Timeout, inactivityTimeout: opts.InactivityTimeout, context: opts.Context, + reqSent: reqSent, }) if err != nil { dockerError, ok := err.(*Error) @@ -1094,6 +1146,7 @@ func (c *Client) Stats(opts StatsOptions) (retErr error) { decoder := json.NewDecoder(readCloser) stats := new(Stats) + <-reqSent for err := decoder.Decode(stats); err != io.EOF; err = decoder.Decode(stats) { if err != nil { return err diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/event.go b/agent/vendor/github.com/fsouza/go-dockerclient/event.go index 007d2b22bc4..21c0584f05b 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/event.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/event.go @@ -216,7 +216,7 @@ func (eventState *eventMonitoringState) monitorEvents(c *Client) { return } eventState.updateLastSeen(ev) - go eventState.sendEvent(ev) + eventState.sendEvent(ev) case err = <-eventState.errC: if err == ErrNoListeners { eventState.disableEventMonitoring() @@ -274,7 +274,10 @@ func (eventState *eventMonitoringState) sendEvent(event *APIEvents) { } for _, listener := range eventState.listeners { - listener <- event + select { + case listener <- event: + default: + } } } } @@ -342,11 +345,12 @@ func (c *Client) eventHijack(startTime int64, eventChan chan *APIEvents, errChan if event.Time == 0 { continue } - if !c.eventMonitor.isEnabled() || c.eventMonitor.C != eventChan { - return - } transformEvent(&event) - eventChan <- &event + c.eventMonitor.RLock() + if c.eventMonitor.enabled && c.eventMonitor.C == eventChan { + eventChan <- &event + } + c.eventMonitor.RUnlock() } }(res, conn) return nil diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/exec.go b/agent/vendor/github.com/fsouza/go-dockerclient/exec.go index b935c6893a2..0048153096b 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/exec.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/exec.go @@ -6,6 +6,7 @@ package docker import ( "encoding/json" + "errors" "fmt" "io" "net/http" @@ -29,6 +30,7 @@ type CreateExecOptions struct { AttachStdout bool `json:"AttachStdout,omitempty" yaml:"AttachStdout,omitempty" toml:"AttachStdout,omitempty"` AttachStderr bool `json:"AttachStderr,omitempty" yaml:"AttachStderr,omitempty" toml:"AttachStderr,omitempty"` Tty bool `json:"Tty,omitempty" yaml:"Tty,omitempty" toml:"Tty,omitempty"` + Env []string `json:"Env,omitempty" yaml:"Env,omitempty" toml:"Env,omitempty"` Cmd []string `json:"Cmd,omitempty" yaml:"Cmd,omitempty" toml:"Cmd,omitempty"` Container string `json:"Container,omitempty" yaml:"Container,omitempty" toml:"Container,omitempty"` User string `json:"User,omitempty" yaml:"User,omitempty" toml:"User,omitempty"` @@ -41,6 +43,9 @@ type CreateExecOptions struct { // // See https://goo.gl/60TeBP for more details func (c *Client) CreateExec(opts CreateExecOptions) (*Exec, error) { + if len(opts.Env) > 0 && c.serverAPIVersion.LessThan(apiVersion125) { + return nil, errors.New("exec configuration Env is only supported in API#1.25 and above") + } path := fmt.Sprintf("/containers/%s/exec", opts.Container) resp, err := c.do("POST", path, doOptions{data: opts, context: opts.Context}) if err != nil { diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/network.go b/agent/vendor/github.com/fsouza/go-dockerclient/network.go index 295efd565dd..b79b67cd58f 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/network.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/network.go @@ -125,8 +125,9 @@ type CreateNetworkOptions struct { // // See https://goo.gl/T8kRVH for more details. type IPAMOptions struct { - Driver string `json:"Driver" yaml:"Driver" toml:"Driver"` - Config []IPAMConfig `json:"Config" yaml:"Config" toml:"Config"` + Driver string `json:"Driver" yaml:"Driver" toml:"Driver"` + Config []IPAMConfig `json:"Config" yaml:"Config" toml:"Config"` + Options map[string]string `json:"Options" yaml:"Options" toml:"Options"` } // IPAMConfig represents IPAM configurations diff --git a/agent/vendor/github.com/fsouza/go-dockerclient/service.go b/agent/vendor/github.com/fsouza/go-dockerclient/service.go index fa6c96d8376..33af547c6e5 100644 --- a/agent/vendor/github.com/fsouza/go-dockerclient/service.go +++ b/agent/vendor/github.com/fsouza/go-dockerclient/service.go @@ -6,9 +6,11 @@ package docker import ( "encoding/json" + "io" "net/http" "net/url" "strconv" + "time" "github.com/docker/docker/api/types/swarm" "golang.org/x/net/context" @@ -167,3 +169,48 @@ func (c *Client) ListServices(opts ListServicesOptions) ([]swarm.Service, error) } return services, nil } + +// LogsServiceOptions represents the set of options used when getting logs from a +// service. +type LogsServiceOptions struct { + Context context.Context + Service string `qs:"-"` + OutputStream io.Writer `qs:"-"` + ErrorStream io.Writer `qs:"-"` + InactivityTimeout time.Duration `qs:"-"` + Tail string + + // Use raw terminal? Usually true when the container contains a TTY. + RawTerminal bool `qs:"-"` + Since int64 + Follow bool + Stdout bool + Stderr bool + Timestamps bool + Details bool +} + +// GetServiceLogs gets stdout and stderr logs from the specified service. +// +// When LogsServiceOptions.RawTerminal is set to false, go-dockerclient will multiplex +// the streams and send the containers stdout to LogsServiceOptions.OutputStream, and +// stderr to LogsServiceOptions.ErrorStream. +// +// When LogsServiceOptions.RawTerminal is true, callers will get the raw stream on +// LogsServiceOptions.OutputStream. +func (c *Client) GetServiceLogs(opts LogsServiceOptions) error { + if opts.Service == "" { + return &NoSuchService{ID: opts.Service} + } + if opts.Tail == "" { + opts.Tail = "all" + } + path := "/services/" + opts.Service + "/logs?" + queryString(opts) + return c.stream("GET", path, streamOptions{ + setRawTerminal: opts.RawTerminal, + stdout: opts.OutputStream, + stderr: opts.ErrorStream, + inactivityTimeout: opts.InactivityTimeout, + context: opts.Context, + }) +} From e8886ec8b9c48b981aed7e93f5bc1fc35444795b Mon Sep 17 00:00:00 2001 From: richardpen Date: Fri, 29 Sep 2017 17:09:45 +0000 Subject: [PATCH 24/58] engine: added buffer for docker events --- agent/engine/docker_container_engine.go | 13 +++- agent/engine/docker_container_engine_test.go | 2 +- agent/engine/docker_events_buffer.go | 76 ++++++++++++++++++++ agent/engine/docker_events_buffer_test.go | 42 +++++++++++ 4 files changed, 130 insertions(+), 3 deletions(-) create mode 100644 agent/engine/docker_events_buffer.go create mode 100644 agent/engine/docker_events_buffer_test.go diff --git a/agent/engine/docker_container_engine.go b/agent/engine/docker_container_engine.go index 4a25e37ef61..82f99b6e76e 100644 --- a/agent/engine/docker_container_engine.go +++ b/agent/engine/docker_container_engine.go @@ -42,6 +42,8 @@ const ( dockerDefaultTag = "latest" // imageNameFormat is the name of a image may look like: repo:tag imageNameFormat = "%s:%s" + // the buffer size will ensure agent doesn't miss any event from docker + dockerEventBufferSize = 100 ) // Timelimits for docker operations enforced above docker @@ -734,18 +736,25 @@ func (dg *dockerGoClient) ContainerEvents(ctx context.Context) (<-chan DockerCon if err != nil { return nil, err } + dockerEvents := make(chan *docker.APIEvents, dockerEventBufferSize) events := make(chan *docker.APIEvents) + buffer := NewInfiniteBuffer() - err = client.AddEventListener(events) + err = client.AddEventListener(dockerEvents) if err != nil { log.Error("Unable to add a docker event listener", "err", err) return nil, err } go func() { <-ctx.Done() - client.RemoveEventListener(events) + client.RemoveEventListener(dockerEvents) }() + // Cache the event from go docker client + go buffer.Serve(dockerEvents) + // Read the buffered events and send to task engine + go buffer.Consume(events) + changedContainers := make(chan DockerContainerChangeEvent) go func() { diff --git a/agent/engine/docker_container_engine_test.go b/agent/engine/docker_container_engine_test.go index 9bc2c09772e..a3bf760f22c 100644 --- a/agent/engine/docker_container_engine_test.go +++ b/agent/engine/docker_container_engine_test.go @@ -582,7 +582,7 @@ func TestContainerEvents(t *testing.T) { for i := 0; i < 2; i++ { anEvent := <-dockerEvents - if anEvent.DockerID != "cid3"+strconv.Itoa(i) { + if anEvent.DockerID != "cid30" && anEvent.DockerID != "cid31" { t.Error("Wrong container id: " + anEvent.DockerID) } if anEvent.Status != api.ContainerStopped { diff --git a/agent/engine/docker_events_buffer.go b/agent/engine/docker_events_buffer.go new file mode 100644 index 00000000000..c83ae559b41 --- /dev/null +++ b/agent/engine/docker_events_buffer.go @@ -0,0 +1,76 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package engine + +import ( + docker "github.com/fsouza/go-dockerclient" + "sync" +) + +// InfiniteBuffer defines an unlimited buffer, where it reads from +// input channel and write to output channel. +type InfiniteBuffer struct { + events []*docker.APIEvents + empty bool + waitDone chan struct{} + count int + lock sync.RWMutex +} + +// NewInfiniteBuffer returns an InfiniteBuffer object +func NewInfiniteBuffer() *InfiniteBuffer { + return &InfiniteBuffer{ + waitDone: make(chan struct{}), + } +} + +// Serve starts reading from the input channel and writes to the buffer +func (buffer *InfiniteBuffer) Serve(events chan *docker.APIEvents) { + for event := range events { + go buffer.Write(event) + } +} + +// Write writes the event into the buffer +func (buffer *InfiniteBuffer) Write(event *docker.APIEvents) { + buffer.lock.Lock() + defer buffer.lock.Unlock() + + // TODO filter the event type + buffer.events = append(buffer.events, event) + if buffer.empty { + buffer.empty = false + buffer.waitDone <- struct{}{} + } +} + +// Consume reads the buffer and write to a listener channel +func (buffer *InfiniteBuffer) Consume(in chan<- *docker.APIEvents) { + for { + buffer.lock.Lock() + + if len(buffer.events) == 0 { + buffer.empty = true + buffer.lock.Unlock() + // wait event + <-buffer.waitDone + } else { + event := buffer.events[0] + buffer.events = buffer.events[1:] + buffer.lock.Unlock() + + in <- event + } + } +} diff --git a/agent/engine/docker_events_buffer_test.go b/agent/engine/docker_events_buffer_test.go new file mode 100644 index 00000000000..5a2533ef64f --- /dev/null +++ b/agent/engine/docker_events_buffer_test.go @@ -0,0 +1,42 @@ +// Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"). You may +// not use this file except in compliance with the License. A copy of the +// License is located at +// +// http://aws.amazon.com/apache2.0/ +// +// or in the "license" file accompanying this file. This file is distributed +// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +// express or implied. See the License for the specific language governing +// permissions and limitations under the License. + +package engine + +import ( + "strconv" + "testing" + + docker "github.com/fsouza/go-dockerclient" +) + +func TestProduceConsume(t *testing.T) { + buffer := NewInfiniteBuffer() + producer := make(chan *docker.APIEvents) + consumer := make(chan *docker.APIEvents) + + // Start the process of producer and consumer + go buffer.Serve(producer) + go buffer.Consume(consumer) + + // writing multiple events to the buffer + go func() { + for i := 0; i < 10000; i++ { + producer <- &docker.APIEvents{ID: strconv.Itoa(i)} + } + }() + + for i := 0; i < 10000; i++ { + <-consumer + } +} From cd318a2e466601f7eb417d60e9921c29bc654f4d Mon Sep 17 00:00:00 2001 From: richardpen Date: Fri, 29 Sep 2017 17:48:49 +0000 Subject: [PATCH 25/58] docker event: filter event type before writing to buffer --- agent/engine/docker_events_buffer.go | 18 +++++++++++++- agent/engine/docker_events_buffer_test.go | 29 ++++++++++++++++++++++- 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/agent/engine/docker_events_buffer.go b/agent/engine/docker_events_buffer.go index c83ae559b41..784444419ba 100644 --- a/agent/engine/docker_events_buffer.go +++ b/agent/engine/docker_events_buffer.go @@ -18,6 +18,12 @@ import ( "sync" ) +const ( + containerTypeEvent = "container" +) + +var ignoredDockerEvents = []string{"rename", "kill", "destroy", "pause", "exec_create", "exec_start", "top", "attach", "export", "pull", "push", "tag", "untag", "import", "delete"} + // InfiniteBuffer defines an unlimited buffer, where it reads from // input channel and write to output channel. type InfiniteBuffer struct { @@ -44,10 +50,20 @@ func (buffer *InfiniteBuffer) Serve(events chan *docker.APIEvents) { // Write writes the event into the buffer func (buffer *InfiniteBuffer) Write(event *docker.APIEvents) { + if event.ID == "" || event.Type != containerTypeEvent { + return + } + + // Ignore events not interested + for _, ignoredEvent := range ignoredDockerEvents { + if event.Status == ignoredEvent { + return + } + } + buffer.lock.Lock() defer buffer.lock.Unlock() - // TODO filter the event type buffer.events = append(buffer.events, event) if buffer.empty { buffer.empty = false diff --git a/agent/engine/docker_events_buffer_test.go b/agent/engine/docker_events_buffer_test.go index 5a2533ef64f..51d9a5ec301 100644 --- a/agent/engine/docker_events_buffer_test.go +++ b/agent/engine/docker_events_buffer_test.go @@ -18,6 +18,7 @@ import ( "testing" docker "github.com/fsouza/go-dockerclient" + "github.com/stretchr/testify/assert" ) func TestProduceConsume(t *testing.T) { @@ -32,7 +33,11 @@ func TestProduceConsume(t *testing.T) { // writing multiple events to the buffer go func() { for i := 0; i < 10000; i++ { - producer <- &docker.APIEvents{ID: strconv.Itoa(i)} + producer <- &docker.APIEvents{ + ID: strconv.Itoa(i), + Type: containerTypeEvent, + Status: "die", + } } }() @@ -40,3 +45,25 @@ func TestProduceConsume(t *testing.T) { <-consumer } } + +func TestIgnoreEvents(t *testing.T) { + buffer := NewInfiniteBuffer() + producer := make(chan *docker.APIEvents) + consumer := make(chan *docker.APIEvents) + + // Start the process of producer and consumer + go buffer.Serve(producer) + go buffer.Consume(consumer) + + // event with empty ID + producer <- &docker.APIEvents{Type: containerTypeEvent, Status: "stop"} + // event with wrong type + producer <- &docker.APIEvents{ID: "id", Status: "stop", Type: "image"} + for _, event := range ignoredDockerEvents { + producer <- &docker.APIEvents{ID: "id", Type: containerTypeEvent, Status: event} + } + + buffer.lock.Lock() + defer buffer.lock.Unlock() + assert.Len(t, buffer.events, 0) +} From 43f36c674c8587fbca4251aea1030f6cd49b21eb Mon Sep 17 00:00:00 2001 From: richardpen Date: Tue, 3 Oct 2017 19:13:52 +0000 Subject: [PATCH 26/58] task manager: reduce steady state check interval to 5 mins and refactor --- agent/engine/docker_container_engine.go | 2 +- agent/engine/docker_events_buffer.go | 59 ++++++++++++----------- agent/engine/docker_events_buffer_test.go | 8 +-- agent/engine/task_manager.go | 2 +- 4 files changed, 37 insertions(+), 34 deletions(-) diff --git a/agent/engine/docker_container_engine.go b/agent/engine/docker_container_engine.go index 82f99b6e76e..7a14547dacb 100644 --- a/agent/engine/docker_container_engine.go +++ b/agent/engine/docker_container_engine.go @@ -751,7 +751,7 @@ func (dg *dockerGoClient) ContainerEvents(ctx context.Context) (<-chan DockerCon }() // Cache the event from go docker client - go buffer.Serve(dockerEvents) + go buffer.StartListening(dockerEvents) // Read the buffered events and send to task engine go buffer.Consume(events) diff --git a/agent/engine/docker_events_buffer.go b/agent/engine/docker_events_buffer.go index 784444419ba..8f5f9699bbd 100644 --- a/agent/engine/docker_events_buffer.go +++ b/agent/engine/docker_events_buffer.go @@ -19,55 +19,56 @@ import ( ) const ( + // TODO add support for filter in go-dockerclient containerTypeEvent = "container" ) -var ignoredDockerEvents = []string{"rename", "kill", "destroy", "pause", "exec_create", "exec_start", "top", "attach", "export", "pull", "push", "tag", "untag", "import", "delete"} +var containerEvents = []string{"create", "start", "stop", "die", "restart", "oom"} // InfiniteBuffer defines an unlimited buffer, where it reads from // input channel and write to output channel. type InfiniteBuffer struct { - events []*docker.APIEvents - empty bool - waitDone chan struct{} - count int - lock sync.RWMutex + events []*docker.APIEvents + empty bool + waitForEvent sync.WaitGroup + count int + lock sync.RWMutex } // NewInfiniteBuffer returns an InfiniteBuffer object func NewInfiniteBuffer() *InfiniteBuffer { - return &InfiniteBuffer{ - waitDone: make(chan struct{}), - } + return &InfiniteBuffer{} } -// Serve starts reading from the input channel and writes to the buffer -func (buffer *InfiniteBuffer) Serve(events chan *docker.APIEvents) { +// StartListening starts reading from the input channel and writes to the buffer +func (buffer *InfiniteBuffer) StartListening(events chan *docker.APIEvents) { for event := range events { - go buffer.Write(event) + go buffer.CopyEvents(event) } } -// Write writes the event into the buffer -func (buffer *InfiniteBuffer) Write(event *docker.APIEvents) { +// CopyEvents copies the event into the buffer +func (buffer *InfiniteBuffer) CopyEvents(event *docker.APIEvents) { if event.ID == "" || event.Type != containerTypeEvent { return } - // Ignore events not interested - for _, ignoredEvent := range ignoredDockerEvents { - if event.Status == ignoredEvent { - return - } - } + // Only add the events agent is interested + for _, containerEvent := range containerEvents { + if event.Status == containerEvent { + buffer.lock.Lock() + defer buffer.lock.Unlock() - buffer.lock.Lock() - defer buffer.lock.Unlock() + buffer.events = append(buffer.events, event) + // Check if there is consumer waiting for events + if buffer.empty { + buffer.empty = false - buffer.events = append(buffer.events, event) - if buffer.empty { - buffer.empty = false - buffer.waitDone <- struct{}{} + // Unblock the consumer + buffer.waitForEvent.Done() + } + return + } } } @@ -77,15 +78,17 @@ func (buffer *InfiniteBuffer) Consume(in chan<- *docker.APIEvents) { buffer.lock.Lock() if len(buffer.events) == 0 { + // Mark the buffer as empty and start waiting for events buffer.empty = true + buffer.waitForEvent.Add(1) buffer.lock.Unlock() - // wait event - <-buffer.waitDone + buffer.waitForEvent.Wait() } else { event := buffer.events[0] buffer.events = buffer.events[1:] buffer.lock.Unlock() + // Send event to the buffer listener in <- event } } diff --git a/agent/engine/docker_events_buffer_test.go b/agent/engine/docker_events_buffer_test.go index 51d9a5ec301..61af0824f43 100644 --- a/agent/engine/docker_events_buffer_test.go +++ b/agent/engine/docker_events_buffer_test.go @@ -27,7 +27,7 @@ func TestProduceConsume(t *testing.T) { consumer := make(chan *docker.APIEvents) // Start the process of producer and consumer - go buffer.Serve(producer) + go buffer.StartListening(producer) go buffer.Consume(consumer) // writing multiple events to the buffer @@ -52,15 +52,15 @@ func TestIgnoreEvents(t *testing.T) { consumer := make(chan *docker.APIEvents) // Start the process of producer and consumer - go buffer.Serve(producer) + go buffer.StartListening(producer) go buffer.Consume(consumer) // event with empty ID producer <- &docker.APIEvents{Type: containerTypeEvent, Status: "stop"} // event with wrong type producer <- &docker.APIEvents{ID: "id", Status: "stop", Type: "image"} - for _, event := range ignoredDockerEvents { - producer <- &docker.APIEvents{ID: "id", Type: containerTypeEvent, Status: event} + for _, event := range containerEvents { + producer <- &docker.APIEvents{ID: "id", Type: containerTypeEvent, Status: event + "invalid"} } buffer.lock.Lock() diff --git a/agent/engine/task_manager.go b/agent/engine/task_manager.go index 80413b91517..6056d457531 100644 --- a/agent/engine/task_manager.go +++ b/agent/engine/task_manager.go @@ -25,7 +25,7 @@ import ( ) const ( - steadyStateTaskVerifyInterval = 10 * time.Minute + steadyStateTaskVerifyInterval = 5 * time.Minute stoppedSentWaitInterval = 30 * time.Second maxStoppedWaitTimes = 72 * time.Hour / stoppedSentWaitInterval taskUnableToTransitionToStoppedReason = "TaskStateError: Agent could not progress task's state to stopped" From 1045da5d13b567d7cf48e2cc6bd04343ce6ad0fa Mon Sep 17 00:00:00 2001 From: richardpen Date: Fri, 6 Oct 2017 21:52:52 +0000 Subject: [PATCH 27/58] engine: remove the filter docker events code The docker events filter part has been moved to docker_events_buffer --- agent/engine/docker_container_engine.go | 53 ------------------------- 1 file changed, 53 deletions(-) diff --git a/agent/engine/docker_container_engine.go b/agent/engine/docker_container_engine.go index 7a14547dacb..5294e3b220b 100644 --- a/agent/engine/docker_container_engine.go +++ b/agent/engine/docker_container_engine.go @@ -759,11 +759,6 @@ func (dg *dockerGoClient) ContainerEvents(ctx context.Context) (<-chan DockerCon go func() { for event := range events { - // currently only container events type needs to be handled - if event.Type != "container" || event.ID == "" { - continue - } - containerID := event.ID log.Debug("Got event from docker daemon", "event", event) @@ -777,23 +772,6 @@ func (dg *dockerGoClient) ContainerEvents(ctx context.Context) (<-chan DockerCon fallthrough case "die": status = api.ContainerStopped - case "kill": - fallthrough - case "rename": - // TODO, ensure this wasn't one of our containers. This isn't critical - // because we typically have the docker id stored too and a wrong name - // won't be fatal once we do - continue - case "restart": - case "resize": - case "unpause": - case "destroy": - // container remove events doesn't need to be handled by ecs agent - // as it has already moved to stopped before this event - continue - - // These result in us falling through to inspect the container, some - // out of caution, some because it's a form of state change case "oom": containerInfo := event.ID // events only contain the container's name in newer Docker API @@ -806,39 +784,8 @@ func (dg *dockerGoClient) ContainerEvents(ctx context.Context) (<-chan DockerCon // "oom" can either means any process got OOM'd, but doesn't always // mean the container dies (non-init processes). If the container also // dies, you see a "die" status as well; we'll update suitably there - fallthrough - case "pause": - // non image events that aren't of interest currently - fallthrough - case "exec_create": - fallthrough - case "exec_start": - fallthrough - case "top": - fallthrough - case "attach": - fallthrough - // image events - case "export": - fallthrough - case "pull": - fallthrough - case "push": - fallthrough - case "tag": - fallthrough - case "untag": - fallthrough - case "import": - fallthrough - case "delete": - // No interest in image events continue default: - if strings.HasPrefix(event.Status, "exec_create:") || strings.HasPrefix(event.Status, "exec_start:") { - continue - } - // Because docker emits new events even when you use an old event api // version, it's not that big a deal seelog.Debugf("Unknown status event from docker: %s", event.Status) From 6817a2350d51b15789a94e26b07ca99e9a8e4332 Mon Sep 17 00:00:00 2001 From: Adnan Khan Date: Tue, 10 Oct 2017 15:49:29 -0700 Subject: [PATCH 28/58] readme: reword metadata option description --- README.md | 4 ++-- agent/api/container.go | 2 +- agent/containermetadata/manager.go | 2 ++ 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 52162751792..1ee0d31d5b7 100644 --- a/README.md +++ b/README.md @@ -179,8 +179,8 @@ configure them as something other than the defaults. | `ECS_CNI_PLUGINS_PATH` | `/ecs/cni` | The path where the cni binary file is located | `/amazon-ecs-cni-plugins` | Not applicable | | `ECS_AWSVPC_BLOCK_IMDS` | `true` | Whether to block access to [Instance Metdata](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) for Tasks started with `awsvpc` network mode | `false` | Not applicable | | `ECS_AWSVPC_ADDITIONAL_LOCAL_ROUTES` | `["10.0.15.0/24"]` | In `awsvpc` network mode, traffic to these prefixes will be routed via the host bridge instead of the task ENI | `[]` | Not applicable | -| `ECS_ENABLE_CONTAINER_METADATA` | `` | Whether to enable creation of a metadata file in the containers. If enabled the agent will inject a file with the container's various metadata and the user can access the container's metadata internally by accessing the environment variable $ECS_CONTAINER_METADATA_FILE. | `false` | `false` | -| `ECS_HOST_DATA_DIR` | `/var/lib/ecs` | The source directory on the host from which ECS_DATADIR is mounted. We use this to determine the source mount path for container metadata files in the case the Agent is run in a container. We do not use this value in Windows because the Agent is not run on a container in Windows. | `/var/lib/ecs` | `Not used` | +| `ECS_ENABLE_CONTAINER_METADATA` | `true` | When `true`, the agent will create a file describing the container's metadata and the file can be located and consumed by using the container enviornment variable `$ECS_CONTAINER_METADATA_FILE` | `false` | `false` | +| `ECS_HOST_DATA_DIR` | `/var/lib/ecs` | The source directory on the host from which ECS_DATADIR is mounted. We use this to determine the source mount path for container metadata files in the case the ECS Agent is running as a container. We do not use this value in Windows because the ECS Agent is not running as container in Windows. | `/var/lib/ecs` | `Not used` | ### Persistence diff --git a/agent/api/container.go b/agent/api/container.go index b0efb8cc6cc..d0a14b9e87e 100644 --- a/agent/api/container.go +++ b/agent/api/container.go @@ -322,7 +322,7 @@ func (c *Container) IsRunning() bool { return c.GetKnownStatus().IsRunning() } -// IsMetadataFileUpdated() returns true if the metadata file has been once the +// IsMetadataFileUpdated returns true if the metadata file has been once the // metadata file is ready and will no longer change func (c *Container) IsMetadataFileUpdated() bool { c.lock.RLock() diff --git a/agent/containermetadata/manager.go b/agent/containermetadata/manager.go index dc40abb76d1..e9741c176ab 100644 --- a/agent/containermetadata/manager.go +++ b/agent/containermetadata/manager.go @@ -27,6 +27,8 @@ import ( ) const ( + // metadataEnvironmentVariable is the enviornment variable passed to the + // container for the metadata file path. metadataEnvironmentVariable = "ECS_CONTAINER_METADATA_FILE" inspectContainerTimeout = 30 * time.Second metadataFile = "ecs-container-metadata.json" From 1ffaff3b0bd22340b2ed03ecd57d5a2e74ef8a47 Mon Sep 17 00:00:00 2001 From: richardpen Date: Tue, 14 Feb 2017 21:17:26 +0000 Subject: [PATCH 29/58] Adding proposal for container metadata service --- proposals/metadata.md | 103 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 proposals/metadata.md diff --git a/proposals/metadata.md b/proposals/metadata.md new file mode 100644 index 00000000000..58aa0c1f125 --- /dev/null +++ b/proposals/metadata.md @@ -0,0 +1,103 @@ + + +### Container metadata feature +In order to solve the issues related to container metadata like: [#288](https://github.com/aws/amazon-ecs-agent/issues/288) and [#456](https://github.com/aws/amazon-ecs-agent/issues/456), we are considering adding a new feature "Container Metadata" similar to [EC2 Instance Metadata Service](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) in ECS agent to provide the container metadata. + +By adding this feature, you can query the information about the task, container and container instance from within the container or from the container instance by reading the metadata file for each container. The following information will be available from this feature: + * Information from Docker: + * Container Network Information + * Container ID from Docker + * Container Name + * Image Name + * Image ID + * Port Mapping + * Information from ECS: + * Cluster Arn + * Container Instance Arn + * Task Arn + +ECS agent will create a file for each container under the directory `/var/lib/ecs/data/` and then mount the file to the container under a directory eg: `/ecs/metadata` with read only permission when the container is being created. Also an environment variable denoting the file path eg: `ECS_CONTAINER_METADATA_FILE` will be injected into the container. The `ECS_CONTAINER_METADATA_FILE` is consisted of several parts like: "/ecs/metadata/container_name_from_task_definition/metadata.json". After the container is started, ECS agent will update the metadata of container into this file. Then the container can get its metada information by parsing the json file with path `ECS_CONTAINER_METADATA_FILE`. This directory will be removed when task is being clean up. Also this feature will be configurable from the environment variable or in the task definition, eg: adding a field `"metadataEnable": true`. The detailed steps when start a container will be: +* Check whether the feature is enabled, if not then go directly create and start the container. +* Check the task definition make sure the path `/ecs` is not mounted, if it's used in the task definition, then disable the feature. +* Create metadata file for each container under `/var/lib/ecs/data/` for each container. +* Create the container with the two extra steps: + * Mount the metadata file created above to a specific directory eg: `/ecs/metadata/` with read only permission for each container. + * Inject the metadata file path as an environment variable to the container eg: `ECS_CONTAINER_METADATA_FILE=/ecs/metadata/container1`. +* After the container is created, write the basic metadata information into the metadata file. +* Start the container and update the networking information into the metadata file. +* When the container is removed during task cleanup, remove the metadata file from disk. + +For windows, the mount is a little different like: `%ProgramData%\Amazon\ECS\data` on the host, and `C:\Amazon\ECS\metadata` inside the container. + +Information contained in the metadata file will look like: +```json +{ + "Version": "v1", + "Status": "created", + "ClusterArn": "arn:aws:ecs:us-west-2:xxxxxxxx:cluster/test", + "Container_Instance": "arn:aws:ecs:us-west-2:xxxxxxxx:container-instance/732d1a0b-acbe-43e4-8358-f477d83eab03", + "TaskArn": "", + "ImageName": "ubuntu", + "ImageID": "04bbc221d46d3e5eb86c046f22878a8053247ce9b1e6b0a24495b171f9d20025", + "ContainerID": "ef3dabed9bef087ed147024a221d2d3a822e85d53c0ca4024d3d78e7913eeb64", + "PortMappings": [{ + "ContainerPort" : 80, + "HostPort": 80, + "BindIP": "", + "Protocol": "tcp" + }], + "NetworkMode": "bridge", + "Gateway": "172.17.0.1", + "IPAddress": "172.17.0.2", + "IPv6Gateway": "", + "LastUpdatedAt": "1487102643" +} +``` + +General use case: +``` ++-----------------------------------------------------------+ +| Containers in task1 Containers in task2 | +| +----------+ +-----------+ +------------+ | +| | | | | | | | +| | /path/c1 | | /path/c2 | | /path/c3 | | +| +----------+ +-----------+ +------------+ | +| | +| Host | +| /path/metadata/task1/c1 | +| /path/metadata/task1/c2 | +| /path/metadata/task2/c3 | +| | ++-----------------------------------------------------------+ +``` + +For containers use "--volumes-from", eg: container 2 started with "--volumes-from c1" +``` ++-----------------------------------------------------------+ +| Containers in task1 Containers in task2 | +| +----------+ +-----------+ +------------+ | +| | c1 | | c2 | | c3 | | +| | /path/c1 | | /path/c2 | | /path/c3 | | +| | | | /path/c1 | | | | +| +----------+ +-----------+ +------------+ | +| | +| Host | +| /path/metadata/task1/c1 | +| /path/metadata/task1/c2 | +| /path/metadata/task2/c3 | +| | ++-----------------------------------------------------------+ +``` From 01d1bef61a4687228b815fd3cd0eb498d2a99522 Mon Sep 17 00:00:00 2001 From: richardpen Date: Mon, 16 Oct 2017 18:19:29 +0000 Subject: [PATCH 30/58] logging: revert default log level to info --- agent/logger/log.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/agent/logger/log.go b/agent/logger/log.go index 15a84c75003..9039442b5c4 100644 --- a/agent/logger/log.go +++ b/agent/logger/log.go @@ -25,7 +25,7 @@ const ( LOGLEVEL_ENV_VAR = "ECS_LOGLEVEL" LOGFILE_ENV_VAR = "ECS_LOGFILE" - DEFAULT_LOGLEVEL = "debug" + DEFAULT_LOGLEVEL = "info" ) var logfile string From 7aebdb5bea0ab8d0da74efae63c791242605ea39 Mon Sep 17 00:00:00 2001 From: Sharanya Devaraj Date: Thu, 12 Oct 2017 21:59:40 +0000 Subject: [PATCH 31/58] dockerclient: Agent supported Docker versions from client min,API Versions Finding agent supported Docker versions by getting the default client version and if the min API version is present, add all the clients between min API version and API version supported, else follow current logic --- CHANGELOG.md | 4 +- .../dockerclient/dockerclientfactory.go | 78 +++++++++++++++++-- .../dockerclient/dockerclientfactory_test.go | 62 ++++++++++++++- .../dockerclientfactory_unix_test.go | 4 +- .../dockerclientfactory_windows_test.go | 6 +- .../dockerclient/versionsupport_unix.go | 4 + .../dockerclient/versionsupport_windows.go | 8 +- 7 files changed, 148 insertions(+), 18 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3f30803bf2c..3773ac5e123 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,12 +2,14 @@ ## UNRELEASED * Feature - Support for provisioning Tasks with ENIs +* Bug - Fixed a bug where unsupported Docker API client versions could be registered +[#1014](https://github.com/aws/amazon-ecs-agent/pull/1014) ## 1.14.5 * Enhancement - Retry failed container image pull operations [#975](https://github.com/aws/amazon-ecs-agent/pull/975) * Enhancement - Set read and write timeouts for websocket connectons [#993](https://github.com/aws/amazon-ecs-agent/pull/993) * Enhancement - Add support for the SumoLogic Docker log driver plugin - [#992](https://github.com/aws/amazon-ecs-agent/pull/992) + [#992](https://github.com/aws/amazon-ecs-agent/pull/992) * Bug - Fixed a memory leak issue when submitting the task state change [#967](https://github.com/aws/amazon-ecs-agent/pull/967) * Bug - Fixed a race condition where a container can be created twice when agent restarts. [#939](https://github.com/aws/amazon-ecs-agent/pull/939) * Bug - Fixed an issue where `microsoft/windowsservercore:latest` was not diff --git a/agent/engine/dockerclient/dockerclientfactory.go b/agent/engine/dockerclient/dockerclientfactory.go index b5dd9bc3a9f..9b869b346b3 100644 --- a/agent/engine/dockerclient/dockerclientfactory.go +++ b/agent/engine/dockerclient/dockerclientfactory.go @@ -14,13 +14,23 @@ package dockerclient import ( - "errors" - "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface" + "github.com/aws/amazon-ecs-agent/agent/utils" log "github.com/cihub/seelog" docker "github.com/fsouza/go-dockerclient" + "github.com/pkg/errors" ) +const ( + // minAPIVersionKey is the docker.Env key for min API version + // This is supported in Docker API versions >=1.25 + // https://docs.docker.com/engine/api/version-history/#v125-api-changes + minAPIVersionKey = "MinAPIVersion" + // apiVersionKey is the docker.Env key for API version + apiVersionKey = "ApiVersion" + // zeroPatch is a string to append patch number zero if the major minor version lacks it + zeroPatch = ".0" +) // Factory provides a collection of docker remote clients that include a // recommended client version as well as a set of alternative supported // docker clients. @@ -110,19 +120,71 @@ func (f *factory) getClient(version DockerVersion) (dockeriface.Client, error) { // findDockerVersions loops over all known API versions and finds which ones // are supported by the docker daemon on the host func findDockerVersions(endpoint string) map[DockerVersion]dockeriface.Client { + // if the client version returns a MinAPIVersion and APIVersion, then use it to return + // all the Docker clients between MinAPIVersion and APIVersion, else try pinging + // the clients in getKnownAPIVersions + var minAPIVersion, apiVersion string + // get a Docker client with the default supported version + client, err := newVersionedClient(endpoint, string(minDockerAPIVersion)) + if err == nil { + clientVersion, err := client.Version() + if err == nil { + // check if the docker.Env obj has MinAPIVersion key + if clientVersion.Exists(minAPIVersionKey) { + minAPIVersion = clientVersion.Get(minAPIVersionKey) + } + // check if the docker.Env obj has APIVersion key + if clientVersion.Exists(apiVersionKey) { + apiVersion = clientVersion.Get(apiVersionKey) + } + } + } + clients := make(map[DockerVersion]dockeriface.Client) for _, version := range getKnownAPIVersions() { - client, err := newVersionedClient(endpoint, string(version)) + dockerClient, err := getDockerClientForVersion(endpoint, string(version), minAPIVersion, apiVersion) if err != nil { - log.Infof("Error while creating client: %v", err) + log.Infof("Unable to get Docker client for version %s: %v", version, err) continue } + clients[version] = dockerClient + } + return clients +} - err = client.Ping() +func getDockerClientForVersion( + endpoint string, + version string, + minAPIVersion string, + apiVersion string) (dockeriface.Client, error) { + if (minAPIVersion != "" && apiVersion != "") { + // Adding patch number zero to Docker versions to reuse the existing semver + // comparator + // TODO: remove this logic later when non-semver comparator is implemented + versionWithPatch := version + zeroPatch + lessThanMinCheck := "<" + minAPIVersion + zeroPatch + moreThanMaxCheck := ">" + apiVersion + zeroPatch + minVersionCheck, err := utils.Version(versionWithPatch).Matches(lessThanMinCheck) + if err != nil { + return nil, errors.Wrapf(err, "version detection using MinAPIVersion: unable to get min version: %s", minAPIVersion) + } + maxVersionCheck, err := utils.Version(versionWithPatch).Matches(moreThanMaxCheck) if err != nil { - log.Infof("Failed to ping with Docker version %s: %v", version, err) + return nil, errors.Wrapf(err, "version detection using MinAPIVersion: unable to get max version: %s", apiVersion) + } + // do not add the version when it is less than min api version or greater + // than api version + if minVersionCheck || maxVersionCheck { + return nil, errors.Errorf("version detection using MinAPIVersion: unsupported version: %s", version) } - clients[version] = client } - return clients + client, err := newVersionedClient(endpoint, string(version)) + if err != nil { + return nil, errors.Wrapf(err, "version detection check: unable to create Docker client for version: %s", version) + } + err = client.Ping() + if err != nil { + return nil, errors.Wrapf(err, "version detection check: failed to ping with Docker version: %s", string(version)) + } + return client, nil } diff --git a/agent/engine/dockerclient/dockerclientfactory_test.go b/agent/engine/dockerclient/dockerclientfactory_test.go index fa7a444a98a..e4f3e030988 100644 --- a/agent/engine/dockerclient/dockerclientfactory_test.go +++ b/agent/engine/dockerclient/dockerclientfactory_test.go @@ -21,6 +21,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface/mocks" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" + docker "github.com/fsouza/go-dockerclient" ) const expectedEndpoint = "expectedEndpoint" @@ -35,7 +36,8 @@ func TestGetDefaultClientSuccess(t *testing.T) { if version == string(getDefaultVersion()) { mockClient = expectedClient } - mockClient.EXPECT().Ping() + mockClient.EXPECT().Version().Return(&docker.Env{}, nil).AnyTimes() + mockClient.EXPECT().Ping().AnyTimes() return mockClient, nil } @@ -59,7 +61,8 @@ func TestFindSupportedAPIVersions(t *testing.T) { // Ensure that agent pings all known versions of Docker API for i := 0; i < len(allVersions); i++ { mockClients[string(allVersions[i])] = mock_dockeriface.NewMockClient(ctrl) - mockClients[string(allVersions[i])].EXPECT().Ping() + mockClients[string(allVersions[i])].EXPECT().Version().Return(&docker.Env{}, nil).AnyTimes() + mockClients[string(allVersions[i])].EXPECT().Ping().AnyTimes() } // Define the function for the mock client @@ -92,3 +95,58 @@ func TestVerifyAgentVersions(t *testing.T) { assert.True(t, isKnown(agentVersion)) } } + +func TestFindSupportedAPIVersionsFromMinAPIVersions(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + agentVersions := getAgentVersions() + allVersions := getKnownAPIVersions() + + // Set up the mocks and expectations + mockClients := make(map[string]*mock_dockeriface.MockClient) + + // Ensure that agent pings all known versions of Docker API + for i := 0; i < len(allVersions); i++ { + mockClients[string(allVersions[i])] = mock_dockeriface.NewMockClient(ctrl) + mockClients[string(allVersions[i])].EXPECT().Version().Return(&docker.Env{"MinAPIVersion=1.12","ApiVersion=1.27"}, nil).AnyTimes() + mockClients[string(allVersions[i])].EXPECT().Ping().AnyTimes() + } + + // Define the function for the mock client + // For simplicity, we will pretend all versions of docker are available + newVersionedClient = func(endpoint, version string) (dockeriface.Client, error) { + return mockClients[version], nil + } + + factory := NewFactory(expectedEndpoint) + actualVersions := factory.FindSupportedAPIVersions() + + assert.Equal(t, len(agentVersions), len(actualVersions)) + for i := 0; i < len(actualVersions); i++ { + assert.Equal(t, agentVersions[i], actualVersions[i]) + } +} + +func TestCompareDockerVersionsWithMinAPIVersion(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + minAPIVersion := "1.12" + apiVersion := "1.27" + versions := []string{"1.11", "1.29"} + rightVersion := "1.25" + + for _, version := range versions { + _, err := getDockerClientForVersion("endpoint", version, minAPIVersion, apiVersion) + assert.EqualError(t, err, "version detection using MinAPIVersion: unsupported version: " + version) + } + + mockClients := make(map[string]*mock_dockeriface.MockClient) + newVersionedClient = func(endpoint, version string) (dockeriface.Client, error) { + mockClients[version] = mock_dockeriface.NewMockClient(ctrl) + mockClients[version].EXPECT().Ping() + return mockClients[version], nil + } + client, _ := getDockerClientForVersion("endpoint", rightVersion, minAPIVersion, apiVersion) + assert.Equal(t, mockClients[rightVersion], client) +} diff --git a/agent/engine/dockerclient/dockerclientfactory_unix_test.go b/agent/engine/dockerclient/dockerclientfactory_unix_test.go index ed3af1fd0c0..9492495418e 100644 --- a/agent/engine/dockerclient/dockerclientfactory_unix_test.go +++ b/agent/engine/dockerclient/dockerclientfactory_unix_test.go @@ -21,6 +21,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface/mocks" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" + docker "github.com/fsouza/go-dockerclient" ) func TestGetClientCached(t *testing.T) { @@ -29,7 +30,8 @@ func TestGetClientCached(t *testing.T) { newVersionedClient = func(endpoint, version string) (dockeriface.Client, error) { mockClient := mock_dockeriface.NewMockClient(ctrl) - mockClient.EXPECT().Ping() + mockClient.EXPECT().Version().Return(&docker.Env{}, nil).AnyTimes() + mockClient.EXPECT().Ping().AnyTimes() return mockClient, nil } diff --git a/agent/engine/dockerclient/dockerclientfactory_windows_test.go b/agent/engine/dockerclient/dockerclientfactory_windows_test.go index 142d31e0422..a2c007d3f6c 100644 --- a/agent/engine/dockerclient/dockerclientfactory_windows_test.go +++ b/agent/engine/dockerclient/dockerclientfactory_windows_test.go @@ -21,6 +21,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface/mocks" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" + docker "github.com/fsouza/go-dockerclient" ) func TestGetClientMinimumVersion(t *testing.T) { @@ -31,10 +32,11 @@ func TestGetClientMinimumVersion(t *testing.T) { newVersionedClient = func(endpoint, version string) (dockeriface.Client, error) { mockClient := mock_dockeriface.NewMockClient(ctrl) - if version == string(MinDockerAPIWindows) { + if version == string(minDockerAPIVersion) { mockClient = expectedClient } - mockClient.EXPECT().Ping() + mockClient.EXPECT().Version().Return(&docker.Env{}, nil).AnyTimes() + mockClient.EXPECT().Ping().AnyTimes() return mockClient, nil } diff --git a/agent/engine/dockerclient/versionsupport_unix.go b/agent/engine/dockerclient/versionsupport_unix.go index 5dd82640b9a..37a45067329 100644 --- a/agent/engine/dockerclient/versionsupport_unix.go +++ b/agent/engine/dockerclient/versionsupport_unix.go @@ -18,6 +18,10 @@ import ( "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface" ) +const ( + // minDockerAPIVersion is the min Docker API version supported by agent + minDockerAPIVersion = Version_1_17 +) // GetClient on linux will simply return the cached client from the map func (f *factory) GetClient(version DockerVersion) (dockeriface.Client, error) { return f.getClient(version) diff --git a/agent/engine/dockerclient/versionsupport_windows.go b/agent/engine/dockerclient/versionsupport_windows.go index b075ba4acd7..0b6e1693ee1 100644 --- a/agent/engine/dockerclient/versionsupport_windows.go +++ b/agent/engine/dockerclient/versionsupport_windows.go @@ -18,14 +18,14 @@ import ( "github.com/aws/amazon-ecs-agent/agent/engine/dockeriface" ) -const MinDockerAPIWindows = Version_1_24 +const minDockerAPIVersion = Version_1_24 // GetClient will replace some versions of Docker on Windows. We need this because // agent assumes that it can always call older versions of the docker API. func (f *factory) GetClient(version DockerVersion) (dockeriface.Client, error) { for _, v := range getWindowsReplaceableVersions() { if v == version { - version = MinDockerAPIWindows + version = minDockerAPIVersion break } } @@ -48,10 +48,10 @@ func getWindowsReplaceableVersions() []DockerVersion { // getAgentVersions for Windows should return all of the replaceable versions plus additional versions func getAgentVersions() []DockerVersion { - return append(getWindowsReplaceableVersions(), MinDockerAPIWindows) + return append(getWindowsReplaceableVersions(), minDockerAPIVersion) } // getDefaultVersion returns agent's default version of the Docker API func getDefaultVersion() DockerVersion { - return MinDockerAPIWindows + return minDockerAPIVersion } From acab52b5d0407ed2e2d11dfcca35aa594cf952ea Mon Sep 17 00:00:00 2001 From: Sharanya Devaraj Date: Thu, 28 Sep 2017 20:34:15 +0000 Subject: [PATCH 32/58] engine/dockerclient: Add new Docker remote API version 1.25 support --- CHANGELOG.md | 4 +++- agent/engine/dockerclient/versionsupport_unix.go | 1 + 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3773ac5e123..147f2a3bd0f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,9 @@ ## UNRELEASED * Feature - Support for provisioning Tasks with ENIs * Bug - Fixed a bug where unsupported Docker API client versions could be registered -[#1014](https://github.com/aws/amazon-ecs-agent/pull/1014) + [#1014](https://github.com/aws/amazon-ecs-agent/pull/1014) +* Enhancement - Support `init` process in containers by adding support for Docker remote API client version 1.25 + [#996](https://github.com/aws/amazon-ecs-agent/pull/996) ## 1.14.5 * Enhancement - Retry failed container image pull operations [#975](https://github.com/aws/amazon-ecs-agent/pull/975) diff --git a/agent/engine/dockerclient/versionsupport_unix.go b/agent/engine/dockerclient/versionsupport_unix.go index 37a45067329..1dd3582421c 100644 --- a/agent/engine/dockerclient/versionsupport_unix.go +++ b/agent/engine/dockerclient/versionsupport_unix.go @@ -38,6 +38,7 @@ func getAgentVersions() []DockerVersion { Version_1_22, Version_1_23, Version_1_24, + Version_1_25, } } From d020b55b1d7bc859fd3dd01a08103776ac596e25 Mon Sep 17 00:00:00 2001 From: Aithal Date: Thu, 19 Oct 2017 18:37:13 +0000 Subject: [PATCH 33/58] ecs-cni-plugins: Updated to rev 2017.10.0@17438dd --- amazon-ecs-cni-plugins | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/amazon-ecs-cni-plugins b/amazon-ecs-cni-plugins index a9042d1c9d8..17438ddf497 160000 --- a/amazon-ecs-cni-plugins +++ b/amazon-ecs-cni-plugins @@ -1 +1 @@ -Subproject commit a9042d1c9d85831a641e58257a01b1957f94754e +Subproject commit 17438ddf497765b2c43bfad94d4c7d9c89b2be8e From 256bba0eb7a407b0bbbe3793ef6e016961fad282 Mon Sep 17 00:00:00 2001 From: Jacob Vallejo Date: Mon, 16 Oct 2017 14:58:23 -0700 Subject: [PATCH 34/58] scripts: fix usage string in ec2-stage --- scripts/ec2-stage | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/ec2-stage b/scripts/ec2-stage index 9086d8da958..aef8b9d5161 100755 --- a/scripts/ec2-stage +++ b/scripts/ec2-stage @@ -30,7 +30,7 @@ source $(dirname "${0}")/publishing-common.sh TARGET_OS_LIST=${SUPPORTED_OSES[@]} usage() { - echo "Usage: ${0} -b BUCKET -k SSH_KEY -s SECURITY_GROUP -i IAM_ROLE [OPTIONS]" + echo "Usage: ${0} -a ARTIFACT_BUCKET -t SOURCE_BUCKET -k SSH_KEY -s SECURITY_GROUP -i IAM_ROLE [OPTIONS]" echo echo "This script stages a new version of the Amazon EC2 Container Agent" echo "built on a freshly-launched EC2 instance." From 302d5bc701bc6f0f7e4be1937c4850632b962df8 Mon Sep 17 00:00:00 2001 From: Jacob Vallejo Date: Fri, 20 Oct 2017 11:25:29 -0700 Subject: [PATCH 35/58] Add flag to print Agent's ECS Attributes This adds a flag and handler to print the agent's ECS attributes (including capabilities) without completely starting and connecting the agent to ECS. --- agent/app/agent.go | 12 ++++++++++++ agent/app/args/flag.go | 9 +++++++-- agent/app/run.go | 14 +++++++++----- 3 files changed, 28 insertions(+), 7 deletions(-) diff --git a/agent/app/agent.go b/agent/app/agent.go index 07b44b6d80a..ae0a1a62e81 100644 --- a/agent/app/agent.go +++ b/agent/app/agent.go @@ -71,6 +71,9 @@ var ( type agent interface { // printVersion prints the Agent version string printVersion() int + // printECSAttributes prints the Agent's capabilities based on + // its environment + printECSAttributes() int // start starts the Agent execution start() int } @@ -163,6 +166,15 @@ func (agent *ecsAgent) printVersion() int { return exitcodes.ExitSuccess } +// printECSAttributes prints the Agent's ECS Attributes based on its +// environment +func (agent *ecsAgent) printECSAttributes() int { + for _, attr := range agent.capabilities() { + fmt.Printf("%s\t%s\n", aws.StringValue(attr.Name), aws.StringValue(attr.Value)) + } + return exitcodes.ExitSuccess +} + // start starts the ECS Agent func (agent *ecsAgent) start() int { sighandlers.StartDebugHandler() diff --git a/agent/app/args/flag.go b/agent/app/args/flag.go index f3088d01709..56b92569b98 100644 --- a/agent/app/args/flag.go +++ b/agent/app/args/flag.go @@ -21,9 +21,11 @@ const ( acceptInsecureCertUsage = "Disable SSL certificate verification. We do not recommend setting this option" licenseUsage = "Print the LICENSE and NOTICE files and exit" blacholeEC2MetadataUsage = "Blackhole the EC2 Metadata requests. Setting this option can cause the ECS Agent to fail to work properly. We do not recommend setting this option" + ecsAttributesUsage = "Print the Agent's ECS Attributes based on its environment" versionFlagName = "version" logLevelFlagName = "loglevel" + ecsAttributesFlagName = "ecs-attributes" acceptInsecureCertFlagName = "k" licenseFlagName = "license" blackholeEC2MetadataFlagName = "blackhole-ec2-metadata" @@ -35,14 +37,16 @@ type Args struct { Version *bool // LogLevel represents the ECS Agent's log level LogLevel *string - // AcceptInsecureCert indicates if SSL certificate verification shoule be - // disabled + // AcceptInsecureCert indicates if SSL certificate verification + // should be disabled AcceptInsecureCert *bool // License indicates if the license information should be printed License *bool // BlackholeEC2Metadata indicates if EC2 Metadata requests should be // blackholed BlackholeEC2Metadata *bool + // ECSAttributes indicates that the agent should print its attributes + ECSAttributes *bool } // New creates a new Args object from the argument list @@ -55,6 +59,7 @@ func New(arguments []string) (*Args, error) { AcceptInsecureCert: flagset.Bool(acceptInsecureCertFlagName, false, acceptInsecureCertUsage), License: flagset.Bool(licenseFlagName, false, licenseUsage), BlackholeEC2Metadata: flagset.Bool(blackholeEC2MetadataFlagName, false, blacholeEC2MetadataUsage), + ECSAttributes: flagset.Bool(ecsAttributesFlagName, false, ecsAttributesUsage), } err := flagset.Parse(arguments) diff --git a/agent/app/run.go b/agent/app/run.go index e25be2fee0f..487ed630f6e 100644 --- a/agent/app/run.go +++ b/agent/app/run.go @@ -49,11 +49,15 @@ func Run(arguments []string) int { return exitcodes.ExitError } - if *parsedArgs.Version { - // Print version and exit + switch { + case *parsedArgs.Version: + // Print Agent's version and exit return agent.printVersion() + case *parsedArgs.ECSAttributes: + // Print agent's ecs attributes based on its environment and exit + return agent.printECSAttributes() + default: + // Start the agent + return agent.start() } - - // Start the agent execution - return agent.start() } From f0a8445a3fdb7f6449b5f4b759984a91ace91cf6 Mon Sep 17 00:00:00 2001 From: Sharanya Devaraj Date: Mon, 23 Oct 2017 23:03:59 +0000 Subject: [PATCH 36/58] agent/stats: Fix flaky tests remove new godockerclient call in init method of unit tests and add to integ test --- agent/stats/common_test.go | 2 -- agent/stats/engine_integ_test.go | 6 ++++++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/agent/stats/common_test.go b/agent/stats/common_test.go index 8e3ae2106c1..459bd0bb139 100644 --- a/agent/stats/common_test.go +++ b/agent/stats/common_test.go @@ -58,13 +58,11 @@ var client, _ = docker.NewClient(endpoint) var clientFactory = dockerclient.NewFactory(endpoint) var cfg = config.DefaultConfig() -var dockerClient ecsengine.DockerClient var defaultCluster = "default" var defaultContainerInstance = "ci" func init() { cfg.EngineAuthData = config.NewSensitiveRawMessage([]byte{}) - dockerClient, _ = ecsengine.NewDockerGoClient(clientFactory, &cfg) } // eventStream returns the event stream used to receive container change events diff --git a/agent/stats/engine_integ_test.go b/agent/stats/engine_integ_test.go index 513f45f2ab3..001fdd93224 100644 --- a/agent/stats/engine_integ_test.go +++ b/agent/stats/engine_integ_test.go @@ -26,6 +26,12 @@ import ( docker "github.com/fsouza/go-dockerclient" ) +var dockerClient ecsengine.DockerClient + +func init() { + dockerClient, _ = ecsengine.NewDockerGoClient(clientFactory, &cfg) +} + func (resolver *IntegContainerMetadataResolver) addToMap(containerID string) { resolver.containerIDToTask[containerID] = &api.Task{ Arn: taskArn, From f3af574bd446e57259e293523540f0100ba2268e Mon Sep 17 00:00:00 2001 From: Samuel Karp Date: Tue, 24 Oct 2017 17:21:02 -0700 Subject: [PATCH 37/58] dockerstate: map keys differ before create The state.idToTask and state.idToContainer maps initially have the keys set to the generated DockerName rather than the DockerID. Once containers are created, the keys are changed to the DockerID. This changed as part of this commit: https://github.com/aws/amazon-ecs-agent/commit/49c36c7855d14155469a7796b35318da34743cf8#diff-464fc7e15d1a6b818ceca89e7b68cd4e. --- CHANGELOG.md | 3 +++ agent/engine/dockerstate/docker_task_engine_state.go | 11 +++++++++-- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 147f2a3bd0f..42291e3f9d3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,9 @@ [#1014](https://github.com/aws/amazon-ecs-agent/pull/1014) * Enhancement - Support `init` process in containers by adding support for Docker remote API client version 1.25 [#996](https://github.com/aws/amazon-ecs-agent/pull/996) +* Bug - Fixed a bug where tasks that fail to pull containers can cause the + agent to fail to restore properly after a restart. + [#1033](https://github.com/aws/amazon-ecs-agent/pull/1033) ## 1.14.5 * Enhancement - Retry failed container image pull operations [#975](https://github.com/aws/amazon-ecs-agent/pull/975) diff --git a/agent/engine/dockerstate/docker_task_engine_state.go b/agent/engine/dockerstate/docker_task_engine_state.go index 69e40950426..88ee05cc7b0 100644 --- a/agent/engine/dockerstate/docker_task_engine_state.go +++ b/agent/engine/dockerstate/docker_task_engine_state.go @@ -364,18 +364,25 @@ func (state *DockerTaskEngineState) RemoveTask(task *api.Task) { task, ok := state.tasks[task.Arn] if !ok { + seelog.Warnf("Failed to locate task %s for removal from state", task.Arn) return } delete(state.tasks, task.Arn) + containerMap, ok := state.taskToID[task.Arn] if !ok { + seelog.Warnf("Failed to locate containerMap for task %s for removal from state", task.Arn) return } delete(state.taskToID, task.Arn) for _, dockerContainer := range containerMap { - delete(state.idToTask, dockerContainer.DockerID) - delete(state.idToContainer, dockerContainer.DockerID) + key := dockerContainer.DockerID + if key == "" { + key = dockerContainer.DockerName + } + delete(state.idToTask, key) + delete(state.idToContainer, key) } } From 7b56419606b30fad2a0434d2384a3e0113f41899 Mon Sep 17 00:00:00 2001 From: Samuel Karp Date: Tue, 24 Oct 2017 20:32:14 -0700 Subject: [PATCH 38/58] dockerstate: Test add/removal with DockerName --- .../dockerstate/docker_task_engine_state.go | 2 ++ agent/engine/dockerstate/dockerstate_test.go | 36 ++++++++++++------- .../engine/dockerstate/testutils/json_test.go | 16 ++++----- 3 files changed, 31 insertions(+), 23 deletions(-) diff --git a/agent/engine/dockerstate/docker_task_engine_state.go b/agent/engine/dockerstate/docker_task_engine_state.go index 88ee05cc7b0..563b1a56f85 100644 --- a/agent/engine/dockerstate/docker_task_engine_state.go +++ b/agent/engine/dockerstate/docker_task_engine_state.go @@ -377,6 +377,8 @@ func (state *DockerTaskEngineState) RemoveTask(task *api.Task) { delete(state.taskToID, task.Arn) for _, dockerContainer := range containerMap { + // The key to these maps is either the Docker ID or agent-generated name. We use the agent-generated name + // before a Docker ID is available. key := dockerContainer.DockerID if key == "" { key = dockerContainer.DockerName diff --git a/agent/engine/dockerstate/dockerstate_test.go b/agent/engine/dockerstate/dockerstate_test.go index 38ed13c2d71..feb45dd6c6d 100644 --- a/agent/engine/dockerstate/dockerstate_test.go +++ b/agent/engine/dockerstate/dockerstate_test.go @@ -171,32 +171,42 @@ func TestTwophaseAddContainer(t *testing.T) { func TestRemoveTask(t *testing.T) { state := NewTaskEngineState() - testContainer := &api.Container{ + testContainer1 := &api.Container{ Name: "c1", } - testDockerContainer := &api.DockerContainer{ + testDockerContainer1 := &api.DockerContainer{ DockerID: "did", - Container: testContainer, + Container: testContainer1, + } + testContainer2 := &api.Container{ + Name: "c2", + } + testDockerContainer2 := &api.DockerContainer{ + // DockerName is used before the DockerID is assigned + DockerName: "docker-name-2", + Container: testContainer2, } testTask := &api.Task{ Arn: "t1", - Containers: []*api.Container{testContainer}, + Containers: []*api.Container{testContainer1, testContainer2}, } state.AddTask(testTask) - state.AddContainer(testDockerContainer, testTask) + state.AddContainer(testDockerContainer1, testTask) + state.AddContainer(testDockerContainer2, testTask) - tasks := state.AllTasks() - if len(tasks) != 1 { - t.Error("Expected only 1 task") - } + engineState := state.(*DockerTaskEngineState) + + assert.Len(t, state.AllTasks(), 1, "Expected one task") + assert.Len(t, engineState.idToTask, 2, "idToTask map should have two entries") + assert.Len(t, engineState.idToContainer, 2, "idToContainer map should have two entries") state.RemoveTask(testTask) - tasks = state.AllTasks() - if len(tasks) != 0 { - t.Error("Expected task to be removed") - } + assert.Len(t, state.AllTasks(), 0, "Expected task to be removed") + assert.Len(t, engineState.idToTask, 0, "idToTask map should be empty") + assert.Len(t, engineState.idToContainer, 0, "idToContainer map should be empty") + } func TestAddImageState(t *testing.T) { diff --git a/agent/engine/dockerstate/testutils/json_test.go b/agent/engine/dockerstate/testutils/json_test.go index 5ce925556b4..6db0a098eb9 100644 --- a/agent/engine/dockerstate/testutils/json_test.go +++ b/agent/engine/dockerstate/testutils/json_test.go @@ -22,6 +22,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/api" "github.com/aws/amazon-ecs-agent/agent/engine/dockerstate" + "github.com/stretchr/testify/assert" ) func createTestContainer(num int) *api.Container { @@ -50,14 +51,12 @@ func createTestTask(arn string, numContainers int) *api.Task { func decodeEqual(t *testing.T, state dockerstate.TaskEngineState) dockerstate.TaskEngineState { data, err := json.Marshal(&state) - if err != nil { - t.Error(err) - } + assert.NoError(t, err, "marshal state") + otherState := dockerstate.NewTaskEngineState() err = json.Unmarshal(data, &otherState) - if err != nil { - t.Error(err) - } + assert.NoError(t, err, "unmarshal state") + if !DockerStatesEqual(state, otherState) { debug.PrintStack() t.Error("States were not equal") @@ -77,8 +76,5 @@ func TestJsonEncoding(t *testing.T) { } other := decodeEqual(t, testState) _, ok := other.ContainerMapByArn("test1") - if !ok { - t.Error("Could not retrieve expected task") - } - + assert.True(t, ok, "could not retrieve expected task") } From 1a47e4e6823bdb6dc6d47b0745e2d5ff38b2ffbb Mon Sep 17 00:00:00 2001 From: Samuel Karp Date: Tue, 24 Oct 2017 22:10:14 -0700 Subject: [PATCH 39/58] functional_tests: Add test for restarting agent This test verifies that the agent can be restarted after a task with an invalid image is cleaned up. This test fails with v1.14.5 and passes after this commit. --- .../tests/functionaltests_test.go | 37 +++++++++++++++++++ agent/functional_tests/util/utils.go | 11 ++++++ agent/functional_tests/util/utils_unix.go | 15 ++++++-- 3 files changed, 60 insertions(+), 3 deletions(-) diff --git a/agent/functional_tests/tests/functionaltests_test.go b/agent/functional_tests/tests/functionaltests_test.go index 6e7b6e45009..f7d49e275cb 100644 --- a/agent/functional_tests/tests/functionaltests_test.go +++ b/agent/functional_tests/tests/functionaltests_test.go @@ -89,6 +89,43 @@ func TestSavedState(t *testing.T) { testTask.WaitStopped(1 * time.Minute) } +// TestSavedStateWithInvalidImageAndCleanup verifies that a task definition with an invalid image does not prevent the +// agnet from starting again after the task has been cleaned up. See +// https://github.com/aws/amazon-ecs-agent/issues/1024 for details. +func TestSavedStateWithInvalidImageAndCleanup(t *testing.T) { + // Set the task cleanup time to just over a minute. + os.Setenv("ECS_ENGINE_TASK_CLEANUP_WAIT_DURATION", "70s") + agent := RunAgent(t, nil) + defer func() { + agent.Cleanup() + os.Unsetenv("ECS_ENGINE_TASK_CLEANUP_WAIT_DURATION") + }() + + testTask, err := agent.StartTask(t, "invalid-image") + require.NoError(t, err, "failed to start task") + assert.NoError(t, testTask.ExpectErrorType("error", "CannotPullContainerError", 1*time.Minute)) + + resp, err := agent.CallTaskIntrospectionAPI(testTask) + assert.NoError(t, err, "should be able to introspect the task") + assert.NotNil(t, resp, "should receive a response") + assert.Equal(t, *testTask.TaskArn, resp.Arn, "arn should be equal") + + // wait two minutes for it to be cleaned up + fmt.Println("Sleeping...") + time.Sleep(2 * time.Minute) + + resp, err = agent.CallTaskIntrospectionAPI(testTask) + assert.NoError(t, err, "should be able to call introspection api") // is there a reason we don't 404? + assert.NotNil(t, resp, "should receive a response") // why? + assert.Equal(t, "", resp.Arn, "arn is blank") + + err = agent.StopAgent() + require.NoError(t, err, "failed to stop agent") + + err = agent.StartAgent() + require.NoError(t, err, "failed to start agent again") +} + // TestPortResourceContention verifies that running two tasks on the same port // in quick-succession does not result in the second one failing to run. It // verifies the 'seqnum' serialization stuff works. diff --git a/agent/functional_tests/util/utils.go b/agent/functional_tests/util/utils.go index 249eaa56021..90867537da8 100644 --- a/agent/functional_tests/util/utils.go +++ b/agent/functional_tests/util/utils.go @@ -394,6 +394,17 @@ func (agent *TestAgent) waitRunningViaIntrospection(task *TestTask) (bool, error } } +func (agent *TestAgent) CallTaskIntrospectionAPI(task *TestTask) (*handlers.TaskResponse, error) { + rawResponse, err := agent.callTaskIntrospectionApi(*task.TaskArn) + if err != nil { + return nil, err + } + + var taskResp handlers.TaskResponse + err = json.Unmarshal(*rawResponse, &taskResp) + return &taskResp, err +} + func (agent *TestAgent) callTaskIntrospectionApi(taskArn string) (*[]byte, error) { fullIntrospectionApiURL := agent.IntrospectionURL + "/v1/tasks" if taskArn != "" { diff --git a/agent/functional_tests/util/utils_unix.go b/agent/functional_tests/util/utils_unix.go index 8baec6df5c0..44d7097f796 100644 --- a/agent/functional_tests/util/utils_unix.go +++ b/agent/functional_tests/util/utils_unix.go @@ -166,8 +166,12 @@ func (agent *TestAgent) StartAgent() error { Links: agent.Options.ContainerLinks, } + if os.Getenv("ECS_FTEST_FORCE_NET_HOST") != "" { + hostConfig.NetworkMode = "host" + } + if agent.Options != nil { - // Override the default docker envrionment variable + // Override the default docker environment variable for key, value := range agent.Options.ExtraEnvironment { envVarExists := false for i, str := range dockerConfig.Env { @@ -207,12 +211,17 @@ func (agent *TestAgent) StartAgent() error { if err != nil { return errors.New("Could not inspect agent container: " + err.Error()) } - agent.IntrospectionURL = "http://localhost:" + containerMetadata.NetworkSettings.Ports["51678/tcp"][0].HostPort + if containerMetadata.HostConfig.NetworkMode == "host" { + agent.IntrospectionURL = "http://localhost:51678" + } else { + agent.IntrospectionURL = "http://localhost:" + containerMetadata.NetworkSettings.Ports["51678/tcp"][0].HostPort + } + return agent.verifyIntrospectionAPI() } // getBindMounts actually constructs volume binds for container's host config -// It also additionally checks for envrionment variables: +// It also additionally checks for environment variables: // * CGROUP_PATH: the cgroup path // * EXECDRIVER_PATH: the path of metrics func (agent *TestAgent) getBindMounts() []string { From fa0662e2cc244e35b16a98745629eb2c1b16908c Mon Sep 17 00:00:00 2001 From: Samuel Karp Date: Wed, 25 Oct 2017 10:42:44 -0700 Subject: [PATCH 40/58] dockerstate: Factor out store/remove for maps --- .../dockerstate/docker_task_engine_state.go | 56 ++++++++++++------- 1 file changed, 35 insertions(+), 21 deletions(-) diff --git a/agent/engine/dockerstate/docker_task_engine_state.go b/agent/engine/dockerstate/docker_task_engine_state.go index 563b1a56f85..648a360a815 100644 --- a/agent/engine/dockerstate/docker_task_engine_state.go +++ b/agent/engine/dockerstate/docker_task_engine_state.go @@ -318,19 +318,7 @@ func (state *DockerTaskEngineState) AddContainer(container *api.DockerContainer, state.tasks[task.Arn] = task } - if container.DockerID != "" { - // Update the container id to the state - state.idToContainer[container.DockerID] = container - state.idToTask[container.DockerID] = task.Arn - - // Remove the previously added name mapping - delete(state.idToContainer, container.DockerName) - delete(state.idToTask, container.DockerName) - } else if container.DockerName != "" { - // Update the container name mapping to the state when the ID isn't available - state.idToContainer[container.DockerName] = container - state.idToTask[container.DockerName] = task.Arn - } + state.storeIDToContainerTaskUnsafe(container, task) existingMap, exists := state.taskToID[task.Arn] if !exists { @@ -377,15 +365,41 @@ func (state *DockerTaskEngineState) RemoveTask(task *api.Task) { delete(state.taskToID, task.Arn) for _, dockerContainer := range containerMap { - // The key to these maps is either the Docker ID or agent-generated name. We use the agent-generated name - // before a Docker ID is available. - key := dockerContainer.DockerID - if key == "" { - key = dockerContainer.DockerName - } - delete(state.idToTask, key) - delete(state.idToContainer, key) + state.removeIDToContainerTaskUnsafe(dockerContainer) + } +} + +// storeIDToContainerTaskUnsafe stores the container in the idToContainer and idToTask maps. The key to the maps is +// either the Docker-generated ID or the agent-generated name (if the ID is not available). If the container is updated +// with an ID, a subsequent call to this function will update the map to use the ID as the key. +func (state *DockerTaskEngineState) storeIDToContainerTaskUnsafe(container *api.DockerContainer, task *api.Task) { + if container.DockerID != "" { + // Update the container id to the state + state.idToContainer[container.DockerID] = container + state.idToTask[container.DockerID] = task.Arn + + // Remove the previously added name mapping + delete(state.idToContainer, container.DockerName) + delete(state.idToTask, container.DockerName) + } else if container.DockerName != "" { + // Update the container name mapping to the state when the ID isn't available + state.idToContainer[container.DockerName] = container + state.idToTask[container.DockerName] = task.Arn + } +} + +// removeIDToContainerTaskUnsafe removes the container from the idToContainer and idToTask maps. They key to the maps +// is either the Docker-generated ID or the agent-generated name (if the ID is not available). This function assumes +// that the ID takes precedence and will delete by the ID when the ID is available. +func (state *DockerTaskEngineState) removeIDToContainerTaskUnsafe(container *api.DockerContainer) { + // The key to these maps is either the Docker ID or agent-generated name. We use the agent-generated name + // before a Docker ID is available. + key := container.DockerID + if key == "" { + key = container.DockerName } + delete(state.idToTask, key) + delete(state.idToContainer, key) } // RemoveImageState removes an image.ImageState From 81b8672717bb4a32243eee13305ca7a841c4e6c8 Mon Sep 17 00:00:00 2001 From: Samuel Karp Date: Wed, 25 Oct 2017 14:00:45 -0700 Subject: [PATCH 41/58] functional_tests: Enhance README --- agent/functional_tests/README.md | 104 +++++++++++++++++++++---------- 1 file changed, 70 insertions(+), 34 deletions(-) diff --git a/agent/functional_tests/README.md b/agent/functional_tests/README.md index 1dd8ca369e6..e985ef19363 100644 --- a/agent/functional_tests/README.md +++ b/agent/functional_tests/README.md @@ -14,49 +14,85 @@ It is not recommended to run these without understanding the implications of doing so and it is certainly not recommended to run them on an AWS account handling production work-loads. -## Setup +## Test setup -Before running these tests, you should build the ECS Agent and tag its image as +### Linux + +Before running these tests, you should build the ECS agent and tag its image as `amazon/amazon-ecs-agent:make`. You should also run the registry the tests pull from. This can most easily be done via `make test-registry`. +#### Environment variables +In order to run telemetry functional test in non Amazon Linux AMI environment +with older versions of the ECS agent (pre-1.10.0), the following environment +variables should be set: +* `CGROUP_PATH`: cgroup path on the host, default value "/cgroup" +* `EXECDRIVER_PATH`: execdriver path on the host, default value "/var/run/docker/execdriver" + +You can configure the following environment variables to change test +execution behavior: +* `AWS_REGION`: Control the region that is used for test execution +* `ECS_CLUSTER`: Control the cluster used for test execution +* `ECS_AGENT_IMAGE`: Override the default image of + `amazon/amazon-ecs-agent:make` +* `ECS_FTEST_TMP`: Override the default temporary directory used for storing + test logs and data files +* `ECS_FTEST_AGENT_ARGS`: Pass additional command-line arguments to the agent +* `ECS_FTEST_FORCE_NET_HOST`: Run the agent with `--net=host` + +#### Additional setup for IAM roles +In order to run TaskIamRole functional tests, the following steps should b +done first: +* Run command: `sysctl -w net.ipv4.conf.all.route_localnet=1` and + `iptables -t nat -A PREROUTING -p tcp -d 169.254.170.2 --dport 80 -j DNAT --to-destination 127.0.0.1:51679`. +* Set the environment variable to enable the test under default network mode: + `export TEST_TASK_IAM_ROLE=true`. +* Set the environment variable of IAM roles the test will use: + `export TASK_IAM_ROLE_ARN="iam role arn"`. The role should have the + `ec2:DescribeRegions` permission and have a trust relationship with + "ecs-tasks.amazonaws.com". If the `TASK_IAM_ROLE_ARN` environment variable + isn't set, the test will use the IAM role attached to the instance profile. + In this case, the IAM role should additionally have the + `iam:GetInstanceProfile` permission. +* Testing under net=host network mode requires additional commands: + `iptables -t nat -A OUTPUT -d 169.254.170.2 -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 51679` + and `export TEST_TASK_IAM_ROLE_NET_HOST=true` + +### Windows + +Before running these tests, you should build the ECS agent (as `agent.exe`) and +record the directory where the binary is present in the `ECS_WINDOWS_TEST_DIR` +environment variable. + +#### Environment variables +You can configure the following environment variables to change test +execution behavior: +* `AWS_REGION`: Control the region that is used for test execution +* `ECS_CLUSTER`: Control the cluster used for test execution +* `ECS_WINDOWS_TEST_DIR`: Override the path used to find `agent.exe` +* `ECS_FTEST_TMP`: Override the default temporary directory used for storing + test logs and data files + +#### Additional setup for IAM roles + +For performing the IAM roles test, perform the following additional tasks. +* `$env:TEST_TASK_IAM_ROLE="true"` +* devcon.exe should be present in system environment variable `PATH`. + + ## Running These tests should be run on an EC2 instance able to correctly run the ECS agent and access the ECS APIs. -The best way to run them is via the `make run-functional-tests` target. - -Thay may also be manually run with `go test -tags functional -v ./...`, - -### Envrionment Variable -In order to run Telemetry functional test in non Amazon Linux AMI environment, -the following environment variables should be set: - * CGROUP_PATH: cgroup path on the host, default value "/cgroup" - * EXECDRIVER_PATH: execdriver path on the host, default value "/var/run/docker/execdriver" - -In order to run TaskIamRole functional test, the following steps should be done first: - * Run command: `sysctl -w net.ipv4.conf.all.route_localnet=1` and - `iptables -t nat -A PREROUTING -p tcp -d 169.254.170.2 --dport 80 -j DNAT --to-destination 127.0.0.1:51679`. - * Set the environment variable to enable the test under default network mode: `export TEST_TASK_IAM_ROLE=true`. - * Set the envrionment variable of IAM roles the test will use: `export TASK_IAM_ROLE_ARN="iam role arn"`, - the role should have the `ec2:DescribeRegions` permission and have the trust relationship with "ecs-tasks.amazonaws.com". - Or if the `TASK_IAM_ROLE_ARN` isn't set, it will use the IAM role attached to the instance profile. In this case, - except the permissions required before, the IAM role should also have `iam:GetInstanceProfile` permission. - * Testing under net=host network mode requires additional command: - `iptables -t nat -A OUTPUT -d 169.254.170.2 -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 51679` and - `export TEST_TASK_IAM_ROLE_NET_HOST=true` - -## Windows Setup - -Set the following environment variable. - * $env:ECS_WINDOWS_TEST_DIR=##Path where the agent binary is present. - * For performing the IAM roles test, perform the following additional tasks. - ** `$env:TEST_TASK_IAM_ROLE="true"` - ** `Set environment variable AWS_REGION. For example, `$env:AWS_REGION="us-east-1"` - ** devcon.exe should be present in system environment variable PATH. +The best way to run them on Linux is via the `make run-functional-tests` +target. -## Running +The best way to run them on Windows is via the `run-functional-tests.ps1` +script located in the `scripts` directory. -Running the command run-functional-tests.ps1 from the scripts directory +They may also be manually run with `go test -tags functional -v ./...` and +you can use standard `go test` flags to control which tests execute (for +example, you can use the `-run` flag to provide a regular expression of tests +to include). From ad5b70b939973521c1da989eda25fa9ab977954e Mon Sep 17 00:00:00 2001 From: Peng Yin Date: Mon, 23 Oct 2017 22:40:46 +0000 Subject: [PATCH 42/58] Fix flaky unit test in engine TestGetTaskByArn and TestMetadataFileUpdatedAgentRestart sometimes can be flaky due to missing docker api call, as there is no way to stop the engine from procssing the task. By modifying the desired/known status of the container/task to reduce this calls. --- agent/engine/docker_task_engine_test.go | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/agent/engine/docker_task_engine_test.go b/agent/engine/docker_task_engine_test.go index 7fcf34d7ae2..77bb0cff0ea 100644 --- a/agent/engine/docker_task_engine_test.go +++ b/agent/engine/docker_task_engine_test.go @@ -1537,6 +1537,7 @@ func TestGetTaskByArn(t *testing.T) { sleepTask := testdata.LoadTask("sleep5") sleepTaskArn := sleepTask.Arn + sleepTask.SetDesiredStatus(api.TaskStopped) taskEngine.AddTask(sleepTask) _, found := taskEngine.GetTaskByArn(sleepTaskArn) @@ -1911,7 +1912,6 @@ func TestPullNormalImage(t *testing.T) { // agent starts, container created, metadata file created, agent restarted, container recovered // during task engine init, metadata file updated func TestMetadataFileUpdatedAgentRestart(t *testing.T) { - conf := &defaultConfig conf.ContainerMetadataEnabled = true @@ -1925,12 +1925,14 @@ func TestMetadataFileUpdatedAgentRestart(t *testing.T) { taskEngine, _ := privateTaskEngine.(*DockerTaskEngine) assert.True(t, taskEngine.cfg.ContainerMetadataEnabled, "ContainerMetadataEnabled set to false.") + taskEngine._time = nil taskEngine.SetSaver(saver) state := taskEngine.State() task := testdata.LoadTask("sleep5") container, _ := task.ContainerByName("sleep5") assert.False(t, container.MetadataFileUpdated) + container.SetKnownStatus(api.ContainerRunning) dockerContainer := &api.DockerContainer{DockerID: containerID, Container: container} @@ -1938,17 +1940,17 @@ func TestMetadataFileUpdatedAgentRestart(t *testing.T) { expectedDockerID := dockerContainer.DockerID expectedContainerName := container.Name + state.AddTask(task) state.AddContainer(dockerContainer, task) client.EXPECT().Version() eventStream := make(chan DockerContainerChangeEvent) client.EXPECT().ContainerEvents(gomock.Any()).Return(eventStream, nil) - imageManager.EXPECT().AddAllImageStates(gomock.Any()).AnyTimes() - imageManager.EXPECT().RecordContainerReference(gomock.Any()).AnyTimes() - imageManager.EXPECT().GetImageStateFromImageName(gomock.Any()).AnyTimes() - client.EXPECT().PullImage(gomock.Any(), gomock.Any()).AnyTimes() - client.EXPECT().DescribeContainer(gomock.Any()).AnyTimes() + client.EXPECT().DescribeContainer(gomock.Any()) + imageManager.EXPECT().RecordContainerReference(gomock.Any()) + saver.EXPECT().Save().AnyTimes() + saver.EXPECT().ForceSave().AnyTimes() metadataManager.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()).Do(func(dockerID string, taskARN string, containerName string) { assert.Equal(t, expectedTaskARN, taskARN) From 734d44fc4c62ee7f688ba7b621159088bf9d7244 Mon Sep 17 00:00:00 2001 From: Aithal Date: Wed, 18 Oct 2017 15:30:42 -0700 Subject: [PATCH 43/58] eventhandler: remove duplicate code in TaskHandler This commit refactors the 'SubmitTaskEvents' method to consolidate the duplicate code in event submission logic into a single method. --- agent/eventhandler/task_handler.go | 126 ++++++++++++++++++----------- 1 file changed, 77 insertions(+), 49 deletions(-) diff --git a/agent/eventhandler/task_handler.go b/agent/eventhandler/task_handler.go index 9efaf86dca3..d7cb31ef56d 100644 --- a/agent/eventhandler/task_handler.go +++ b/agent/eventhandler/task_handler.go @@ -188,57 +188,14 @@ func (handler *TaskHandler) SubmitTaskEvents(taskEvents *eventList, client api.E event := eventToSubmit.Value.(*sendableEvent) if event.containerShouldBeSent() { - seelog.Infof("TaskHandler, Sending container change: %s", event.String()) - err = client.SubmitContainerStateChange(event.containerChange) - if err == nil { - // submitted; ensure we don't retry it - event.setSent() - if event.containerChange.Container != nil { - event.containerChange.Container.SetSentStatus(event.containerChange.Status) - } - handler.stateSaver.Save() - seelog.Debugf("TaskHandler, Submitted container state change: %s", event.String()) - backoff.Reset() - taskEvents.events.Remove(eventToSubmit) - } else { - seelog.Errorf("TaskHandler, Unretriable error submitting container state change [%s]: %v", - event.String(), err) - } + sendEvent(sendContainerStatusToECS, setContainerChangeSent, "container", client, + eventToSubmit, handler.stateSaver, backoff, taskEvents) } else if event.taskShouldBeSent() { - seelog.Infof("TaskHandler, Sending task change: %s", event.String()) - err = client.SubmitTaskStateChange(event.taskChange) - if err == nil { - // submitted or can't be retried; ensure we don't retry it - event.setSent() - if event.taskChange.Task != nil { - event.taskChange.Task.SetSentStatus(event.taskChange.Status) - } - handler.stateSaver.Save() - seelog.Debugf("TaskHandler, Submitted task state change: %s", event.String()) - backoff.Reset() - taskEvents.events.Remove(eventToSubmit) - } else { - seelog.Errorf("TaskHandler, Unretriable error submitting task state change[%s]: %v", - event.String(), err) - } + sendEvent(sendTaskStatusToECS, setTaskChangeSent, "task", client, + eventToSubmit, handler.stateSaver, backoff, taskEvents) } else if event.taskAttachmentShouldBeSent() { - seelog.Infof("TaskHandler, Sending task attachment change: %s", event.String()) - err = client.SubmitTaskStateChange(event.taskChange) - if err == nil { - // submitted or can't be retried; ensure we don't retry it - event.setSent() - if event.taskChange.Attachment != nil { - event.taskChange.Attachment.SetSentStatus() - event.taskChange.Attachment.StopAckTimer() - } - handler.stateSaver.Save() - seelog.Debugf("TaskHandler, Submitted task attachment state change: %s", event.String()) - backoff.Reset() - taskEvents.events.Remove(eventToSubmit) - } else { - seelog.Errorf("TaskHandler, Unretriable error submitting task attachment state change [%s]: %v", - event.String(), err) - } + sendEvent(sendTaskStatusToECS, setTaskAttachmentSent, "task attachment", client, + eventToSubmit, handler.stateSaver, backoff, taskEvents) } else { // Shouldn't be sent as either a task or container change event; must have been already sent seelog.Infof("TaskHandler, Not submitting redundant event; just removing: %s", event.String()) @@ -256,3 +213,74 @@ func (handler *TaskHandler) SubmitTaskEvents(taskEvents *eventList, client api.E }) } } + +// sendEvent tries to send an event, specified by 'eventToSubmit', of type +// 'eventType' to ECS +func sendEvent(sendStatusToECS sendStatusChangeToECS, + setChangeSent setStatusSent, + eventType string, + client api.ECSClient, + eventToSubmit *list.Element, + stateSaver statemanager.Saver, + backoff *utils.SimpleBackoff, + taskEvents *eventList) { + + // Extract the wrapped event from the list element + event := eventToSubmit.Value.(*sendableEvent) + seelog.Infof("TaskHandler, Sending %s change: %s", eventType, event.String()) + // Try submitting the change to ECS + if err := sendStatusToECS(client, event); err != nil { + seelog.Errorf("TaskHandler, Unretriable error submitting %s state change [%s]: %v", + eventType, event.String(), err) + return + } + // 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 container state change: %s", event.String()) + backoff.Reset() + taskEvents.events.Remove(eventToSubmit) +} + +// sendStatusChangeToECS defines a function type for invoking the appropriate ECS state change API +type sendStatusChangeToECS func(client api.ECSClient, event *sendableEvent) error + +// sendContainerStatusToECS invokes the SubmitContainerStateChange API to send a +// container status change to ECS +func sendContainerStatusToECS(client api.ECSClient, event *sendableEvent) error { + return client.SubmitContainerStateChange(event.containerChange) +} + +// sendTaskStatusToECS invokes the SubmitTaskStateChange API to send a task +// status change to ECS +func sendTaskStatusToECS(client api.ECSClient, event *sendableEvent) error { + return client.SubmitTaskStateChange(event.taskChange) +} + +// setStatusSent defines a function type to mark the event as sent +type setStatusSent func(event *sendableEvent) + +// setContainerChangeSent sets the event's container change object as sent +func setContainerChangeSent(event *sendableEvent) { + if event.containerChange.Container != nil { + event.containerChange.Container.SetSentStatus(event.containerChange.Status) + } +} + +// setTaskChangeSent sets the event's task change object as sent +func setTaskChangeSent(event *sendableEvent) { + if event.taskChange.Task != nil { + event.taskChange.Task.SetSentStatus(event.taskChange.Status) + } +} + +// setTaskAttachmentSent sets the event's task attachment object as sent +func setTaskAttachmentSent(event *sendableEvent) { + if event.taskChange.Attachment != nil { + event.taskChange.Attachment.SetSentStatus() + event.taskChange.Attachment.StopAckTimer() + } +} From 399683998ef7591ef1d1b751d19604144fca9d63 Mon Sep 17 00:00:00 2001 From: Aithal Date: Wed, 18 Oct 2017 16:33:11 -0700 Subject: [PATCH 44/58] eventhandler: container sent state bug fix Fixed a bug where upon submitting the task state change, the container sent state was not being updated. This would cause spurious container state changes in the submission queue of task handler upon agent restart. --- agent/eventhandler/task_handler.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/agent/eventhandler/task_handler.go b/agent/eventhandler/task_handler.go index d7cb31ef56d..7e621acbc8b 100644 --- a/agent/eventhandler/task_handler.go +++ b/agent/eventhandler/task_handler.go @@ -275,6 +275,9 @@ func setTaskChangeSent(event *sendableEvent) { if event.taskChange.Task != nil { event.taskChange.Task.SetSentStatus(event.taskChange.Status) } + for _, container := range event.taskChange.Containers { + container.Container.SetSentStatus(event.taskChange.Status.ContainerStatus(container.Container.GetSteadyStateStatus())) + } } // setTaskAttachmentSent sets the event's task attachment object as sent From 81717c24a16357aa9d8820d00de11d2fc73ca8ca Mon Sep 17 00:00:00 2001 From: Aithal Date: Thu, 19 Oct 2017 08:33:29 -0700 Subject: [PATCH 45/58] eventhandler: periodic submit-state event drain Added a ticker to drain the event queue every minute. If there are any container state changes not submitted, the ticker ensures that they do get submitted. --- agent/acs/handler/acs_handler_test.go | 47 +++---- agent/acs/handler/payload_handler_test.go | 35 +++-- agent/app/agent.go | 2 +- agent/eventhandler/handler_test.go | 129 ++++++++++++------ agent/eventhandler/task_handler.go | 74 +++++++++- agent/eventhandler/task_handler_types.go | 18 ++- agent/eventhandler/task_handler_types_test.go | 49 +++++++ 7 files changed, 264 insertions(+), 90 deletions(-) diff --git a/agent/acs/handler/acs_handler_test.go b/agent/acs/handler/acs_handler_test.go index 6432bf5b2fa..4f896b48970 100644 --- a/agent/acs/handler/acs_handler_test.go +++ b/agent/acs/handler/acs_handler_test.go @@ -202,9 +202,9 @@ func TestHandlerReconnectsOnConnectErrors(t *testing.T) { ecsClient.EXPECT().DiscoverPollEndpoint(gomock.Any()).Return(acsURL, nil).AnyTimes() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + mockWsClient := mock_wsclient.NewMockClientServer(ctrl) mockWsClient.EXPECT().SetAnyRequestHandler(gomock.Any()).AnyTimes() mockWsClient.EXPECT().AddRequestHandler(gomock.Any()).AnyTimes() @@ -340,9 +340,9 @@ func TestHandlerReconnectsWithoutBackoffOnEOFError(t *testing.T) { ecsClient.EXPECT().DiscoverPollEndpoint(gomock.Any()).Return(acsURL, nil).AnyTimes() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + deregisterInstanceEventStream := eventstream.NewEventStream("DeregisterContainerInstance", ctx) deregisterInstanceEventStream.StartListening() @@ -403,9 +403,9 @@ func TestHandlerReconnectsWithBackoffOnNonEOFError(t *testing.T) { ecsClient.EXPECT().DiscoverPollEndpoint(gomock.Any()).Return(acsURL, nil).AnyTimes() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + deregisterInstanceEventStream := eventstream.NewEventStream("DeregisterContainerInstance", ctx) deregisterInstanceEventStream.StartListening() @@ -465,9 +465,9 @@ func TestHandlerGeneratesDeregisteredInstanceEvent(t *testing.T) { ecsClient.EXPECT().DiscoverPollEndpoint(gomock.Any()).Return(acsURL, nil).AnyTimes() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + deregisterInstanceEventStream := eventstream.NewEventStream("DeregisterContainerInstance", ctx) // receiverFunc cancels the context when invoked. Any event on the deregister @@ -525,9 +525,9 @@ func TestHandlerReconnectDelayForInactiveInstanceError(t *testing.T) { ecsClient.EXPECT().DiscoverPollEndpoint(gomock.Any()).Return(acsURL, nil).AnyTimes() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + deregisterInstanceEventStream := eventstream.NewEventStream("DeregisterContainerInstance", ctx) deregisterInstanceEventStream.StartListening() @@ -593,9 +593,9 @@ func TestHandlerReconnectsOnServeErrors(t *testing.T) { ecsClient.EXPECT().DiscoverPollEndpoint(gomock.Any()).Return(acsURL, nil).AnyTimes() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + mockWsClient := mock_wsclient.NewMockClientServer(ctrl) mockWsClient.EXPECT().SetAnyRequestHandler(gomock.Any()).AnyTimes() mockWsClient.EXPECT().AddRequestHandler(gomock.Any()).AnyTimes() @@ -649,9 +649,9 @@ func TestHandlerStopsWhenContextIsCancelled(t *testing.T) { ecsClient.EXPECT().DiscoverPollEndpoint(gomock.Any()).Return(acsURL, nil).AnyTimes() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + mockWsClient := mock_wsclient.NewMockClientServer(ctrl) mockWsClient.EXPECT().SetAnyRequestHandler(gomock.Any()).AnyTimes() mockWsClient.EXPECT().AddRequestHandler(gomock.Any()).AnyTimes() @@ -698,9 +698,8 @@ func TestHandlerReconnectsOnDiscoverPollEndpointError(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) mockWsClient := mock_wsclient.NewMockClientServer(ctrl) mockWsClient.EXPECT().SetAnyRequestHandler(gomock.Any()).AnyTimes() @@ -768,7 +767,9 @@ func TestConnectionIsClosedOnIdle(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + defer cancel() wait := sync.WaitGroup{} wait.Add(1) @@ -816,7 +817,8 @@ func TestHandlerDoesntLeakGoroutines(t *testing.T) { taskEngine := engine.NewMockTaskEngine(ctrl) ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) closeWS := make(chan bool) server, serverIn, requests, errs, err := startMockAcsServer(t, closeWS) @@ -839,7 +841,6 @@ func TestHandlerDoesntLeakGoroutines(t *testing.T) { taskEngine.EXPECT().Version().Return("Docker: 1.5.0", nil).AnyTimes() taskEngine.EXPECT().AddTask(gomock.Any()).AnyTimes() - ctx, cancel := context.WithCancel(context.Background()) ended := make(chan bool, 1) go func() { acsSession := session{ @@ -899,7 +900,8 @@ func TestStartSessionHandlesRefreshCredentialsMessages(t *testing.T) { taskEngine := engine.NewMockTaskEngine(ctrl) ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) closeWS := make(chan bool) server, serverIn, requestsChan, errChan, err := startMockAcsServer(t, closeWS) if err != nil { @@ -907,7 +909,6 @@ func TestStartSessionHandlesRefreshCredentialsMessages(t *testing.T) { } defer close(serverIn) - ctx, cancel := context.WithCancel(context.Background()) go func() { for { select { @@ -1019,9 +1020,9 @@ func TestHandlerReconnectsCorrectlySetsSendCredentialsURLParameter(t *testing.T) taskEngine := engine.NewMockTaskEngine(ctrl) ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) - ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + mockWsClient := mock_wsclient.NewMockClientServer(ctrl) mockWsClient.EXPECT().SetAnyRequestHandler(gomock.Any()).AnyTimes() diff --git a/agent/acs/handler/payload_handler_test.go b/agent/acs/handler/payload_handler_test.go index 94d5a59bd0a..f5bbe3e7672 100644 --- a/agent/acs/handler/payload_handler_test.go +++ b/agent/acs/handler/payload_handler_test.go @@ -47,9 +47,10 @@ func TestHandlePayloadMessageWithNoMessageId(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() credentialsManager := credentials.NewManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + defer cancel() - ctx := context.Background() buffer := newPayloadRequestHandler( ctx, taskEngine, @@ -94,12 +95,13 @@ func TestHandlePayloadMessageAddTaskError(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() credentialsManager := credentials.NewManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + defer cancel() // Return error from AddTask taskEngine.EXPECT().AddTask(gomock.Any()).Return(fmt.Errorf("oops")).Times(2) - ctx := context.Background() buffer := newPayloadRequestHandler( ctx, taskEngine, @@ -151,9 +153,11 @@ func TestHandlePayloadMessageStateSaveError(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) credentialsManager := credentials.NewManager() stateManager := mock_statemanager.NewMockStateManager(ctrl) - taskHandler := eventhandler.NewTaskHandler(stateManager) - taskEngine := engine.NewMockTaskEngine(ctrl) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + defer cancel() + // Save added task in the addedTask variable var addedTask *api.Task taskEngine.EXPECT().AddTask(gomock.Any()).Do(func(task *api.Task) { @@ -163,7 +167,6 @@ func TestHandlePayloadMessageStateSaveError(t *testing.T) { // State manager returns error on save stateManager.EXPECT().Save().Return(fmt.Errorf("oops")) - ctx := context.Background() buffer := newPayloadRequestHandler( ctx, taskEngine, @@ -206,8 +209,8 @@ func TestHandlePayloadMessageAckedWhenTaskAdded(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() credentialsManager := credentials.NewManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) taskEngine := engine.NewMockTaskEngine(ctrl) var addedTask *api.Task @@ -277,7 +280,7 @@ func TestHandlePayloadMessageCredentialsAckedWhenTaskAdded(t *testing.T) { stateManager := statemanager.NewNoopStateManager() ctx, cancel := context.WithCancel(context.Background()) credentialsManager := credentials.NewManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) taskEngine := engine.NewMockTaskEngine(ctrl) var addedTask *api.Task @@ -392,7 +395,9 @@ func TestAddPayloadTaskAddsNonStoppedTasksAfterStoppedTasks(t *testing.T) { taskEngine := engine.NewMockTaskEngine(ctrl) credentialsManager := credentials.NewManager() stateManager := statemanager.NewNoopStateManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + defer cancel() var tasksAddedToEngine []*api.Task taskEngine.EXPECT().AddTask(gomock.Any()).Do(func(task *api.Task) { @@ -415,7 +420,6 @@ func TestAddPayloadTaskAddsNonStoppedTasksAfterStoppedTasks(t *testing.T) { MessageId: aws.String(payloadMessageId), } - ctx := context.Background() buffer := newPayloadRequestHandler( ctx, taskEngine, @@ -451,8 +455,8 @@ func TestPayloadBufferHandler(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() credentialsManager := credentials.NewManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) var addedTask *api.Task taskEngine.EXPECT().AddTask(gomock.Any()).Do(func(task *api.Task) { @@ -517,7 +521,7 @@ func TestPayloadBufferHandlerWithCredentials(t *testing.T) { stateManager := statemanager.NewNoopStateManager() ctx, cancel := context.WithCancel(context.Background()) credentialsManager := credentials.NewManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) // The payload message in the test consists of two tasks, record both of them in // the order in which they were added @@ -694,9 +698,10 @@ func TestPayloadHandlerAddedENIToTask(t *testing.T) { ecsClient := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - ctx := context.Background() credentialsManager := credentials.NewManager() - taskHandler := eventhandler.NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + taskHandler := eventhandler.NewTaskHandler(ctx, stateManager, nil, nil) + defer cancel() taskEngine := engine.NewMockTaskEngine(ctrl) var addedTask *api.Task diff --git a/agent/app/agent.go b/agent/app/agent.go index ae0a1a62e81..a6e3409d82a 100644 --- a/agent/app/agent.go +++ b/agent/app/agent.go @@ -261,7 +261,7 @@ func (agent *ecsAgent) doStart(containerChangeEventStream *eventstream.EventStre deregisterInstanceEventStream := eventstream.NewEventStream( deregisterContainerInstanceEventStreamName, agent.ctx) deregisterInstanceEventStream.StartListening() - taskHandler := eventhandler.NewTaskHandler(stateManager) + taskHandler := eventhandler.NewTaskHandler(agent.ctx, stateManager, state, client) agent.startAsyncRoutines(containerChangeEventStream, credentialsManager, imageManager, taskEngine, stateManager, deregisterInstanceEventStream, client, taskHandler) diff --git a/agent/eventhandler/handler_test.go b/agent/eventhandler/handler_test.go index 15b3460f1cc..b294150f753 100644 --- a/agent/eventhandler/handler_test.go +++ b/agent/eventhandler/handler_test.go @@ -15,6 +15,7 @@ package eventhandler import ( "container/list" + "context" "strconv" "sync" "testing" @@ -22,6 +23,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/api" "github.com/aws/amazon-ecs-agent/agent/api/mocks" + "github.com/aws/amazon-ecs-agent/agent/engine/dockerstate/mocks" "github.com/aws/amazon-ecs-agent/agent/statechange" "github.com/aws/amazon-ecs-agent/agent/statemanager" "github.com/aws/amazon-ecs-agent/agent/utils" @@ -30,27 +32,30 @@ import ( "github.com/stretchr/testify/assert" ) +const taskARN = "taskarn" + func TestSendsEventsOneContainer(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() client := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - handler := NewTaskHandler(stateManager) - taskarn := "taskarn" + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, stateManager, nil, client) + defer cancel() var wg sync.WaitGroup wg.Add(1) // Trivial: one container, no errors - contEvent1 := containerEvent(taskarn) - contEvent2 := containerEvent(taskarn) - taskEvent2 := taskEvent(taskarn) + contEvent1 := containerEvent(taskARN) + contEvent2 := containerEvent(taskARN) + taskEvent2 := taskEvent(taskARN) client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { assert.Equal(t, 2, len(change.Containers)) - assert.Equal(t, taskarn, change.Containers[0].TaskArn) - assert.Equal(t, taskarn, change.Containers[1].TaskArn) + assert.Equal(t, taskARN, change.Containers[0].TaskArn) + assert.Equal(t, taskARN, change.Containers[1].TaskArn) wg.Done() }) @@ -67,14 +72,15 @@ func TestSendsEventsOneEventRetries(t *testing.T) { client := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - handler := NewTaskHandler(stateManager) - taskarn := "taskarn" + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, stateManager, nil, client) + defer cancel() var wg sync.WaitGroup wg.Add(2) retriable := utils.NewRetriableError(utils.NewRetriable(true), errors.New("test")) - taskEvent := taskEvent(taskarn) + taskEvent := taskEvent(taskARN) gomock.InOrder( client.EXPECT().SubmitTaskStateChange(gomock.Any()).Return(retriable).Do(func(interface{}) { wg.Done() }), @@ -92,7 +98,9 @@ func TestSendsEventsConcurrentLimit(t *testing.T) { client := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - handler := NewTaskHandler(stateManager) + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, stateManager, nil, client) + defer cancel() completeStateChange := make(chan bool, concurrentEventCalls+1) var wg sync.WaitGroup @@ -129,22 +137,23 @@ func TestSendsEventsContainerDifferences(t *testing.T) { client := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - handler := NewTaskHandler(stateManager) - taskarn := "taskarn" + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, stateManager, nil, client) + defer cancel() var wg sync.WaitGroup wg.Add(1) // Test container event replacement doesn't happen - contEvent1 := containerEvent(taskarn) - contEvent2 := containerEventStopped(taskarn) - taskEvent := taskEvent(taskarn) + contEvent1 := containerEvent(taskARN) + contEvent2 := containerEventStopped(taskARN) + taskEvent := taskEvent(taskARN) client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { assert.Equal(t, 2, len(change.Containers)) - assert.Equal(t, taskarn, change.Containers[0].TaskArn) + assert.Equal(t, taskARN, change.Containers[0].TaskArn) assert.Equal(t, api.ContainerRunning, change.Containers[0].Status) - assert.Equal(t, taskarn, change.Containers[1].TaskArn) + assert.Equal(t, taskARN, change.Containers[1].TaskArn) assert.Equal(t, api.ContainerStopped, change.Containers[1].Status) wg.Done() }) @@ -162,9 +171,12 @@ func TestSendsEventsTaskDifferences(t *testing.T) { client := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - handler := NewTaskHandler(stateManager) - taskarnA := "taskarnA" - taskarnB := "taskarnB" + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, stateManager, nil, client) + defer cancel() + + taskARNA := "taskarnA" + taskARNB := "taskarnB" var wg sync.WaitGroup wg.Add(2) @@ -173,21 +185,21 @@ func TestSendsEventsTaskDifferences(t *testing.T) { wgAddEvent.Add(1) // Test task event replacement doesn't happen - taskEventA := taskEvent(taskarnA) - contEventA1 := containerEvent(taskarnA) + taskEventA := taskEvent(taskARNA) + contEventA1 := containerEvent(taskARNA) - contEventB1 := containerEvent(taskarnB) - contEventB2 := containerEventStopped(taskarnB) - taskEventB := taskEventStopped(taskarnB) + contEventB1 := containerEvent(taskARNB) + contEventB2 := containerEventStopped(taskARNB) + taskEventB := taskEventStopped(taskARNB) client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { - assert.Equal(t, taskarnA, change.TaskARN) + assert.Equal(t, taskARNA, change.TaskARN) wgAddEvent.Done() wg.Done() }) client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { - assert.Equal(t, taskarnB, change.TaskARN) + assert.Equal(t, taskARNB, change.TaskARN) wg.Done() }) @@ -209,32 +221,35 @@ func TestSendsEventsDedupe(t *testing.T) { client := mock_api.NewMockECSClient(ctrl) stateManager := statemanager.NewNoopStateManager() - handler := NewTaskHandler(stateManager) - taskarnA := "taskarnA" - taskarnB := "taskarnB" + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, stateManager, nil, client) + defer cancel() + + taskARNA := "taskarnA" + taskARNB := "taskarnB" var wg sync.WaitGroup wg.Add(1) // Verify that a task doesn't get sent if we already have 'sent' it - task1 := taskEvent(taskarnA) + task1 := taskEvent(taskARNA) task1.(api.TaskStateChange).Task.SetSentStatus(api.TaskRunning) - cont1 := containerEvent(taskarnA) + cont1 := containerEvent(taskARNA) cont1.(api.ContainerStateChange).Container.SetSentStatus(api.ContainerRunning) handler.AddStateChangeEvent(cont1, client) handler.AddStateChangeEvent(task1, client) - task2 := taskEvent(taskarnB) + task2 := taskEvent(taskARNB) task2.(api.TaskStateChange).Task.SetSentStatus(api.TaskStatusNone) - cont2 := containerEvent(taskarnB) + cont2 := containerEvent(taskARNB) cont2.(api.ContainerStateChange).Container.SetSentStatus(api.ContainerRunning) // Expect to send a task status but not a container status client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { assert.Equal(t, 1, len(change.Containers)) - assert.Equal(t, taskarnB, change.Containers[0].TaskArn) - assert.Equal(t, taskarnB, change.TaskARN) + assert.Equal(t, taskARNB, change.Containers[0].TaskArn) + assert.Equal(t, taskARNB, change.TaskARN) wg.Done() }) @@ -253,16 +268,18 @@ func TestCleanupTaskEventAfterSubmit(t *testing.T) { stateManager := statemanager.NewNoopStateManager() client := mock_api.NewMockECSClient(ctrl) - handler := NewTaskHandler(stateManager) - taskarn := "taskarn" - taskarn2 := "taskarn2" + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, stateManager, nil, client) + defer cancel() + + taskARN2 := "taskarn2" var wg sync.WaitGroup wg.Add(3) - taskEvent1 := taskEvent(taskarn) - taskEvent2 := taskEvent(taskarn) - taskEvent3 := taskEvent(taskarn2) + taskEvent1 := taskEvent(taskARN) + taskEvent2 := taskEvent(taskARN) + taskEvent3 := taskEvent(taskARN2) client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do( func(change api.TaskStateChange) { @@ -323,10 +340,34 @@ func TestENISentStatusChange(t *testing.T) { events := list.New() events.PushBack(sendableTaskEvent) - handler := NewTaskHandler(statemanager.NewNoopStateManager()) + ctx, cancel := context.WithCancel(context.Background()) + handler := NewTaskHandler(ctx, statemanager.NewNoopStateManager(), nil, client) + defer cancel() handler.SubmitTaskEvents(&eventList{ events: events, }, client) assert.True(t, eniAttachment.AttachStatusSent) } + +func TestGetBatchedContainerEvents(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + state := mock_dockerstate.NewMockTaskEngineState(ctrl) + + handler := &TaskHandler{ + tasksToContainerStates: map[string][]api.ContainerStateChange{ + "t1": []api.ContainerStateChange{}, + "t2": []api.ContainerStateChange{}, + }, + state: state, + } + + state.EXPECT().TaskByArn("t1").Return(&api.Task{Arn: "t1", KnownStatusUnsafe: api.TaskRunning}, true) + state.EXPECT().TaskByArn("t2").Return(nil, false) + + events := handler.getBatchedContainerEvents() + assert.Len(t, events, 1) + assert.Equal(t, "t1", events[0].TaskARN) +} diff --git a/agent/eventhandler/task_handler.go b/agent/eventhandler/task_handler.go index 7e621acbc8b..0c1c2b9269f 100644 --- a/agent/eventhandler/task_handler.go +++ b/agent/eventhandler/task_handler.go @@ -15,19 +15,28 @@ package eventhandler import ( "container/list" + "context" "errors" "sync" "time" "github.com/aws/amazon-ecs-agent/agent/api" + "github.com/aws/amazon-ecs-agent/agent/engine/dockerstate" "github.com/aws/amazon-ecs-agent/agent/statechange" "github.com/aws/amazon-ecs-agent/agent/statemanager" "github.com/aws/amazon-ecs-agent/agent/utils" "github.com/cihub/seelog" ) -// Maximum number of tasks that may be handled at once by the TaskHandler -const concurrentEventCalls = 3 +const ( + // concurrentEventCalls is the maximum number of tasks that may be handled at + // once by the TaskHandler + concurrentEventCalls = 3 + + // drainEventsFrequency is the frequency at the which unsent events batched + // by the task handler are sent to the backend + drainEventsFrequency = time.Minute +) type eventList struct { // events is a list of *sendableEvents @@ -58,16 +67,73 @@ type TaskHandler struct { // stateSaver is a statemanager which may be used to save any // changes to a task or container's SentStatus stateSaver statemanager.Saver + + drainEventsFrequency time.Duration + state dockerstate.TaskEngineState + client api.ECSClient + ctx context.Context } // NewTaskHandler returns a pointer to TaskHandler -func NewTaskHandler(stateManager statemanager.Saver) *TaskHandler { - return &TaskHandler{ +func NewTaskHandler(ctx context.Context, + stateManager statemanager.Saver, + state dockerstate.TaskEngineState, + client api.ECSClient) *TaskHandler { + // Create a handler and start the periodic event drain loop + taskHandler := &TaskHandler{ + ctx: ctx, tasksToEvents: make(map[string]*eventList), submitSemaphore: utils.NewSemaphore(concurrentEventCalls), tasksToContainerStates: make(map[string][]api.ContainerStateChange), stateSaver: stateManager, + state: state, + client: client, + drainEventsFrequency: drainEventsFrequency, + } + go taskHandler.startDrainEventsTicker() + + return taskHandler +} + +// startDrainEventsTicker starts a ticker that periodically drains the events queue +// by submitting state change events to the ECS backend +func (handler *TaskHandler) startDrainEventsTicker() { + ticker := time.NewTicker(handler.drainEventsFrequency) + for { + select { + case <-handler.ctx.Done(): + seelog.Infof("TaskHandler: Stopping periodic container state change submission ticker") + ticker.Stop() + return + case <-ticker.C: + seelog.Info("TaskHandler tick") + for _, event := range handler.getBatchedContainerEvents() { + seelog.Infof( + "TaskHandler: Adding a state change event to send batched container events: %s", + event.String()) + handler.AddStateChangeEvent(event, handler.client) + } + } + } +} + +// getBatchedContainerEvents gets a list task state changes for container events that +// have been batched and not sent beyond the drainEventsFrequency threshold +func (handler *TaskHandler) getBatchedContainerEvents() []api.TaskStateChange { + handler.taskHandlerLock.RLock() + defer handler.taskHandlerLock.RUnlock() + + var events []api.TaskStateChange + for taskARN, _ := range handler.tasksToContainerStates { + if task, ok := handler.state.TaskByArn(taskARN); ok { + events = append(events, api.TaskStateChange{ + TaskARN: taskARN, + Status: task.GetKnownStatus(), + Task: task, + }) + } } + return events } // AddStateChangeEvent queues up a state change for sending using the given client. diff --git a/agent/eventhandler/task_handler_types.go b/agent/eventhandler/task_handler_types.go index 0f36bc681d0..9cbd6cbbe90 100644 --- a/agent/eventhandler/task_handler_types.go +++ b/agent/eventhandler/task_handler_types.go @@ -14,6 +14,7 @@ package eventhandler import ( + "fmt" "sync" "github.com/aws/amazon-ecs-agent/agent/api" @@ -39,9 +40,9 @@ func (event *sendableEvent) String() string { defer event.lock.RUnlock() if event.isContainerEvent { - return "ContainerChange: " + event.containerChange.String() + return "ContainerChange: [" + event.containerChange.String() + fmt.Sprintf("] sent: %t", event.containerSent) } else { - return "TaskChange: " + event.taskChange.String() + return "TaskChange: [" + event.taskChange.String() + fmt.Sprintf("] sent: %t", event.taskSent) } } @@ -71,6 +72,7 @@ func (event *sendableEvent) taskArn() string { func (event *sendableEvent) taskShouldBeSent() bool { event.lock.RLock() defer event.lock.RUnlock() + if event.isContainerEvent { return false } @@ -78,9 +80,19 @@ func (event *sendableEvent) taskShouldBeSent() bool { if tevent.Status == api.TaskStatusNone { return false // defensive programming :) } - if event.taskSent || (tevent.Task != nil && tevent.Task.GetSentStatus() >= tevent.Status) { + if event.taskSent { return false // redundant event } + if tevent.Task != nil && tevent.Task.GetSentStatus() >= tevent.Status { + for _, containerStateChange := range tevent.Containers { + container := containerStateChange.Container + if container.GetSentStatus() < container.GetKnownStatus() { + return true + } + } + + return false + } return true } diff --git a/agent/eventhandler/task_handler_types_test.go b/agent/eventhandler/task_handler_types_test.go index 3cb257a4999..2259d6cbe1f 100644 --- a/agent/eventhandler/task_handler_types_test.go +++ b/agent/eventhandler/task_handler_types_test.go @@ -69,6 +69,55 @@ func TestShouldTaskEventBeSent(t *testing.T) { }), shouldBeSent: true, }, + { + // Even though the task has been sent, there's a container + // state change that needs to be sent + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskRunning, + Task: &api.Task{ + SentStatusUnsafe: api.TaskRunning, + }, + Containers: []api.ContainerStateChange{ + { + Container: &api.Container{ + SentStatusUnsafe: api.ContainerRunning, + KnownStatusUnsafe: api.ContainerRunning, + }, + }, + { + Container: &api.Container{ + SentStatusUnsafe: api.ContainerRunning, + KnownStatusUnsafe: api.ContainerStopped, + }, + }, + }, + }), + shouldBeSent: true, + }, + { + // All states sent, nothing to send + event: newSendableTaskEvent(api.TaskStateChange{ + Status: api.TaskRunning, + Task: &api.Task{ + SentStatusUnsafe: api.TaskRunning, + }, + Containers: []api.ContainerStateChange{ + { + Container: &api.Container{ + SentStatusUnsafe: api.ContainerRunning, + KnownStatusUnsafe: api.ContainerRunning, + }, + }, + { + Container: &api.Container{ + SentStatusUnsafe: api.ContainerStopped, + KnownStatusUnsafe: api.ContainerStopped, + }, + }, + }, + }), + shouldBeSent: false, + }, } { t.Run(fmt.Sprintf("Event[%s] should be sent[%t]", tc.event.String(), tc.shouldBeSent), func(t *testing.T) { assert.Equal(t, tc.shouldBeSent, tc.event.taskShouldBeSent()) From b0c7693569f70029a944d3a9c694fd723f771191 Mon Sep 17 00:00:00 2001 From: Aithal Date: Fri, 20 Oct 2017 15:35:08 -0700 Subject: [PATCH 46/58] changelog entry for non-essential containers state change --- CHANGELOG.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 42291e3f9d3..1dfd4acc01a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,13 +2,15 @@ ## UNRELEASED * Feature - Support for provisioning Tasks with ENIs -* Bug - Fixed a bug where unsupported Docker API client versions could be registered - [#1014](https://github.com/aws/amazon-ecs-agent/pull/1014) * Enhancement - Support `init` process in containers by adding support for Docker remote API client version 1.25 [#996](https://github.com/aws/amazon-ecs-agent/pull/996) * Bug - Fixed a bug where tasks that fail to pull containers can cause the agent to fail to restore properly after a restart. [#1033](https://github.com/aws/amazon-ecs-agent/pull/1033) +* Bug - Fixed a bug where unsupported Docker API client versions could be registered + [#1014](https://github.com/aws/amazon-ecs-agent/pull/1014) +* Bug - Fixed a bug where non-essential container state changes were sometimes not submitted + [#1026](https://github.com/aws/amazon-ecs-agent/pull/1026) ## 1.14.5 * Enhancement - Retry failed container image pull operations [#975](https://github.com/aws/amazon-ecs-agent/pull/975) From 71066023e4034b9608651c5f7d249902724992b8 Mon Sep 17 00:00:00 2001 From: Aithal Date: Tue, 24 Oct 2017 13:56:58 -0700 Subject: [PATCH 47/58] eventhandler: fix bugs and clean up task handler This commit fixes a bunch of things in the task handler code: 1. Breaking up the really long submitTaskEvents method: The callback for the the backoff has been moved into its own named method from the in-place anonymous method (send()) 2. The backoff callback method now returns an error when there's an error submitting state change to ECS backend. This fixes a bug with the old version of the code where the backoff would never happen on errors because the error was never propagated all the way up 3. The race-condition between startDrainEventsTicker() and AddStateChangeEvent() when both are trying to submit changes to the same task is fixed as the tasksToEvents is used to group events belonging to the same task and only cleaned up when events are submitted instead of being cleaned before invoking the submitTaskEvents() routine --- agent/eventhandler/handler_test.go | 170 ++++++++++++++++++++- agent/eventhandler/task_handler.go | 229 ++++++++++++++++++----------- 2 files changed, 309 insertions(+), 90 deletions(-) diff --git a/agent/eventhandler/handler_test.go b/agent/eventhandler/handler_test.go index b294150f753..3463ce7ebf1 100644 --- a/agent/eventhandler/handler_test.go +++ b/agent/eventhandler/handler_test.go @@ -27,6 +27,7 @@ import ( "github.com/aws/amazon-ecs-agent/agent/statechange" "github.com/aws/amazon-ecs-agent/agent/statemanager" "github.com/aws/amazon-ecs-agent/agent/utils" + "github.com/aws/amazon-ecs-agent/agent/utils/mocks" "github.com/golang/mock/gomock" "github.com/pkg/errors" "github.com/stretchr/testify/assert" @@ -291,7 +292,14 @@ func TestCleanupTaskEventAfterSubmit(t *testing.T) { handler.AddStateChangeEvent(taskEvent3, client) wg.Wait() - assert.Len(t, handler.tasksToEvents, 0) + + // Wait for task events to be removed from the tasksToEvents map + for { + if handler.getTasksToEventsLen() == 0 { + break + } + time.Sleep(time.Millisecond) + } } func containerEvent(arn string) statechange.Event { @@ -316,11 +324,11 @@ func TestENISentStatusChange(t *testing.T) { client := mock_api.NewMockECSClient(ctrl) task := &api.Task{ - Arn: "taskarn", + Arn: taskARN, } eniAttachment := &api.ENIAttachment{ - TaskARN: "taskarn", + TaskARN: taskARN, AttachStatusSent: false, ExpiresAt: time.Now().Add(time.Second), } @@ -331,7 +339,7 @@ func TestENISentStatusChange(t *testing.T) { sendableTaskEvent := newSendableTaskEvent(api.TaskStateChange{ Attachment: eniAttachment, - TaskARN: "taskarn", + TaskARN: taskARN, Status: api.TaskStatusNone, Task: task, }) @@ -343,9 +351,9 @@ func TestENISentStatusChange(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) handler := NewTaskHandler(ctx, statemanager.NewNoopStateManager(), nil, client) defer cancel() - handler.SubmitTaskEvents(&eventList{ + handler.submitTaskEvents(&eventList{ events: events, - }, client) + }, client, taskARN) assert.True(t, eniAttachment.AttachStatusSent) } @@ -371,3 +379,153 @@ func TestGetBatchedContainerEvents(t *testing.T) { assert.Len(t, events, 1) assert.Equal(t, "t1", events[0].TaskARN) } + +func TestSenderWhenSendingTaskRunningAfterStopped(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + state := mock_dockerstate.NewMockTaskEngineState(ctrl) + client := mock_api.NewMockECSClient(ctrl) + stateManager := statemanager.NewNoopStateManager() + + handler := &TaskHandler{ + state: state, + submitSemaphore: utils.NewSemaphore(concurrentEventCalls), + tasksToEvents: make(map[string]*eventList), + tasksToContainerStates: make(map[string][]api.ContainerStateChange), + stateSaver: stateManager, + client: client, + } + + taskEvents := &eventList{events: list.New(), + sending: false, + createdAt: time.Now(), + taskARN: taskARN, + } + + backoff := mock_utils.NewMockBackoff(ctrl) + sender := &taskEventsSender{ + handler: handler, + backoff: backoff, + client: client, + taskEvents: taskEvents, + } + ok, err := sender.send() + assert.True(t, ok) + assert.NoError(t, err) + + task := &api.Task{} + sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + TaskARN: taskARN, + Status: api.TaskStopped, + Task: task, + })) + sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + TaskARN: taskARN, + Status: api.TaskRunning, + Task: task, + })) + handler.tasksToEvents[taskARN] = sender.taskEvents + + var wg sync.WaitGroup + wg.Add(1) + gomock.InOrder( + client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { + assert.Equal(t, api.TaskStopped, change.Status) + }), + backoff.EXPECT().Reset().Do(func() { + wg.Done() + }), + ) + ok, err = sender.send() + // We have an unsent event for the TaskRunning transition. Hence, send() returns false + assert.False(t, ok) + assert.NoError(t, err) + wg.Wait() + + // The unsent transition is deleted from the task list. send() returns true as it + // does not have any more events to process + ok, err = sender.send() + assert.NoError(t, err) + assert.True(t, ok) +} + +func TestSenderWhenSendingTaskStoppedAfterRunning(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + state := mock_dockerstate.NewMockTaskEngineState(ctrl) + client := mock_api.NewMockECSClient(ctrl) + stateManager := statemanager.NewNoopStateManager() + + handler := &TaskHandler{ + state: state, + submitSemaphore: utils.NewSemaphore(concurrentEventCalls), + tasksToEvents: make(map[string]*eventList), + tasksToContainerStates: make(map[string][]api.ContainerStateChange), + stateSaver: stateManager, + client: client, + } + + taskEvents := &eventList{events: list.New(), + sending: false, + createdAt: time.Now(), + taskARN: taskARN, + } + + backoff := mock_utils.NewMockBackoff(ctrl) + sender := &taskEventsSender{ + handler: handler, + backoff: backoff, + client: client, + taskEvents: taskEvents, + } + ok, err := sender.send() + assert.True(t, ok) + assert.NoError(t, err) + + task := &api.Task{} + sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + TaskARN: taskARN, + Status: api.TaskRunning, + Task: task, + })) + sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + TaskARN: taskARN, + Status: api.TaskStopped, + Task: task, + })) + handler.tasksToEvents[taskARN] = sender.taskEvents + + var wg sync.WaitGroup + wg.Add(1) + gomock.InOrder( + client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { + assert.Equal(t, api.TaskRunning, change.Status) + }), + backoff.EXPECT().Reset().Do(func() { + wg.Done() + }), + ) + // We have an unsent event for the TaskStopped transition. Hence, send() returns false + ok, err = sender.send() + assert.False(t, ok) + assert.NoError(t, err) + wg.Wait() + + wg.Add(1) + gomock.InOrder( + client.EXPECT().SubmitTaskStateChange(gomock.Any()).Do(func(change api.TaskStateChange) { + assert.Equal(t, api.TaskStopped, change.Status) + }), + backoff.EXPECT().Reset().Do(func() { + wg.Done() + }), + ) + // The unsent transition is send and deleted from the task list. send() returns true as it + // does not have any more events to process + ok, err = sender.send() + assert.True(t, ok) + assert.NoError(t, err) + wg.Wait() +} diff --git a/agent/eventhandler/task_handler.go b/agent/eventhandler/task_handler.go index 0c1c2b9269f..fde5fcba863 100644 --- a/agent/eventhandler/task_handler.go +++ b/agent/eventhandler/task_handler.go @@ -17,6 +17,7 @@ import ( "container/list" "context" "errors" + "fmt" "sync" "time" @@ -36,16 +37,12 @@ const ( // drainEventsFrequency is the frequency at the which unsent events batched // by the task handler are sent to the backend drainEventsFrequency = time.Minute -) -type eventList struct { - // events is a list of *sendableEvents - events *list.List - // sending will check whether the list is already being handlerd - sending bool - //eventsListLock locks both the list and sending bool - eventListLock sync.Mutex -} + submitStateBackoffMin = time.Second + submitStateBackoffMax = 30 * time.Second + submitStateBackoffJitterMultiple = 0.20 + submitStateBackoffMultiple = 1.3 +) // TaskHandler encapsulates the the map of a task arn to task and container events // associated with said task @@ -62,7 +59,7 @@ type TaskHandler struct { // taskHandlerLock is used to safely access the following maps: // * taskToEvents // * tasksToContainerStates - taskHandlerLock sync.RWMutex + lock sync.RWMutex // stateSaver is a statemanager which may be used to save any // changes to a task or container's SentStatus @@ -74,6 +71,25 @@ type TaskHandler struct { ctx context.Context } +// eventList is used to group all events for a task +type eventList struct { + // events is a list of *sendableEvents + events *list.List + // sending will check whether the list is already being handlerd + sending bool + //eventsListLock locks both the list and sending bool + lock sync.Mutex + // createdAt is a timestamp for when the event list was created + createdAt time.Time + // taskARN is the task arn that the event list is associated + taskARN string +} + +func (events *eventList) toStringUnsafe() string { + return fmt.Sprintf("Task event list [taskARN: %s, sending: %t, createdAt: %s]", + events.taskARN, events.sending, events.createdAt.String()) +} + // NewTaskHandler returns a pointer to TaskHandler func NewTaskHandler(ctx context.Context, stateManager statemanager.Saver, @@ -106,7 +122,6 @@ func (handler *TaskHandler) startDrainEventsTicker() { ticker.Stop() return case <-ticker.C: - seelog.Info("TaskHandler tick") for _, event := range handler.getBatchedContainerEvents() { seelog.Infof( "TaskHandler: Adding a state change event to send batched container events: %s", @@ -120,8 +135,8 @@ func (handler *TaskHandler) startDrainEventsTicker() { // getBatchedContainerEvents gets a list task state changes for container events that // have been batched and not sent beyond the drainEventsFrequency threshold func (handler *TaskHandler) getBatchedContainerEvents() []api.TaskStateChange { - handler.taskHandlerLock.RLock() - defer handler.taskHandlerLock.RUnlock() + handler.lock.RLock() + defer handler.lock.RUnlock() var events []api.TaskStateChange for taskARN, _ := range handler.tasksToContainerStates { @@ -163,18 +178,18 @@ func (handler *TaskHandler) AddStateChangeEvent(change statechange.Event, client // batchContainerEvent collects container state change events for a given task arn func (handler *TaskHandler) batchContainerEvent(event api.ContainerStateChange) { - handler.taskHandlerLock.Lock() - defer handler.taskHandlerLock.Unlock() + handler.lock.Lock() + defer handler.lock.Unlock() - seelog.Infof("TaskHandler, batching container event: %s", event.String()) + seelog.Infof("TaskHandler: batching container event: %s", event.String()) handler.tasksToContainerStates[event.TaskArn] = append(handler.tasksToContainerStates[event.TaskArn], event) } // flushBatch attaches the task arn's container events to TaskStateChange event that // is being submittied to the backend func (handler *TaskHandler) flushBatch(event *api.TaskStateChange) { - handler.taskHandlerLock.Lock() - defer handler.taskHandlerLock.Unlock() + handler.lock.Lock() + defer handler.lock.Unlock() event.Containers = append(event.Containers, handler.tasksToContainerStates[event.TaskARN]...) delete(handler.tasksToContainerStates, event.TaskARN) @@ -183,33 +198,37 @@ func (handler *TaskHandler) flushBatch(event *api.TaskStateChange) { // addEvent prepares a given event to be sent by adding it to the handler's appropriate // eventList and remove the entry in tasksToEvents map func (handler *TaskHandler) addEvent(change *sendableEvent, client api.ECSClient) { - handler.taskHandlerLock.Lock() - defer handler.taskHandlerLock.Unlock() - seelog.Infof("TaskHandler, Adding event: %s", change.String()) - taskEvents := handler.getTaskEventList(change) - taskEvents.eventListLock.Lock() - defer taskEvents.eventListLock.Unlock() + taskEvents.lock.Lock() + defer taskEvents.lock.Unlock() // Update taskEvent + seelog.Infof("TaskHandler: Adding event: %s", change.String()) taskEvents.events.PushBack(change) if !taskEvents.sending { taskEvents.sending = true - go handler.SubmitTaskEvents(taskEvents, client) + go handler.submitTaskEvents(taskEvents, client, change.taskArn()) } - - delete(handler.tasksToEvents, change.taskArn()) } // getTaskEventList gets the eventList from taskToEvent map func (handler *TaskHandler) getTaskEventList(change *sendableEvent) (taskEvents *eventList) { - taskEvents, ok := handler.tasksToEvents[change.taskArn()] + handler.lock.Lock() + defer handler.lock.Unlock() + + taskARN := change.taskArn() + taskEvents, ok := handler.tasksToEvents[taskARN] if !ok { - seelog.Debug("TaskHandler, collecting events for new task ", change) - taskEvents = &eventList{events: list.New(), sending: false} - handler.tasksToEvents[change.taskArn()] = taskEvents + taskEvents = &eventList{events: list.New(), + sending: false, + createdAt: time.Now(), + taskARN: taskARN, + } + handler.tasksToEvents[taskARN] = taskEvents + seelog.Debugf("TaskHandler: collecting events for new task; event: %s; events: %s ", + change.String(), taskEvents.toStringUnsafe()) } return taskEvents @@ -217,67 +236,108 @@ func (handler *TaskHandler) getTaskEventList(change *sendableEvent) (taskEvents // Continuously retries sending an event until it succeeds, sleeping between each // attempt -func (handler *TaskHandler) SubmitTaskEvents(taskEvents *eventList, client api.ECSClient) { - backoff := utils.NewSimpleBackoff(1*time.Second, 30*time.Second, 0.20, 1.3) +func (handler *TaskHandler) submitTaskEvents(taskEvents *eventList, client api.ECSClient, taskARN string) { + defer handler.removeTaskEvents(taskARN) + + backoff := utils.NewSimpleBackoff(submitStateBackoffMin, submitStateBackoffMax, + submitStateBackoffJitterMultiple, submitStateBackoffMultiple) // Mirror events.sending, but without the need to lock since this is local // to our goroutine done := false + sender := &taskEventsSender{ + handler: handler, + taskEvents: taskEvents, + backoff: backoff, + client: client, + } + // TODO: wire in the context here. Else, we have go routine leaks in tests for !done { // If we looped back up here, we successfully submitted an event, but // we haven't emptied the list so we should keep submitting backoff.Reset() utils.RetryWithBackoff(backoff, func() error { - // Lock and unlock within this function, allowing the list to be added - // to while we're not actively sending an event - seelog.Debug("TaskHandler, Waiting on semaphore to send...") - handler.submitSemaphore.Wait() - defer handler.submitSemaphore.Post() + var err error + done, err = sender.send() + return err + }) + } +} - seelog.Debug("TaskHandler, Aquiring lock for sending event...") - taskEvents.eventListLock.Lock() - defer taskEvents.eventListLock.Unlock() - seelog.Debug("TaskHandler, Aquired lock!") +func (handler *TaskHandler) removeTaskEvents(taskARN string) { + handler.lock.Lock() + defer handler.lock.Unlock() - var err error + delete(handler.tasksToEvents, taskARN) +} - if taskEvents.events.Len() == 0 { - seelog.Debug("TaskHandler, No events left; not retrying more") +func (handler *TaskHandler) getTasksToEventsLen() int { + handler.lock.RLock() + defer handler.lock.RUnlock() - taskEvents.sending = false - done = true - return nil - } + return len(handler.tasksToEvents) +} - eventToSubmit := taskEvents.events.Front() - event := eventToSubmit.Value.(*sendableEvent) - - if event.containerShouldBeSent() { - sendEvent(sendContainerStatusToECS, setContainerChangeSent, "container", client, - eventToSubmit, handler.stateSaver, backoff, taskEvents) - } else if event.taskShouldBeSent() { - sendEvent(sendTaskStatusToECS, setTaskChangeSent, "task", client, - eventToSubmit, handler.stateSaver, backoff, taskEvents) - } else if event.taskAttachmentShouldBeSent() { - sendEvent(sendTaskStatusToECS, setTaskAttachmentSent, "task attachment", client, - eventToSubmit, handler.stateSaver, backoff, taskEvents) - } else { - // Shouldn't be sent as either a task or container change event; must have been already sent - seelog.Infof("TaskHandler, Not submitting redundant event; just removing: %s", event.String()) - taskEvents.events.Remove(eventToSubmit) - } +type taskEventsSender struct { + handler *TaskHandler + taskEvents *eventList + backoff utils.Backoff + client api.ECSClient +} - if taskEvents.events.Len() == 0 { - seelog.Debug("TaskHandler, Removed the last element, no longer sending") - taskEvents.sending = false - done = true - return nil - } +func (sender *taskEventsSender) send() (bool, error) { + // Lock and unlock within this function, allowing the list to be added + // to while we're not actively sending an event + seelog.Debug("TaskHandler: Waiting on semaphore to send events...") + + handler := sender.handler + handler.submitSemaphore.Wait() + defer handler.submitSemaphore.Post() + + seelog.Debug("TaskHandler: Aquiring lock for sending event...") + taskEvents := sender.taskEvents + taskEvents.lock.Lock() + defer taskEvents.lock.Unlock() + seelog.Debugf("TaskHandler: Aquired lock, processing event list: : %s", taskEvents.toStringUnsafe()) + + if taskEvents.events.Len() == 0 { + seelog.Debug("TaskHandler: No events left; not retrying more") + taskEvents.sending = false + return true, nil + } - return err - }) + eventToSubmit := taskEvents.events.Front() + event := eventToSubmit.Value.(*sendableEvent) + + if event.containerShouldBeSent() { + if err := sendEvent(sendContainerStatusToECS, setContainerChangeSent, "container", + sender.client, eventToSubmit, handler.stateSaver, sender.backoff, taskEvents); err != nil { + return false, err + } + } else if event.taskShouldBeSent() { + if err := sendEvent(sendTaskStatusToECS, setTaskChangeSent, "task", sender.client, + eventToSubmit, handler.stateSaver, sender.backoff, taskEvents); err != nil { + return false, err + } + } else if event.taskAttachmentShouldBeSent() { + if err := sendEvent(sendTaskStatusToECS, setTaskAttachmentSent, "task attachment", + sender.client, eventToSubmit, handler.stateSaver, sender.backoff, taskEvents); err != nil { + return false, err + } + } else { + // Shouldn't be sent as either a task or container change event; must have been already sent + seelog.Infof("TaskHandler: Not submitting redundant event; just removing: %s", event.String()) + taskEvents.events.Remove(eventToSubmit) } + + if taskEvents.events.Len() == 0 { + seelog.Debug("TaskHandler: Removed the last element, no longer sending") + taskEvents.sending = false + return true, nil + } + + return false, nil } // sendEvent tries to send an event, specified by 'eventToSubmit', of type @@ -288,17 +348,16 @@ func sendEvent(sendStatusToECS sendStatusChangeToECS, client api.ECSClient, eventToSubmit *list.Element, stateSaver statemanager.Saver, - backoff *utils.SimpleBackoff, - taskEvents *eventList) { - + backoff utils.Backoff, + taskEvents *eventList) error { // Extract the wrapped event from the list element event := eventToSubmit.Value.(*sendableEvent) - seelog.Infof("TaskHandler, Sending %s change: %s", eventType, event.String()) + seelog.Infof("TaskHandler: Sending %s change: %s", eventType, event.String()) // Try submitting the change to ECS if err := sendStatusToECS(client, event); err != nil { - seelog.Errorf("TaskHandler, Unretriable error submitting %s state change [%s]: %v", + seelog.Errorf("TaskHandler: Unretriable error submitting %s state change [%s]: %v", eventType, event.String(), err) - return + return err } // submitted; ensure we don't retry it event.setSent() @@ -306,9 +365,10 @@ func sendEvent(sendStatusToECS sendStatusChangeToECS, setChangeSent(event) // Update the state file stateSaver.Save() - seelog.Debugf("TaskHandler, Submitted container state change: %s", event.String()) - backoff.Reset() + seelog.Debugf("TaskHandler: Submitted container state change: %s", event.String()) taskEvents.events.Remove(eventToSubmit) + backoff.Reset() + return nil } // sendStatusChangeToECS defines a function type for invoking the appropriate ECS state change API @@ -341,8 +401,9 @@ func setTaskChangeSent(event *sendableEvent) { if event.taskChange.Task != nil { event.taskChange.Task.SetSentStatus(event.taskChange.Status) } - for _, container := range event.taskChange.Containers { - container.Container.SetSentStatus(event.taskChange.Status.ContainerStatus(container.Container.GetSteadyStateStatus())) + for _, containerStateChange := range event.taskChange.Containers { + container := containerStateChange.Container + container.SetSentStatus(containerStateChange.Status) } } From f363f063b0e4aedacafe81be65f65c7948b2796c Mon Sep 17 00:00:00 2001 From: Aithal Date: Wed, 25 Oct 2017 14:06:25 -0700 Subject: [PATCH 48/58] eventhandler: fix events batching race There was another race condition where, if an event was already being marked for submission, the batched container changes would be lost if another submission trigger came in for the same task from the ticker. This commit makes it so that the two maps in task handler are updated in a single lock scope to avoid such a race. This commit also refactors the code to get rid of most methods that were not tied to any struct. Instead, each struct has its own methods to deal with sending state changes to ECS --- agent/eventhandler/handler_test.go | 50 ++-- agent/eventhandler/task_handler.go | 275 +++++++----------- agent/eventhandler/task_handler_types.go | 105 ++++++- agent/eventhandler/task_handler_types_test.go | 4 +- 4 files changed, 213 insertions(+), 221 deletions(-) diff --git a/agent/eventhandler/handler_test.go b/agent/eventhandler/handler_test.go index 3463ce7ebf1..8681049b537 100644 --- a/agent/eventhandler/handler_test.go +++ b/agent/eventhandler/handler_test.go @@ -351,7 +351,7 @@ func TestENISentStatusChange(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) handler := NewTaskHandler(ctx, statemanager.NewNoopStateManager(), nil, client) defer cancel() - handler.submitTaskEvents(&eventList{ + handler.submitTaskEvents(&taskSendableEvents{ events: events, }, client, taskARN) @@ -380,7 +380,7 @@ func TestGetBatchedContainerEvents(t *testing.T) { assert.Equal(t, "t1", events[0].TaskARN) } -func TestSenderWhenSendingTaskRunningAfterStopped(t *testing.T) { +func TestSubmitTaskEventsWhenSubmittingTaskRunningAfterStopped(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() @@ -391,41 +391,35 @@ func TestSenderWhenSendingTaskRunningAfterStopped(t *testing.T) { handler := &TaskHandler{ state: state, submitSemaphore: utils.NewSemaphore(concurrentEventCalls), - tasksToEvents: make(map[string]*eventList), + tasksToEvents: make(map[string]*taskSendableEvents), tasksToContainerStates: make(map[string][]api.ContainerStateChange), stateSaver: stateManager, client: client, } - taskEvents := &eventList{events: list.New(), + taskEvents := &taskSendableEvents{events: list.New(), sending: false, createdAt: time.Now(), taskARN: taskARN, } backoff := mock_utils.NewMockBackoff(ctrl) - sender := &taskEventsSender{ - handler: handler, - backoff: backoff, - client: client, - taskEvents: taskEvents, - } - ok, err := sender.send() + ok, err := taskEvents.submitFirstEvent(handler, backoff) assert.True(t, ok) assert.NoError(t, err) task := &api.Task{} - sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ TaskARN: taskARN, Status: api.TaskStopped, Task: task, })) - sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ TaskARN: taskARN, Status: api.TaskRunning, Task: task, })) - handler.tasksToEvents[taskARN] = sender.taskEvents + handler.tasksToEvents[taskARN] = taskEvents var wg sync.WaitGroup wg.Add(1) @@ -437,7 +431,7 @@ func TestSenderWhenSendingTaskRunningAfterStopped(t *testing.T) { wg.Done() }), ) - ok, err = sender.send() + ok, err = taskEvents.submitFirstEvent(handler, backoff) // We have an unsent event for the TaskRunning transition. Hence, send() returns false assert.False(t, ok) assert.NoError(t, err) @@ -445,12 +439,12 @@ func TestSenderWhenSendingTaskRunningAfterStopped(t *testing.T) { // The unsent transition is deleted from the task list. send() returns true as it // does not have any more events to process - ok, err = sender.send() + ok, err = taskEvents.submitFirstEvent(handler, backoff) assert.NoError(t, err) assert.True(t, ok) } -func TestSenderWhenSendingTaskStoppedAfterRunning(t *testing.T) { +func TestSubmitTaskEventsWhenSubmittingTaskStoppedAfterRunning(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() @@ -461,41 +455,35 @@ func TestSenderWhenSendingTaskStoppedAfterRunning(t *testing.T) { handler := &TaskHandler{ state: state, submitSemaphore: utils.NewSemaphore(concurrentEventCalls), - tasksToEvents: make(map[string]*eventList), + tasksToEvents: make(map[string]*taskSendableEvents), tasksToContainerStates: make(map[string][]api.ContainerStateChange), stateSaver: stateManager, client: client, } - taskEvents := &eventList{events: list.New(), + taskEvents := &taskSendableEvents{events: list.New(), sending: false, createdAt: time.Now(), taskARN: taskARN, } backoff := mock_utils.NewMockBackoff(ctrl) - sender := &taskEventsSender{ - handler: handler, - backoff: backoff, - client: client, - taskEvents: taskEvents, - } - ok, err := sender.send() + ok, err := taskEvents.submitFirstEvent(handler, backoff) assert.True(t, ok) assert.NoError(t, err) task := &api.Task{} - sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ TaskARN: taskARN, Status: api.TaskRunning, Task: task, })) - sender.taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ + taskEvents.events.PushBack(newSendableTaskEvent(api.TaskStateChange{ TaskARN: taskARN, Status: api.TaskStopped, Task: task, })) - handler.tasksToEvents[taskARN] = sender.taskEvents + handler.tasksToEvents[taskARN] = taskEvents var wg sync.WaitGroup wg.Add(1) @@ -508,7 +496,7 @@ func TestSenderWhenSendingTaskStoppedAfterRunning(t *testing.T) { }), ) // We have an unsent event for the TaskStopped transition. Hence, send() returns false - ok, err = sender.send() + ok, err = taskEvents.submitFirstEvent(handler, backoff) assert.False(t, ok) assert.NoError(t, err) wg.Wait() @@ -524,7 +512,7 @@ func TestSenderWhenSendingTaskStoppedAfterRunning(t *testing.T) { ) // The unsent transition is send and deleted from the task list. send() returns true as it // does not have any more events to process - ok, err = sender.send() + ok, err = taskEvents.submitFirstEvent(handler, backoff) assert.True(t, ok) assert.NoError(t, err) wg.Wait() diff --git a/agent/eventhandler/task_handler.go b/agent/eventhandler/task_handler.go index fde5fcba863..bdf4ad58ce3 100644 --- a/agent/eventhandler/task_handler.go +++ b/agent/eventhandler/task_handler.go @@ -50,8 +50,7 @@ type TaskHandler struct { // submitSemaphore for the number of tasks that may be handled at once submitSemaphore utils.Semaphore // taskToEvents is arn:*eventList map so events may be serialized per task - //TODO: fix leak, currently items are never removed from this map - tasksToEvents map[string]*eventList + tasksToEvents map[string]*taskSendableEvents // tasksToContainerStates is used to collect container events // between task transitions tasksToContainerStates map[string][]api.ContainerStateChange @@ -71,8 +70,8 @@ type TaskHandler struct { ctx context.Context } -// eventList is used to group all events for a task -type eventList struct { +// taskSendableEvents is used to group all events for a task +type taskSendableEvents struct { // events is a list of *sendableEvents events *list.List // sending will check whether the list is already being handlerd @@ -81,15 +80,10 @@ type eventList struct { lock sync.Mutex // createdAt is a timestamp for when the event list was created createdAt time.Time - // taskARN is the task arn that the event list is associated + // taskARN is the task arn that the event list is associated with taskARN string } -func (events *eventList) toStringUnsafe() string { - return fmt.Sprintf("Task event list [taskARN: %s, sending: %t, createdAt: %s]", - events.taskARN, events.sending, events.createdAt.String()) -} - // NewTaskHandler returns a pointer to TaskHandler func NewTaskHandler(ctx context.Context, stateManager statemanager.Saver, @@ -98,7 +92,7 @@ func NewTaskHandler(ctx context.Context, // Create a handler and start the periodic event drain loop taskHandler := &TaskHandler{ ctx: ctx, - tasksToEvents: make(map[string]*eventList), + tasksToEvents: make(map[string]*taskSendableEvents), submitSemaphore: utils.NewSemaphore(concurrentEventCalls), tasksToContainerStates: make(map[string][]api.ContainerStateChange), stateSaver: stateManager, @@ -111,6 +105,33 @@ func NewTaskHandler(ctx context.Context, return taskHandler } +// AddStateChangeEvent queues up a state change for sending using the given client. +func (handler *TaskHandler) AddStateChangeEvent(change statechange.Event, client api.ECSClient) error { + handler.lock.Lock() + defer handler.lock.Unlock() + + switch change.GetEventType() { + case statechange.TaskEvent: + event, ok := change.(api.TaskStateChange) + if !ok { + return errors.New("eventhandler: unable to get task event from state change event") + } + handler.flushBatchUnsafe(&event, client) + return nil + + case statechange.ContainerEvent: + event, ok := change.(api.ContainerStateChange) + if !ok { + return errors.New("eventhandler: unable to get container event from state change event") + } + handler.batchContainerEventUnsafe(event) + return nil + + default: + return errors.New("eventhandler: unable to determine event type from state change event") + } +} + // startDrainEventsTicker starts a ticker that periodically drains the events queue // by submitting state change events to the ECS backend func (handler *TaskHandler) startDrainEventsTicker() { @@ -139,7 +160,7 @@ func (handler *TaskHandler) getBatchedContainerEvents() []api.TaskStateChange { defer handler.lock.RUnlock() var events []api.TaskStateChange - for taskARN, _ := range handler.tasksToContainerStates { + for taskARN := range handler.tasksToContainerStates { if task, ok := handler.state.TaskByArn(taskARN); ok { events = append(events, api.TaskStateChange{ TaskARN: taskARN, @@ -151,84 +172,40 @@ func (handler *TaskHandler) getBatchedContainerEvents() []api.TaskStateChange { return events } -// AddStateChangeEvent queues up a state change for sending using the given client. -func (handler *TaskHandler) AddStateChangeEvent(change statechange.Event, client api.ECSClient) error { - switch change.GetEventType() { - case statechange.TaskEvent: - event, ok := change.(api.TaskStateChange) - if !ok { - return errors.New("eventhandler: unable to get task event from state change event") - } - handler.flushBatch(&event) - handler.addEvent(newSendableTaskEvent(event), client) - return nil - - case statechange.ContainerEvent: - event, ok := change.(api.ContainerStateChange) - if !ok { - return errors.New("eventhandler: unable to get container event from state change event") - } - handler.batchContainerEvent(event) - return nil - - default: - return errors.New("eventhandler: unable to determine event type from state change event") - } -} - -// batchContainerEvent collects container state change events for a given task arn -func (handler *TaskHandler) batchContainerEvent(event api.ContainerStateChange) { - handler.lock.Lock() - defer handler.lock.Unlock() - +// batchContainerEventUnsafe collects container state change events for a given task arn +func (handler *TaskHandler) batchContainerEventUnsafe(event api.ContainerStateChange) { seelog.Infof("TaskHandler: batching container event: %s", event.String()) handler.tasksToContainerStates[event.TaskArn] = append(handler.tasksToContainerStates[event.TaskArn], event) } -// flushBatch attaches the task arn's container events to TaskStateChange event that -// is being submittied to the backend -func (handler *TaskHandler) flushBatch(event *api.TaskStateChange) { - handler.lock.Lock() - defer handler.lock.Unlock() - +// flushBatchUnsafe attaches the task arn's container events to TaskStateChange event that +// is being submittied to the backend and sends it to the backend +func (handler *TaskHandler) flushBatchUnsafe(event *api.TaskStateChange, client api.ECSClient) { event.Containers = append(event.Containers, handler.tasksToContainerStates[event.TaskARN]...) delete(handler.tasksToContainerStates, event.TaskARN) -} -// addEvent prepares a given event to be sent by adding it to the handler's appropriate -// eventList and remove the entry in tasksToEvents map -func (handler *TaskHandler) addEvent(change *sendableEvent, client api.ECSClient) { - taskEvents := handler.getTaskEventList(change) + // Prepare a given event to be sent by adding it to the handler's appropriate + // eventList and remove the entry in tasksToEvents map + change := newSendableTaskEvent(*event) + taskEvents := handler.getTaskEventsUnsafe(change) - taskEvents.lock.Lock() - defer taskEvents.lock.Unlock() - - // Update taskEvent - seelog.Infof("TaskHandler: Adding event: %s", change.String()) - taskEvents.events.PushBack(change) - - if !taskEvents.sending { - taskEvents.sending = true - go handler.submitTaskEvents(taskEvents, client, change.taskArn()) - } + taskEvents.sendChange(change, client, handler) } -// getTaskEventList gets the eventList from taskToEvent map -func (handler *TaskHandler) getTaskEventList(change *sendableEvent) (taskEvents *eventList) { - handler.lock.Lock() - defer handler.lock.Unlock() - +// getTaskEventsUnsafe gets the eventList from taskToEvent map +func (handler *TaskHandler) getTaskEventsUnsafe(change *sendableEvent) *taskSendableEvents { taskARN := change.taskArn() taskEvents, ok := handler.tasksToEvents[taskARN] if !ok { - taskEvents = &eventList{events: list.New(), + taskEvents = &taskSendableEvents{ + events: list.New(), sending: false, createdAt: time.Now(), taskARN: taskARN, } handler.tasksToEvents[taskARN] = taskEvents seelog.Debugf("TaskHandler: collecting events for new task; event: %s; events: %s ", - change.String(), taskEvents.toStringUnsafe()) + change.toString(), taskEvents.toStringUnsafe()) } return taskEvents @@ -236,7 +213,7 @@ func (handler *TaskHandler) getTaskEventList(change *sendableEvent) (taskEvents // Continuously retries sending an event until it succeeds, sleeping between each // attempt -func (handler *TaskHandler) submitTaskEvents(taskEvents *eventList, client api.ECSClient, taskARN string) { +func (handler *TaskHandler) submitTaskEvents(taskEvents *taskSendableEvents, client api.ECSClient, taskARN string) { defer handler.removeTaskEvents(taskARN) backoff := utils.NewSimpleBackoff(submitStateBackoffMin, submitStateBackoffMax, @@ -245,21 +222,20 @@ func (handler *TaskHandler) submitTaskEvents(taskEvents *eventList, client api.E // Mirror events.sending, but without the need to lock since this is local // to our goroutine done := false - sender := &taskEventsSender{ - handler: handler, - taskEvents: taskEvents, - backoff: backoff, - client: client, - } - // TODO: wire in the context here. Else, we have go routine leaks in tests for !done { // If we looped back up here, we successfully submitted an event, but // we haven't emptied the list so we should keep submitting backoff.Reset() utils.RetryWithBackoff(backoff, func() error { + // Lock and unlock within this function, allowing the list to be added + // to while we're not actively sending an event + seelog.Debug("TaskHandler: Waiting on semaphore to send events...") + handler.submitSemaphore.Wait() + defer handler.submitSemaphore.Post() + var err error - done, err = sender.send() + done, err = taskEvents.submitFirstEvent(handler, backoff) return err }) } @@ -272,33 +248,38 @@ func (handler *TaskHandler) removeTaskEvents(taskARN string) { delete(handler.tasksToEvents, taskARN) } -func (handler *TaskHandler) getTasksToEventsLen() int { - handler.lock.RLock() - defer handler.lock.RUnlock() - - return len(handler.tasksToEvents) -} +// sendChange adds the change to the sendable events list. If the +// event for the task is in the process of being sent, it doesn't trigger +// the async submit state api method +func (taskEvents *taskSendableEvents) sendChange(change *sendableEvent, + client api.ECSClient, + handler *TaskHandler) { -type taskEventsSender struct { - handler *TaskHandler - taskEvents *eventList - backoff utils.Backoff - client api.ECSClient -} + taskEvents.lock.Lock() + defer taskEvents.lock.Unlock() -func (sender *taskEventsSender) send() (bool, error) { - // Lock and unlock within this function, allowing the list to be added - // to while we're not actively sending an event - seelog.Debug("TaskHandler: Waiting on semaphore to send events...") + // Update taskEvent + seelog.Infof("TaskHandler: Adding event: %s", change.toString()) + taskEvents.events.PushBack(change) - handler := sender.handler - handler.submitSemaphore.Wait() - defer handler.submitSemaphore.Post() + if !taskEvents.sending { + taskEvents.sending = true + go handler.submitTaskEvents(taskEvents, client, change.taskArn()) + } else { + seelog.Debugf("TaskHandler: Not submitting change as the task is already being sent: %s", change.toString()) + } +} +// submitFirstEvent submits the first event for the task from the event list. It +// returns true if the list became empty after submitting the event. Else, it returns +// false. An error is returned if there was an error with submitting the state change +// to ECS. The error is used by the backoff handler to backoff before retrying the +// state change submission for the first event +func (taskEvents *taskSendableEvents) submitFirstEvent(handler *TaskHandler, backoff utils.Backoff) (bool, error) { seelog.Debug("TaskHandler: Aquiring lock for sending event...") - taskEvents := sender.taskEvents taskEvents.lock.Lock() defer taskEvents.lock.Unlock() + seelog.Debugf("TaskHandler: Aquired lock, processing event list: : %s", taskEvents.toStringUnsafe()) if taskEvents.events.Len() == 0 { @@ -308,26 +289,27 @@ func (sender *taskEventsSender) send() (bool, error) { } eventToSubmit := taskEvents.events.Front() + // Extract the wrapped event from the list element event := eventToSubmit.Value.(*sendableEvent) if event.containerShouldBeSent() { - if err := sendEvent(sendContainerStatusToECS, setContainerChangeSent, "container", - sender.client, eventToSubmit, handler.stateSaver, sender.backoff, taskEvents); err != nil { + if err := event.send(sendContainerStatusToECS, setContainerChangeSent, "container", + handler.client, eventToSubmit, handler.stateSaver, backoff, taskEvents); err != nil { return false, err } } else if event.taskShouldBeSent() { - if err := sendEvent(sendTaskStatusToECS, setTaskChangeSent, "task", sender.client, - eventToSubmit, handler.stateSaver, sender.backoff, taskEvents); err != nil { + if err := event.send(sendTaskStatusToECS, setTaskChangeSent, "task", + handler.client, eventToSubmit, handler.stateSaver, backoff, taskEvents); err != nil { return false, err } } else if event.taskAttachmentShouldBeSent() { - if err := sendEvent(sendTaskStatusToECS, setTaskAttachmentSent, "task attachment", - sender.client, eventToSubmit, handler.stateSaver, sender.backoff, taskEvents); err != nil { + if err := event.send(sendTaskStatusToECS, setTaskAttachmentSent, "task attachment", + handler.client, eventToSubmit, handler.stateSaver, backoff, taskEvents); err != nil { return false, err } } else { // Shouldn't be sent as either a task or container change event; must have been already sent - seelog.Infof("TaskHandler: Not submitting redundant event; just removing: %s", event.String()) + seelog.Infof("TaskHandler: Not submitting redundant event; just removing: %s", event.toString()) taskEvents.events.Remove(eventToSubmit) } @@ -340,77 +322,16 @@ func (sender *taskEventsSender) send() (bool, error) { return false, nil } -// sendEvent tries to send an event, specified by 'eventToSubmit', of type -// 'eventType' to ECS -func sendEvent(sendStatusToECS sendStatusChangeToECS, - setChangeSent setStatusSent, - eventType string, - client api.ECSClient, - eventToSubmit *list.Element, - stateSaver statemanager.Saver, - backoff utils.Backoff, - taskEvents *eventList) error { - // Extract the wrapped event from the list element - event := eventToSubmit.Value.(*sendableEvent) - seelog.Infof("TaskHandler: Sending %s change: %s", eventType, event.String()) - // Try submitting the change to ECS - if err := sendStatusToECS(client, event); err != nil { - seelog.Errorf("TaskHandler: Unretriable error submitting %s state change [%s]: %v", - eventType, event.String(), err) - 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 container state change: %s", event.String()) - taskEvents.events.Remove(eventToSubmit) - backoff.Reset() - return nil -} - -// sendStatusChangeToECS defines a function type for invoking the appropriate ECS state change API -type sendStatusChangeToECS func(client api.ECSClient, event *sendableEvent) error - -// sendContainerStatusToECS invokes the SubmitContainerStateChange API to send a -// container status change to ECS -func sendContainerStatusToECS(client api.ECSClient, event *sendableEvent) error { - return client.SubmitContainerStateChange(event.containerChange) -} - -// sendTaskStatusToECS invokes the SubmitTaskStateChange API to send a task -// status change to ECS -func sendTaskStatusToECS(client api.ECSClient, event *sendableEvent) error { - return client.SubmitTaskStateChange(event.taskChange) -} - -// setStatusSent defines a function type to mark the event as sent -type setStatusSent func(event *sendableEvent) - -// setContainerChangeSent sets the event's container change object as sent -func setContainerChangeSent(event *sendableEvent) { - if event.containerChange.Container != nil { - event.containerChange.Container.SetSentStatus(event.containerChange.Status) - } +func (taskEvents *taskSendableEvents) toStringUnsafe() string { + return fmt.Sprintf("Task event list [taskARN: %s, sending: %t, createdAt: %s]", + taskEvents.taskARN, taskEvents.sending, taskEvents.createdAt.String()) } -// setTaskChangeSent sets the event's task change object as sent -func setTaskChangeSent(event *sendableEvent) { - if event.taskChange.Task != nil { - event.taskChange.Task.SetSentStatus(event.taskChange.Status) - } - for _, containerStateChange := range event.taskChange.Containers { - container := containerStateChange.Container - container.SetSentStatus(containerStateChange.Status) - } -} +// getTasksToEventsLen returns the length of the tasksToEvents map. It is +// used only in the test code to ascertain that map has been cleaned up +func (handler *TaskHandler) getTasksToEventsLen() int { + handler.lock.RLock() + defer handler.lock.RUnlock() -// setTaskAttachmentSent sets the event's task attachment object as sent -func setTaskAttachmentSent(event *sendableEvent) { - if event.taskChange.Attachment != nil { - event.taskChange.Attachment.SetSentStatus() - event.taskChange.Attachment.StopAckTimer() - } + return len(handler.tasksToEvents) } diff --git a/agent/eventhandler/task_handler_types.go b/agent/eventhandler/task_handler_types.go index 9cbd6cbbe90..690d97c7a71 100644 --- a/agent/eventhandler/task_handler_types.go +++ b/agent/eventhandler/task_handler_types.go @@ -14,10 +14,14 @@ package eventhandler import ( + "container/list" "fmt" "sync" "github.com/aws/amazon-ecs-agent/agent/api" + "github.com/aws/amazon-ecs-agent/agent/statemanager" + "github.com/aws/amazon-ecs-agent/agent/utils" + "github.com/cihub/seelog" ) // a state change that may have a container and, optionally, a task event to @@ -35,17 +39,6 @@ type sendableEvent struct { lock sync.RWMutex } -func (event *sendableEvent) String() string { - event.lock.RLock() - defer event.lock.RUnlock() - - if event.isContainerEvent { - return "ContainerChange: [" + event.containerChange.String() + fmt.Sprintf("] sent: %t", event.containerSent) - } else { - return "TaskChange: [" + event.taskChange.String() + fmt.Sprintf("] sent: %t", event.taskSent) - } -} - func newSendableContainerEvent(event api.ContainerStateChange) *sendableEvent { return &sendableEvent{ isContainerEvent: true, @@ -84,9 +77,13 @@ func (event *sendableEvent) taskShouldBeSent() bool { return false // redundant event } if tevent.Task != nil && tevent.Task.GetSentStatus() >= tevent.Status { + // If the task status has already been sent, check if there are + // any container states that need to be 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 } } @@ -131,3 +128,89 @@ func (event *sendableEvent) setSent() { event.taskSent = true } } + +// send tries to send an event, specified by 'eventToSubmit', of type +// 'eventType' to ECS +func (event *sendableEvent) send( + sendStatusToECS sendStatusChangeToECS, + setChangeSent setStatusSent, + eventType string, + client api.ECSClient, + eventToSubmit *list.Element, + stateSaver statemanager.Saver, + backoff utils.Backoff, + taskEvents *taskSendableEvents) error { + + seelog.Infof("TaskHandler: Sending %s change: %s", eventType, event.toString()) + // Try submitting the change to ECS + if err := sendStatusToECS(client, event); err != nil { + seelog.Errorf("TaskHandler: Unretriable error submitting %s state change [%s]: %v", + eventType, event.toString(), err) + 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 container state change: %s", event.toString()) + taskEvents.events.Remove(eventToSubmit) + backoff.Reset() + return nil +} + +// sendStatusChangeToECS defines a function type for invoking the appropriate ECS state change API +type sendStatusChangeToECS func(client api.ECSClient, event *sendableEvent) error + +// sendContainerStatusToECS invokes the SubmitContainerStateChange API to send a +// container status change to ECS +func sendContainerStatusToECS(client api.ECSClient, event *sendableEvent) error { + return client.SubmitContainerStateChange(event.containerChange) +} + +// sendTaskStatusToECS invokes the SubmitTaskStateChange API to send a task +// status change to ECS +func sendTaskStatusToECS(client api.ECSClient, event *sendableEvent) error { + return client.SubmitTaskStateChange(event.taskChange) +} + +// setStatusSent defines a function type to mark the event as sent +type setStatusSent func(event *sendableEvent) + +// setContainerChangeSent sets the event's container change object as sent +func setContainerChangeSent(event *sendableEvent) { + if event.containerChange.Container != nil { + event.containerChange.Container.SetSentStatus(event.containerChange.Status) + } +} + +// setTaskChangeSent sets the event's task change object as sent +func setTaskChangeSent(event *sendableEvent) { + if event.taskChange.Task != nil { + event.taskChange.Task.SetSentStatus(event.taskChange.Status) + } + for _, containerStateChange := range event.taskChange.Containers { + container := containerStateChange.Container + container.SetSentStatus(containerStateChange.Status) + } +} + +// setTaskAttachmentSent sets the event's task attachment object as sent +func setTaskAttachmentSent(event *sendableEvent) { + if event.taskChange.Attachment != nil { + event.taskChange.Attachment.SetSentStatus() + event.taskChange.Attachment.StopAckTimer() + } +} + +func (event *sendableEvent) toString() string { + event.lock.RLock() + defer event.lock.RUnlock() + + if event.isContainerEvent { + return "ContainerChange: [" + event.containerChange.String() + fmt.Sprintf("] sent: %t", event.containerSent) + } else { + return "TaskChange: [" + event.taskChange.String() + fmt.Sprintf("] sent: %t", event.taskSent) + } +} diff --git a/agent/eventhandler/task_handler_types_test.go b/agent/eventhandler/task_handler_types_test.go index 2259d6cbe1f..bd089207606 100644 --- a/agent/eventhandler/task_handler_types_test.go +++ b/agent/eventhandler/task_handler_types_test.go @@ -119,7 +119,7 @@ func TestShouldTaskEventBeSent(t *testing.T) { shouldBeSent: false, }, } { - t.Run(fmt.Sprintf("Event[%s] should be sent[%t]", tc.event.String(), tc.shouldBeSent), func(t *testing.T) { + t.Run(fmt.Sprintf("Event[%s] should be sent[%t]", tc.event.toString(), tc.shouldBeSent), func(t *testing.T) { assert.Equal(t, tc.shouldBeSent, tc.event.taskShouldBeSent()) assert.Equal(t, false, tc.event.containerShouldBeSent()) assert.Equal(t, false, tc.event.taskAttachmentShouldBeSent()) @@ -193,7 +193,7 @@ func TestShouldTaskAttachmentEventBeSent(t *testing.T) { }, } { t.Run(fmt.Sprintf("Event[%s] should be sent[attachment=%t;task=%t]", - tc.event.String(), tc.attachmentShouldBeSent, tc.taskShouldBeSent), func(t *testing.T) { + tc.event.toString(), tc.attachmentShouldBeSent, tc.taskShouldBeSent), func(t *testing.T) { assert.Equal(t, tc.attachmentShouldBeSent, tc.event.taskAttachmentShouldBeSent()) assert.Equal(t, tc.taskShouldBeSent, tc.event.taskShouldBeSent()) assert.Equal(t, false, tc.event.containerShouldBeSent()) From 4d9cdf2d952a7cae029d8a44fb2c76dfb9bff5a6 Mon Sep 17 00:00:00 2001 From: Aithal Date: Fri, 27 Oct 2017 12:54:33 -0700 Subject: [PATCH 49/58] eventhandler: Reduce drain events frequency to 20s --- agent/eventhandler/handler_test.go | 2 +- agent/eventhandler/task_handler.go | 95 ++++++++++++++++++++---------- 2 files changed, 66 insertions(+), 31 deletions(-) diff --git a/agent/eventhandler/handler_test.go b/agent/eventhandler/handler_test.go index 8681049b537..31db0def84c 100644 --- a/agent/eventhandler/handler_test.go +++ b/agent/eventhandler/handler_test.go @@ -375,7 +375,7 @@ func TestGetBatchedContainerEvents(t *testing.T) { state.EXPECT().TaskByArn("t1").Return(&api.Task{Arn: "t1", KnownStatusUnsafe: api.TaskRunning}, true) state.EXPECT().TaskByArn("t2").Return(nil, false) - events := handler.getBatchedContainerEvents() + events := handler.taskStateChangesToSend() assert.Len(t, events, 1) assert.Equal(t, "t1", events[0].TaskARN) } diff --git a/agent/eventhandler/task_handler.go b/agent/eventhandler/task_handler.go index bdf4ad58ce3..4e61297d006 100644 --- a/agent/eventhandler/task_handler.go +++ b/agent/eventhandler/task_handler.go @@ -36,7 +36,7 @@ const ( // drainEventsFrequency is the frequency at the which unsent events batched // by the task handler are sent to the backend - drainEventsFrequency = time.Minute + drainEventsFrequency = 20 * time.Second submitStateBackoffMin = time.Second submitStateBackoffMax = 30 * time.Second @@ -72,9 +72,12 @@ type TaskHandler struct { // taskSendableEvents is used to group all events for a task type taskSendableEvents struct { - // events is a list of *sendableEvents + // events is a list of *sendableEvents. We treat this as queue, where + // new events are added to the back of the queue and old events are + // drained from the front. `sendChange` pushes an event to the back of + // the queue. An event is removed from the queue in `submitFirstEvent` events *list.List - // sending will check whether the list is already being handlerd + // sending will check whether the list is already being handled sending bool //eventsListLock locks both the list and sending bool lock sync.Mutex @@ -105,7 +108,12 @@ func NewTaskHandler(ctx context.Context, return taskHandler } -// AddStateChangeEvent queues up a state change for sending using the given client. +// AddStateChangeEvent queues up the state change event to be sent to ECS. +// If the event is for a container state change, it just gets added to the +// handler.tasksToContainerStates map. +// If the event is for task state change, it triggers the non-blocking +// handler.submitTaskEvents method to submit the batched container state +// changes and the task state change to ECS func (handler *TaskHandler) AddStateChangeEvent(change statechange.Event, client api.ECSClient) error { handler.lock.Lock() defer handler.lock.Unlock() @@ -116,6 +124,9 @@ func (handler *TaskHandler) AddStateChangeEvent(change statechange.Event, client if !ok { return errors.New("eventhandler: unable to get task event from state change event") } + // Task event: gather all the container events and send them + // to ECS by invoking the async submitTaskEvents method from + // the sendable event list object handler.flushBatchUnsafe(&event, client) return nil @@ -143,24 +154,35 @@ func (handler *TaskHandler) startDrainEventsTicker() { ticker.Stop() return case <-ticker.C: - for _, event := range handler.getBatchedContainerEvents() { + // Gather a list of task state changes to send. This list is + // constructed from the tasksToEvents map based on the task + // arns of containers that haven't been sent to ECS yet. + for _, taskEvent := range handler.taskStateChangesToSend() { seelog.Infof( "TaskHandler: Adding a state change event to send batched container events: %s", - event.String()) - handler.AddStateChangeEvent(event, handler.client) + taskEvent.String()) + // Force start the the task state change submission + // workflow by calling AddStateChangeEvent method. + handler.AddStateChangeEvent(taskEvent, handler.client) } } } } -// getBatchedContainerEvents gets a list task state changes for container events that +// taskStateChangesToSend gets a list task state changes for container events that // have been batched and not sent beyond the drainEventsFrequency threshold -func (handler *TaskHandler) getBatchedContainerEvents() []api.TaskStateChange { +func (handler *TaskHandler) taskStateChangesToSend() []api.TaskStateChange { handler.lock.RLock() defer handler.lock.RUnlock() var events []api.TaskStateChange for taskARN := range handler.tasksToContainerStates { + // An entry for the task in tasksToContainerStates means that there + // is at least 1 container event for that task that hasn't been sent + // to ECS (has been batched). + // Make sure that the engine's task state knows about this task (as a + // safety mechanism) and add it to the list of task state changes + // that need to be sent to ECS if task, ok := handler.state.TaskByArn(taskARN); ok { events = append(events, api.TaskStateChange{ TaskARN: taskARN, @@ -178,25 +200,34 @@ func (handler *TaskHandler) batchContainerEventUnsafe(event api.ContainerStateCh handler.tasksToContainerStates[event.TaskArn] = append(handler.tasksToContainerStates[event.TaskArn], event) } -// flushBatchUnsafe attaches the task arn's container events to TaskStateChange event that -// is being submittied to the backend and sends it to the backend -func (handler *TaskHandler) flushBatchUnsafe(event *api.TaskStateChange, client api.ECSClient) { - event.Containers = append(event.Containers, handler.tasksToContainerStates[event.TaskARN]...) - delete(handler.tasksToContainerStates, event.TaskARN) - - // Prepare a given event to be sent by adding it to the handler's appropriate - // eventList and remove the entry in tasksToEvents map - change := newSendableTaskEvent(*event) - taskEvents := handler.getTaskEventsUnsafe(change) - - taskEvents.sendChange(change, client, handler) +// flushBatchUnsafe attaches the task arn's container events to TaskStateChange event +// by creating the sendable event list. It then submits this event to ECS asynchronously +func (handler *TaskHandler) flushBatchUnsafe(taskStateChange *api.TaskStateChange, client api.ECSClient) { + taskStateChange.Containers = append(taskStateChange.Containers, + handler.tasksToContainerStates[taskStateChange.TaskARN]...) + // All container events for the task have now been copied to the + // task state change object. Remove them from the map + delete(handler.tasksToContainerStates, taskStateChange.TaskARN) + + // Prepare a given event to be sent by adding it to the handler's + // eventList + event := newSendableTaskEvent(*taskStateChange) + taskEvents := handler.getTaskEventsUnsafe(event) + + // Add the event to the sendable events queue for the task and + // start sending it asynchronously if possible + taskEvents.sendChange(event, client, handler) } -// getTaskEventsUnsafe gets the eventList from taskToEvent map -func (handler *TaskHandler) getTaskEventsUnsafe(change *sendableEvent) *taskSendableEvents { - taskARN := change.taskArn() +// getTaskEventsUnsafe gets the event list for the task arn in the sendableEvent +// from taskToEvent map +func (handler *TaskHandler) getTaskEventsUnsafe(event *sendableEvent) *taskSendableEvents { + taskARN := event.taskArn() taskEvents, ok := handler.tasksToEvents[taskARN] + if !ok { + // We are not tracking this task arn in the tasksToEvents map. Create + // a new entry taskEvents = &taskSendableEvents{ events: list.New(), sending: false, @@ -205,7 +236,7 @@ func (handler *TaskHandler) getTaskEventsUnsafe(change *sendableEvent) *taskSend } handler.tasksToEvents[taskARN] = taskEvents seelog.Debugf("TaskHandler: collecting events for new task; event: %s; events: %s ", - change.toString(), taskEvents.toStringUnsafe()) + event.toString(), taskEvents.toStringUnsafe()) } return taskEvents @@ -248,9 +279,9 @@ func (handler *TaskHandler) removeTaskEvents(taskARN string) { delete(handler.tasksToEvents, taskARN) } -// sendChange adds the change to the sendable events list. If the -// event for the task is in the process of being sent, it doesn't trigger -// the async submit state api method +// sendChange adds the change to the sendable events queue. It triggers +// the handler's submitTaskEvents async method to submit this change if +// there's no go routines already sending changes for this event list func (taskEvents *taskSendableEvents) sendChange(change *sendableEvent, client api.ECSClient, handler *TaskHandler) { @@ -258,15 +289,19 @@ func (taskEvents *taskSendableEvents) sendChange(change *sendableEvent, taskEvents.lock.Lock() defer taskEvents.lock.Unlock() - // Update taskEvent + // Add event to the queue seelog.Infof("TaskHandler: Adding event: %s", change.toString()) taskEvents.events.PushBack(change) if !taskEvents.sending { + // If a send event is not already in progress, trigger the + // submitTaskEvents to start sending changes to ECS taskEvents.sending = true go handler.submitTaskEvents(taskEvents, client, change.taskArn()) } else { - seelog.Debugf("TaskHandler: Not submitting change as the task is already being sent: %s", change.toString()) + seelog.Debugf( + "TaskHandler: Not submitting change as the task is already being sent: %s", + change.toString()) } } From b7688c21d67238f284f41d7c52a427433eb34d01 Mon Sep 17 00:00:00 2001 From: Aithal Date: Mon, 23 Oct 2017 08:40:17 -0700 Subject: [PATCH 50/58] acs model changes for ENI DNS settings Update ACS model for getting DNS information about the ENI --- agent/acs/model/api/api-2.json | 4 +++- agent/acs/model/ecsacs/api.go | 4 ++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/agent/acs/model/api/api-2.json b/agent/acs/model/api/api-2.json index ffab619bf89..a43208aba50 100644 --- a/agent/acs/model/api/api-2.json +++ b/agent/acs/model/api/api-2.json @@ -191,7 +191,9 @@ "attachmentArn":{"shape":"String"}, "ec2Id":{"shape":"String"}, "ipv4Addresses":{"shape":"IPv4AddressList"}, - "ipv6Addresses":{"shape":"IPv6AddressList"} + "ipv6Addresses":{"shape":"IPv6AddressList"}, + "domainName":{"shape":"StringList"}, + "domainNameServers":{"shape":"StringList"} } }, "ElasticNetworkInterfaceList":{ diff --git a/agent/acs/model/ecsacs/api.go b/agent/acs/model/ecsacs/api.go index 3c6d1159ebe..f3efe0ddb1e 100644 --- a/agent/acs/model/ecsacs/api.go +++ b/agent/acs/model/ecsacs/api.go @@ -198,6 +198,10 @@ type ElasticNetworkInterface struct { AttachmentArn *string `locationName:"attachmentArn" type:"string"` + DomainName []*string `locationName:"domainName" type:"list"` + + DomainNameServers []*string `locationName:"domainNameServers" type:"list"` + Ec2Id *string `locationName:"ec2Id" type:"string"` Ipv4Addresses []*IPv4AddressAssignment `locationName:"ipv4Addresses" type:"list"` From fd4a34bd3ec50eaa3f4fa8abfd4925291664b0a3 Mon Sep 17 00:00:00 2001 From: Aithal Date: Mon, 23 Oct 2017 08:41:14 -0700 Subject: [PATCH 51/58] api: apply DNS overrides in container's hostconfig If the container belongs to a task with an ENI, and if the ENI object has custom DNS overrides specified, override it in the container's host config as well. --- agent/api/ecsclient/.client.go.swo | Bin 0 -> 16384 bytes agent/api/eni.go | 12 ++++++++++++ agent/api/eni_test.go | 15 ++++++++++++++- agent/api/task.go | 27 +++++++++++++++++++++++++++ agent/api/task_test.go | 18 ++++++++++++++++++ 5 files changed, 71 insertions(+), 1 deletion(-) create mode 100644 agent/api/ecsclient/.client.go.swo diff --git a/agent/api/ecsclient/.client.go.swo b/agent/api/ecsclient/.client.go.swo new file mode 100644 index 0000000000000000000000000000000000000000..a791ee6469c3eb9e0c32b620bfe5f69e6c8cf230 GIT binary patch literal 16384 zcmeHOUu+yl8Q;>Da3l?gfJkuIHpalGv8-k|+wHTJO%?ZN0a< z*`2lHR4oEE5`BUvs1OeYAypJm5iJOWpr{B$1uB0eq&^@-5kiT4Zm+@_HOTw z9S8A*_LQIRcIKOzZ+`R5x8HobS)V=MILnTivj#rzG>j+y^3ug$fB%cOy>ikpELU_b zk1BTmw2#c&$39{mwGJO{o0cz3t7lyceA5nkLk%BQ9agu3Xd@0Sn^)t=u68g=vQENP zYb&m*wlmz0XRHqQMOFU|-73m#&!sZ;Wp;w0{_~5Rft-Qe7`V&$@Z4d!)jwFghu!_I zbGr%WbvXk$133dZ133dZ133dZ133dZ1OI0Xi11G16PVLm^t`(I`?itq8~Srmm%AhN zZ|Ztqm%lJl|AwyL(&e*yfOMSOb@?g%{nSXkF3!Jl266^+266^+266^+266^+266^+ z266^+266`e3kEF5Fz!IRAJKUm&;Qf&|2N-Z7~cTaf%gG74jRV4ftP{b0-pws1An{A zFn$R90Qeg4H1H+h^T20;>%cW20z;nQ}KpR*A-VeM1 za$g7j1$-U24jcgv0tbNozzaxzM8E;ybtGbb415cC21tNq;0$mYphS&aE4|j$DidAK z9NxAPPcYj{V!-R+U165*u!xH!@?$9-@s3Mk+%eF8O<&amUs$fsqlO;~ z%eOhREzeFoOK{c93d1M}BNqkeE)J3iBUG3jaS}0%M~s3Rg-xS6H0w&4^n2Or@e1=@ z&nU#4dqKx+`0b!wD%NEO4zv2|`w(>&*rB+H?o}_;x@;6MMmk6ll{|`2pu4L_u5h6< zbr~d{!~6h@$j;MV(C4OVhQ2@&+OvC3kW%bn(moDlpKRd-TF|Q|CQ;#7kyBTfN>@Fz z(iC1vF^7s8ewc`dbv^04z@{=Yc%*E!6W?Yf)jON6tu{{9o2v6N8|n%&axtkF7K_OB zJ7rc7ss$x zeupas*$Eaq8@tY+$whOtadYu>3GJ8_x+W%@sYi{TLOX!b`VVniV4Bbs1|^u=3q9V$ zDp3v7o9*=C5u%pk)%h(ztcZ@Zn0NUFK2kRotSSa{d+R-<4OD;sHXd#nQD+U-nb zcN6yWC=s-+t$5qF&1JrIX6>A$t(1`xvZU!=gQFTNZne(9Y3#rNb?x)5jBRH(j&v08 zub4G;F~k(LBsT(;N-;b(EM5L4-=dpnzt=A?^|A|?>XhQlq^T=o5Yn@a7n7qa7Rk>I zI$CPAR{MLqD@153H%H1uLE<}bJ7LT1@gNa!#c~E_&9-?caF^hA67f2Z1QZLMseT&N&4|%La1Op@q_mv696d!$T}^>a z>#3+7VL{^xKxUvKIr&uGigJLUsPDN;UO1}@-1<&~8c@@bVsg(-l*3!zk7Q0YeTdOU%8Yi1z6TPO;kZ zMRvNeyofj!uYdDMc197P)S~Dqb&IU+dI(l+yc`}{{x*e%f}%Jo)&ZTAK#_wJP2{d) z5D`>Crw7D}gAu_T-S|jL zQpj`VA!!Q}$Z}`08mhx>7PP52GlY{_keXB@9lXNM^N8;J42rQ5F<;br70V{O7$mG` zZEJ<==sa>eT>+PM_{a?Y+{bGDH|{H}f%rx)F2(h2@Iwc-7;1SQTcdU{j(jnXHnH#q zo&Ohbj`eZIrStzOeXe{JXZ}9|PXI1Z2kr*`i8KGNfUf|L10CR_zzk3Zrhpqb-@gew z3w#+^0*(X6fC?}Tlz|s<=6@Wx3UmMmuz~x4dEf}}OPu#V13U`!fQNunz&_v(;CA38 zocDhL{2W*Vrh(t%jQ<266^+266^+25yakL539PX(S4DI#h*o=IAjHM;1{+OgfyEtwnx?spdHL zAWl(7Mv56Ie~H5fXENc3L#K&wGm|kznp3At$5Nk2Ocn|{ZJABXAbBa%pei&@Q@NC( zsgEi~nalcj9yj+xa(H?}FZTpgsfgi5eZs!@4XoLf~Ud6BOt9prr*{${X2 zVdA7VGOE4zP<$_Cl_zMLrITXn3L-spry^spIk{6DPg9zS>NFRX&ROQWDb<`71RIhA zib9<* zgEbg4xd(PIImJyY+GZUtRF2kXNYJ4`8XK9P9BkL@urq0mCoRPw-+dEeGKuia^9PFg zn=)g5-trP&qK#p;I3<&zamspGZNH%{q8}>Y=p~bI#busFoiqE>B&J6 z++cktkHJp#pDtuJV*k;_*gm9Q-vZJf}1j@hfHA9q^s&$`R$f@45Qfhou^-Y6RBMD?}j~*$d zy$#I-3sgwwIWC$q0x9_zr;@5fq7gk=(}rNuP^5rd0nB4$$|T>jHhAgMW$6)z=UrhQ d_e 0 { + hostConfig.DNS = eni.DomainNameServers + } + if len(eni.DomainNameSearchList) > 0 { + hostConfig.DNSSearch = eni.DomainNameSearchList + } + + return hostConfig +} + func (task *Task) dockerLinks(container *Container, dockerContainerMap map[string]*DockerContainer) ([]string, error) { dockerLinkArr := make([]string, len(container.Links)) for i, link := range container.Links { diff --git a/agent/api/task_test.go b/agent/api/task_test.go index 48d9688cc85..e4a50c23bc5 100644 --- a/agent/api/task_test.go +++ b/agent/api/task_test.go @@ -313,6 +313,24 @@ func TestDockerHostConfigPauseContainer(t *testing.T) { config, err = testTask.DockerHostConfig(testTask.Containers[2], dockerMap(testTask)) assert.Nil(t, err) assert.Equal(t, networkModeNone, config.NetworkMode) + + // Verify that overridden DNS settings are set for the "pause" container + // and not set for non "pause" containers + testTask.ENI.DomainNameServers = []string{"169.254.169.253"} + testTask.ENI.DomainNameSearchList = []string{"us-west-2.compute.internal"} + + // DNS overrides are only applied to the pause container. Verify that the non-pause + // container contains no overrides + config, err = testTask.DockerHostConfig(testTask.Containers[0], dockerMap(testTask)) + assert.Nil(t, err) + assert.Equal(t, 0, len(config.DNS)) + assert.Equal(t, 0, len(config.DNSSearch)) + + // Verify DNS settings are overridden for the pause container + config, err = testTask.DockerHostConfig(testTask.Containers[2], dockerMap(testTask)) + assert.Nil(t, err) + assert.Equal(t, []string{"169.254.169.253"}, config.DNS) + assert.Equal(t, []string{"us-west-2.compute.internal"}, config.DNSSearch) } func TestBadDockerHostConfigRawConfig(t *testing.T) { From b10ab3ec16ac3ec3c46e5d625b621a7d01bc37b1 Mon Sep 17 00:00:00 2001 From: Aithal Date: Thu, 26 Oct 2017 15:09:25 -0700 Subject: [PATCH 52/58] state: Note about DNS entries for the ENI object Record the new DNS fields in ENI state for the statemanager's version bump for the state file --- agent/api/ecsclient/.client.go.swo | Bin 16384 -> 0 bytes agent/api/eni.go | 19 +++++++++++++++++++ agent/api/task.go | 16 ++++++++-------- agent/statemanager/state_manager.go | 3 ++- 4 files changed, 29 insertions(+), 9 deletions(-) delete mode 100644 agent/api/ecsclient/.client.go.swo diff --git a/agent/api/ecsclient/.client.go.swo b/agent/api/ecsclient/.client.go.swo deleted file mode 100644 index a791ee6469c3eb9e0c32b620bfe5f69e6c8cf230..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 16384 zcmeHOUu+yl8Q;>Da3l?gfJkuIHpalGv8-k|+wHTJO%?ZN0a< z*`2lHR4oEE5`BUvs1OeYAypJm5iJOWpr{B$1uB0eq&^@-5kiT4Zm+@_HOTw z9S8A*_LQIRcIKOzZ+`R5x8HobS)V=MILnTivj#rzG>j+y^3ug$fB%cOy>ikpELU_b zk1BTmw2#c&$39{mwGJO{o0cz3t7lyceA5nkLk%BQ9agu3Xd@0Sn^)t=u68g=vQENP zYb&m*wlmz0XRHqQMOFU|-73m#&!sZ;Wp;w0{_~5Rft-Qe7`V&$@Z4d!)jwFghu!_I zbGr%WbvXk$133dZ133dZ133dZ133dZ1OI0Xi11G16PVLm^t`(I`?itq8~Srmm%AhN zZ|Ztqm%lJl|AwyL(&e*yfOMSOb@?g%{nSXkF3!Jl266^+266^+266^+266^+266^+ z266^+266`e3kEF5Fz!IRAJKUm&;Qf&|2N-Z7~cTaf%gG74jRV4ftP{b0-pws1An{A zFn$R90Qeg4H1H+h^T20;>%cW20z;nQ}KpR*A-VeM1 za$g7j1$-U24jcgv0tbNozzaxzM8E;ybtGbb415cC21tNq;0$mYphS&aE4|j$DidAK z9NxAPPcYj{V!-R+U165*u!xH!@?$9-@s3Mk+%eF8O<&amUs$fsqlO;~ z%eOhREzeFoOK{c93d1M}BNqkeE)J3iBUG3jaS}0%M~s3Rg-xS6H0w&4^n2Or@e1=@ z&nU#4dqKx+`0b!wD%NEO4zv2|`w(>&*rB+H?o}_;x@;6MMmk6ll{|`2pu4L_u5h6< zbr~d{!~6h@$j;MV(C4OVhQ2@&+OvC3kW%bn(moDlpKRd-TF|Q|CQ;#7kyBTfN>@Fz z(iC1vF^7s8ewc`dbv^04z@{=Yc%*E!6W?Yf)jON6tu{{9o2v6N8|n%&axtkF7K_OB zJ7rc7ss$x zeupas*$Eaq8@tY+$whOtadYu>3GJ8_x+W%@sYi{TLOX!b`VVniV4Bbs1|^u=3q9V$ zDp3v7o9*=C5u%pk)%h(ztcZ@Zn0NUFK2kRotSSa{d+R-<4OD;sHXd#nQD+U-nb zcN6yWC=s-+t$5qF&1JrIX6>A$t(1`xvZU!=gQFTNZne(9Y3#rNb?x)5jBRH(j&v08 zub4G;F~k(LBsT(;N-;b(EM5L4-=dpnzt=A?^|A|?>XhQlq^T=o5Yn@a7n7qa7Rk>I zI$CPAR{MLqD@153H%H1uLE<}bJ7LT1@gNa!#c~E_&9-?caF^hA67f2Z1QZLMseT&N&4|%La1Op@q_mv696d!$T}^>a z>#3+7VL{^xKxUvKIr&uGigJLUsPDN;UO1}@-1<&~8c@@bVsg(-l*3!zk7Q0YeTdOU%8Yi1z6TPO;kZ zMRvNeyofj!uYdDMc197P)S~Dqb&IU+dI(l+yc`}{{x*e%f}%Jo)&ZTAK#_wJP2{d) z5D`>Crw7D}gAu_T-S|jL zQpj`VA!!Q}$Z}`08mhx>7PP52GlY{_keXB@9lXNM^N8;J42rQ5F<;br70V{O7$mG` zZEJ<==sa>eT>+PM_{a?Y+{bGDH|{H}f%rx)F2(h2@Iwc-7;1SQTcdU{j(jnXHnH#q zo&Ohbj`eZIrStzOeXe{JXZ}9|PXI1Z2kr*`i8KGNfUf|L10CR_zzk3Zrhpqb-@gew z3w#+^0*(X6fC?}Tlz|s<=6@Wx3UmMmuz~x4dEf}}OPu#V13U`!fQNunz&_v(;CA38 zocDhL{2W*Vrh(t%jQ<266^+266^+25yakL539PX(S4DI#h*o=IAjHM;1{+OgfyEtwnx?spdHL zAWl(7Mv56Ie~H5fXENc3L#K&wGm|kznp3At$5Nk2Ocn|{ZJABXAbBa%pei&@Q@NC( zsgEi~nalcj9yj+xa(H?}FZTpgsfgi5eZs!@4XoLf~Ud6BOt9prr*{${X2 zVdA7VGOE4zP<$_Cl_zMLrITXn3L-spry^spIk{6DPg9zS>NFRX&ROQWDb<`71RIhA zib9<* zgEbg4xd(PIImJyY+GZUtRF2kXNYJ4`8XK9P9BkL@urq0mCoRPw-+dEeGKuia^9PFg zn=)g5-trP&qK#p;I3<&zamspGZNH%{q8}>Y=p~bI#busFoiqE>B&J6 z++cktkHJp#pDtuJV*k;_*gm9Q-vZJf}1j@hfHA9q^s&$`R$f@45Qfhou^-Y6RBMD?}j~*$d zy$#I-3sgwwIWC$q0x9_zr;@5fq7gk=(}rNuP^5rd0nB4$$|T>jHhAgMW$6)z=UrhQ d_e 0 { - hostConfig.DNS = eni.DomainNameServers - } - if len(eni.DomainNameSearchList) > 0 { - hostConfig.DNSSearch = eni.DomainNameSearchList - } + + hostConfig.DNS = eni.DomainNameServers + hostConfig.DNSSearch = eni.DomainNameSearchList return hostConfig } @@ -883,5 +880,8 @@ func (t *Task) String() string { for _, c := range t.Containers { res += fmt.Sprintf("%s (%s->%s),", c.Name, c.GetKnownStatus().String(), c.GetDesiredStatus().String()) } + if t.ENI != nil { + res += fmt.Sprintf(" ENI: [%s]", t.ENI.String()) + } return res + "]" } diff --git a/agent/statemanager/state_manager.go b/agent/statemanager/state_manager.go index 76afcbbb4b5..bdd41416850 100644 --- a/agent/statemanager/state_manager.go +++ b/agent/statemanager/state_manager.go @@ -50,7 +50,8 @@ const ( // d) Add 'ENIAttachments' struct // e) Deprecate 'SteadyStateDependencies' in favor of 'TransitionDependencySet' // 7) - // a) Add 'MetadataUpdated' field to 'api.Container' + // a) Add 'MetadataUpdated' field to 'api.Container' + // b) Add 'DomainNameServers' and 'DomainNameSearchList' in `api.ENI` ECSDataVersion = 7 // ecsDataFile specifies the filename in the ECS_DATADIR From 34baa53583810910c1f2c4fac32022da20c43d04 Mon Sep 17 00:00:00 2001 From: Aithal Date: Fri, 27 Oct 2017 14:32:41 -0700 Subject: [PATCH 53/58] fix race while accessing task's ENI object --- agent/api/task.go | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/agent/api/task.go b/agent/api/task.go index 7ab15fd30e6..594f8a4aec5 100644 --- a/agent/api/task.go +++ b/agent/api/task.go @@ -872,16 +872,18 @@ func (task *Task) GetTaskENI() *ENI { } // String returns a human readable string representation of this object -func (t *Task) String() string { +func (task *Task) String() string { res := fmt.Sprintf("%s:%s %s, TaskStatus: (%s->%s)", - t.Family, t.Version, t.Arn, - t.GetKnownStatus().String(), t.GetDesiredStatus().String()) + task.Family, task.Version, task.Arn, + task.GetKnownStatus().String(), task.GetDesiredStatus().String()) res += " Containers: [" - for _, c := range t.Containers { + for _, c := range task.Containers { res += fmt.Sprintf("%s (%s->%s),", c.Name, c.GetKnownStatus().String(), c.GetDesiredStatus().String()) } - if t.ENI != nil { - res += fmt.Sprintf(" ENI: [%s]", t.ENI.String()) + task.eniLock.Lock() + defer task.eniLock.Unlock() + if task.ENI != nil { + res += fmt.Sprintf(" ENI: [%s]", task.ENI.String()) } return res + "]" } From f16a04174c06dc3386c26fdce6eede92882b009d Mon Sep 17 00:00:00 2001 From: Aithal Date: Fri, 27 Oct 2017 15:06:05 -0700 Subject: [PATCH 54/58] register agent with "none" log driver capability Agent registers itself as being capable of placing containers with "none" logging driver on start, without the need for explicitly specifying this in the config --- agent/config/config_unix.go | 2 +- agent/config/config_unix_test.go | 3 ++- agent/config/config_windows.go | 2 +- agent/config/config_windows_test.go | 3 ++- agent/config/types.go | 2 +- agent/engine/dockerclient/logging_drivers.go | 2 ++ 6 files changed, 9 insertions(+), 5 deletions(-) diff --git a/agent/config/config_unix.go b/agent/config/config_unix.go index 5700b8279fa..746d279ab5e 100644 --- a/agent/config/config_unix.go +++ b/agent/config/config_unix.go @@ -35,7 +35,7 @@ func DefaultConfig() Config { DataDirOnHost: "/var/lib/ecs", DisableMetrics: false, ReservedMemory: 0, - AvailableLoggingDrivers: []dockerclient.LoggingDriver{dockerclient.JSONFileDriver}, + AvailableLoggingDrivers: []dockerclient.LoggingDriver{dockerclient.JSONFileDriver, dockerclient.NoneDriver}, TaskCleanupWaitDuration: DefaultTaskCleanupWaitDuration, DockerStopTimeout: DefaultDockerStopTimeout, CredentialsAuditLogFile: defaultCredentialsAuditLogFile, diff --git a/agent/config/config_unix_test.go b/agent/config/config_unix_test.go index d9446236f1a..54a8a14e168 100644 --- a/agent/config/config_unix_test.go +++ b/agent/config/config_unix_test.go @@ -61,7 +61,8 @@ func TestConfigDefault(t *testing.T) { assert.Equal(t, uint16(0), cfg.ReservedMemory, "Default reserved memory set incorrectly") assert.Equal(t, 30*time.Second, cfg.DockerStopTimeout, "Default docker stop container timeout set incorrectly") assert.False(t, cfg.PrivilegedDisabled, "Default PrivilegedDisabled set incorrectly") - assert.Equal(t, []dockerclient.LoggingDriver{dockerclient.JSONFileDriver}, cfg.AvailableLoggingDrivers, "Default logging drivers set incorrectly") + assert.Equal(t, []dockerclient.LoggingDriver{dockerclient.JSONFileDriver, dockerclient.NoneDriver}, + cfg.AvailableLoggingDrivers, "Default logging drivers set incorrectly") assert.Equal(t, 3*time.Hour, cfg.TaskCleanupWaitDuration, "Default task cleanup wait duration set incorrectly") assert.False(t, cfg.TaskENIEnabled, "TaskENIEnabled set incorrectly") assert.False(t, cfg.TaskIAMRoleEnabled, "TaskIAMRoleEnabled set incorrectly") diff --git a/agent/config/config_windows.go b/agent/config/config_windows.go index c64d5dd0a15..c0a5fce0334 100644 --- a/agent/config/config_windows.go +++ b/agent/config/config_windows.go @@ -67,7 +67,7 @@ func DefaultConfig() Config { // DisableMetrics is set to true on Windows as docker stats does not work DisableMetrics: true, ReservedMemory: 0, - AvailableLoggingDrivers: []dockerclient.LoggingDriver{dockerclient.JSONFileDriver}, + AvailableLoggingDrivers: []dockerclient.LoggingDriver{dockerclient.JSONFileDriver, dockerclient.NoneDriver}, TaskCleanupWaitDuration: DefaultTaskCleanupWaitDuration, DockerStopTimeout: DefaultDockerStopTimeout, CredentialsAuditLogFile: filepath.Join(ecsRoot, defaultCredentialsAuditLogFile), diff --git a/agent/config/config_windows_test.go b/agent/config/config_windows_test.go index f052faf965f..85292202126 100644 --- a/agent/config/config_windows_test.go +++ b/agent/config/config_windows_test.go @@ -54,7 +54,8 @@ func TestConfigDefault(t *testing.T) { assert.Equal(t, uint16(0), cfg.ReservedMemory, "Default reserved memory set incorrectly") assert.Equal(t, 30*time.Second, cfg.DockerStopTimeout, "Default docker stop container timeout set incorrectly") assert.False(t, cfg.PrivilegedDisabled, "Default PrivilegedDisabled set incorrectly") - assert.Equal(t, []dockerclient.LoggingDriver{dockerclient.JSONFileDriver}, cfg.AvailableLoggingDrivers, "Default logging drivers set incorrectly") + assert.Equal(t, []dockerclient.LoggingDriver{dockerclient.JSONFileDriver, dockerclient.NoneDriver}, + cfg.AvailableLoggingDrivers, "Default logging drivers set incorrectly") assert.Equal(t, 3*time.Hour, cfg.TaskCleanupWaitDuration, "Default task cleanup wait duration set incorrectly") assert.False(t, cfg.TaskIAMRoleEnabled, "TaskIAMRoleEnabled set incorrectly") assert.False(t, cfg.TaskIAMRoleEnabledForNetworkHost, "TaskIAMRoleEnabledForNetworkHost set incorrectly") diff --git a/agent/config/types.go b/agent/config/types.go index 05549c9c58f..b3076ba6cc9 100644 --- a/agent/config/types.go +++ b/agent/config/types.go @@ -91,7 +91,7 @@ type Config struct { DockerStopTimeout time.Duration // AvailableLoggingDrivers specifies the logging drivers available for use - // with Docker. If not set, it defaults to ["json-file"]. + // with Docker. If not set, it defaults to ["json-file","none"]. AvailableLoggingDrivers []dockerclient.LoggingDriver // PrivilegedDisabled specified whether the Agent is capable of launching diff --git a/agent/engine/dockerclient/logging_drivers.go b/agent/engine/dockerclient/logging_drivers.go index 484e7fc613b..9376d9c748f 100644 --- a/agent/engine/dockerclient/logging_drivers.go +++ b/agent/engine/dockerclient/logging_drivers.go @@ -25,6 +25,7 @@ const ( SplunklogsDriver LoggingDriver = "splunk" LogentriesDriver LoggingDriver = "logentries" SumoLogicDriver LoggingDriver = "sumologic" + NoneDriver LoggingDriver = "none" ) var LoggingDriverMinimumVersion = map[LoggingDriver]DockerVersion{ @@ -37,4 +38,5 @@ var LoggingDriverMinimumVersion = map[LoggingDriver]DockerVersion{ SplunklogsDriver: Version_1_22, LogentriesDriver: Version_1_25, SumoLogicDriver: Version_1_29, + NoneDriver: Version_1_18, } From 3e9ecba6dd5ab958a7c3db07ce99858d8f85d35b Mon Sep 17 00:00:00 2001 From: Aithal Date: Fri, 27 Oct 2017 15:15:45 -0700 Subject: [PATCH 55/58] changelog entry for none log driver support --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1dfd4acc01a..ab633c4997c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ * Feature - Support for provisioning Tasks with ENIs * Enhancement - Support `init` process in containers by adding support for Docker remote API client version 1.25 [#996](https://github.com/aws/amazon-ecs-agent/pull/996) +* Enhancement - Enable 'none' logging driver capability by default + [#1041](https://github.com/aws/amazon-ecs-agent/pull/1041) * Bug - Fixed a bug where tasks that fail to pull containers can cause the agent to fail to restore properly after a restart. [#1033](https://github.com/aws/amazon-ecs-agent/pull/1033) From 6911423cd4335bf14e623a35cf77509b077946c3 Mon Sep 17 00:00:00 2001 From: Aithal Date: Fri, 27 Oct 2017 15:20:54 -0700 Subject: [PATCH 56/58] change min docker version to for none log driver changed min docker version required to 1.19 --- agent/engine/dockerclient/logging_drivers.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/agent/engine/dockerclient/logging_drivers.go b/agent/engine/dockerclient/logging_drivers.go index 9376d9c748f..0aec379b03b 100644 --- a/agent/engine/dockerclient/logging_drivers.go +++ b/agent/engine/dockerclient/logging_drivers.go @@ -38,5 +38,5 @@ var LoggingDriverMinimumVersion = map[LoggingDriver]DockerVersion{ SplunklogsDriver: Version_1_22, LogentriesDriver: Version_1_25, SumoLogicDriver: Version_1_29, - NoneDriver: Version_1_18, + NoneDriver: Version_1_19, } From 0156888b0cc4998d066f12cbcb8cb9f7df8b9ca7 Mon Sep 17 00:00:00 2001 From: Aithal Date: Mon, 30 Oct 2017 09:08:00 -0700 Subject: [PATCH 57/58] readme changes for 'none' logging driver --- README.md | 2 +- agent/app/agent_capability.go | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 1ee0d31d5b7..78b3dee42f4 100644 --- a/README.md +++ b/README.md @@ -162,7 +162,7 @@ configure them as something other than the defaults. | `ECS_UPDATE_DOWNLOAD_DIR` | /cache | Where to place update tarballs within the container. | | | | `ECS_DISABLE_METRICS` | <true | false> | Whether to disable metrics gathering for tasks. | false | true | | `ECS_RESERVED_MEMORY` | 32 | Memory, in MB, to reserve for use by things other than containers managed by Amazon ECS. | 0 | 0 | -| `ECS_AVAILABLE_LOGGING_DRIVERS` | `["awslogs","fluentd","gelf","json-file","journald","logentries","splunk","syslog"]` | Which logging drivers are available on the container instance. | `["json-file"]` | `["json-file"]` | +| `ECS_AVAILABLE_LOGGING_DRIVERS` | `["awslogs","fluentd","gelf","json-file","journald","logentries","splunk","syslog"]` | Which logging drivers are available on the container instance. | `["json-file","none"]` | `["json-file","none"]` | | `ECS_DISABLE_PRIVILEGED` | `true` | Whether launching privileged containers is disabled on the container instance. | `false` | `false` | | `ECS_SELINUX_CAPABLE` | `true` | Whether SELinux is available on the container instance. | `false` | `false` | | `ECS_APPARMOR_CAPABLE` | `true` | Whether AppArmor is available on the container instance. | `false` | `false` | diff --git a/agent/app/agent_capability.go b/agent/app/agent_capability.go index 6a6c905f903..e27bf5f7012 100644 --- a/agent/app/agent_capability.go +++ b/agent/app/agent_capability.go @@ -45,6 +45,7 @@ const ( // com.amazonaws.ecs.capability.logging-driver.fluentd // com.amazonaws.ecs.capability.logging-driver.journald // com.amazonaws.ecs.capability.logging-driver.gelf +// com.amazonaws.ecs.capability.logging-driver.none // com.amazonaws.ecs.capability.selinux // com.amazonaws.ecs.capability.apparmor // com.amazonaws.ecs.capability.ecr-auth From d2dd240c29fd80707d4136e1d469c53a456d855d Mon Sep 17 00:00:00 2001 From: Justin Haynes Date: Tue, 17 Oct 2017 14:50:41 +0000 Subject: [PATCH 58/58] update agent to 1.15.0. --- CHANGELOG.md | 22 +++++++++++----------- VERSION | 2 +- agent/version/version.go | 2 +- misc/windows-deploy/user-data.ps1 | 2 +- 4 files changed, 14 insertions(+), 14 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ab633c4997c..d01e021cb4c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,17 +1,17 @@ # Changelog -## UNRELEASED -* Feature - Support for provisioning Tasks with ENIs -* Enhancement - Support `init` process in containers by adding support for Docker remote API client version 1.25 - [#996](https://github.com/aws/amazon-ecs-agent/pull/996) -* Enhancement - Enable 'none' logging driver capability by default - [#1041](https://github.com/aws/amazon-ecs-agent/pull/1041) -* Bug - Fixed a bug where tasks that fail to pull containers can cause the - agent to fail to restore properly after a restart. - [#1033](https://github.com/aws/amazon-ecs-agent/pull/1033) -* Bug - Fixed a bug where unsupported Docker API client versions could be registered +## 1.15.0 +* Feature - Support for provisioning tasks with ENIs. +* Feature - Support for `--init` Docker run flag. [#996](https://github.com/aws/amazon-ecs-agent/pull/996) +* Feature - Introduces container level metadata. [#981](https://github.com/aws/amazon-ecs-agent/pull/981) +* Enhancement - Enable 'none' logging driver capability by default. + [#1041](https://github.com/aws/amazon-ecs-agent/pull/1041) +* Bug - Fixed a bug where tasks that fail to pull containers can cause the agent + to fail to restore properly after a restart. [#1033](https://github.com/aws/amazon-ecs-agent/pull/1033) +* Bug - Fixed default logging level issue. [#1016](https://github.com/aws/amazon-ecs-agent/pull/1016) +* Bug - Fixed a bug where unsupported Docker API client versions could be registered. [#1014](https://github.com/aws/amazon-ecs-agent/pull/1014) -* Bug - Fixed a bug where non-essential container state changes were sometimes not submitted +* Bug - Fixed a bug where non-essential container state changes were sometimes not submitted. [#1026](https://github.com/aws/amazon-ecs-agent/pull/1026) ## 1.14.5 diff --git a/VERSION b/VERSION index 61e44cc77cf..d19d0890128 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.14.5 \ No newline at end of file +1.15.0 \ No newline at end of file diff --git a/agent/version/version.go b/agent/version/version.go index a4d2d718cde..fc1948fd852 100644 --- a/agent/version/version.go +++ b/agent/version/version.go @@ -22,7 +22,7 @@ package version // repository. Only the 'Version' const should change in checked-in source code // Version is the version of the Agent -const Version = "1.14.5" +const Version = "1.15.0" // GitDirty indicates the cleanliness of the git repo when this agent was built const GitDirty = true diff --git a/misc/windows-deploy/user-data.ps1 b/misc/windows-deploy/user-data.ps1 index e98fd7329e8..564871c5952 100644 --- a/misc/windows-deploy/user-data.ps1 +++ b/misc/windows-deploy/user-data.ps1 @@ -4,7 +4,7 @@ # Set agent env variables for the Machine context (durable) [Environment]::SetEnvironmentVariable("ECS_CLUSTER", "windows", "Machine") [Environment]::SetEnvironmentVariable("ECS_ENABLE_TASK_IAM_ROLE", "false", "Machine") -$agentVersion = 'v1.14.5' +$agentVersion = 'v1.15.0' $agentZipUri = "https://s3.amazonaws.com/amazon-ecs-agent/ecs-agent-windows-$agentVersion.zip" $agentZipMD5Uri = "$agentZipUri.md5"