// NewDockerGoClient creates a new DockerGoClient
func NewDockerGoClient(clientFactory dockerclient.Factory, authType string, authData *config.SensitiveRawMessage, acceptInsecureCert bool) (DockerClient, error) {
endpoint := utils.DefaultIfBlank(os.Getenv(DOCKER_ENDPOINT_ENV_VARIABLE), DOCKER_DEFAULT_ENDPOINT)
if clientFactory == nil {
clientFactory = dockerclient.NewFactory(endpoint)
}
client, err := clientFactory.GetDefaultClient()
if err != nil {
log.Error("Unable to connect to docker daemon . Ensure docker is running", "endpoint", endpoint, "err", err)
return nil, err
}
// Even if we have a dockerclient, the daemon might not be running. Ping it
// to ensure it's up.
err = client.Ping()
if err != nil {
log.Error("Unable to ping docker daemon. Ensure docker is running", "endpoint", endpoint, "err", err)
return nil, err
}
return &dockerGoClient{
clientFactory: clientFactory,
auth: dockerauth.NewDockerAuthProvider(authType, authData.Contents()),
ecrClientFactory: ecr.NewECRFactory(acceptInsecureCert),
}, nil
}
func FileConfig() Config {
config_file := utils.DefaultIfBlank(os.Getenv("ECS_AGENT_CONFIG_FILE_PATH"), "/etc/ecs_container_agent/config.json")
file, err := os.Open(config_file)
if err != nil {
return Config{}
}
data, err := ioutil.ReadAll(file)
if err != nil {
log.Error("Unable to read config file", "err", err)
return Config{}
}
if strings.TrimSpace(string(data)) == "" {
// empty file, not an error
return Config{}
}
config := Config{}
err = json.Unmarshal(data, &config)
if err != nil {
log.Error("Error reading config json data", "err", err)
}
// Handle any deprecated keys correctly here
if utils.ZeroOrNil(config.Cluster) && !utils.ZeroOrNil(config.ClusterArn) {
config.Cluster = config.ClusterArn
}
return config
}
// getBindMounts actually constructs volume binds for container's host config
// It also additionally checks for envrionment variables:
// * CGROUP_PATH: the cgroup path
// * EXECDRIVER_PATH: the path of metrics
func (agent *TestAgent) getBindMounts() []string {
var binds []string
cgroupPath := utils.DefaultIfBlank(os.Getenv("CGROUP_PATH"), defaultCgroupPath)
cgroupBind := cgroupPath + ":" + cgroupPath + readOnly
binds = append(binds, cgroupBind)
execdriverPath := utils.DefaultIfBlank(os.Getenv("EXECDRIVER_PATH"), defaultExecDriverPath)
execdriverBind := execdriverPath + ":" + ExecDriverDir + readOnly
binds = append(binds, execdriverBind)
hostLogDir := filepath.Join(agent.TestDir, "log")
hostDataDir := filepath.Join(agent.TestDir, "data")
hostConfigDir := filepath.Join(agent.TestDir, "config")
hostCacheDir := filepath.Join(agent.TestDir, "cache")
agent.Logdir = hostLogDir
binds = append(binds, hostLogDir+":"+logdir)
binds = append(binds, hostDataDir+":"+datadir)
binds = append(binds, dockerEndpoint+":"+dockerEndpoint)
binds = append(binds, hostConfigDir+":"+configDirectory)
binds = append(binds, hostCacheDir+":"+cacheDirectory)
return binds
}
func NewDockerGoClient() (*DockerGoClient, error) {
endpoint := utils.DefaultIfBlank(os.Getenv(DOCKER_ENDPOINT_ENV_VARIABLE), DOCKER_DEFAULT_ENDPOINT)
client, err := docker.NewVersionedClient(endpoint, "1.17")
if err != nil {
log.Error("Unable to connect to docker daemon . Ensure docker is running", "endpoint", endpoint, "err", err)
return nil, err
}
// Even if we have a dockerclient, the daemon might not be running. Ping it
// to ensure it's up.
err = client.Ping()
if err != nil {
log.Error("Unable to ping docker daemon. Ensure docker is running", "endpoint", endpoint, "err", err)
return nil, err
}
return &DockerGoClient{
dockerClient: client,
}, nil
}
// NewDockerGoClient creates a new DockerGoClient
func NewDockerGoClient(clientFactory dockerclient.Factory) (*DockerGoClient, error) {
endpoint := utils.DefaultIfBlank(os.Getenv(DOCKER_ENDPOINT_ENV_VARIABLE), DOCKER_DEFAULT_ENDPOINT)
if clientFactory == nil {
clientFactory = dockerclient.NewFactory(endpoint)
}
client, err := clientFactory.GetDefaultClient()
if err != nil {
log.Error("Unable to connect to docker daemon . Ensure docker is running", "endpoint", endpoint, "err", err)
return nil, err
}
// Even if we have a dockerclient, the daemon might not be running. Ping it
// to ensure it's up.
err = client.Ping()
if err != nil {
log.Error("Unable to ping docker daemon. Ensure docker is running", "endpoint", endpoint, "err", err)
return nil, err
}
return &DockerGoClient{
clientFactory: clientFactory,
}, nil
}
testImageName = "amazon/amazon-ecs-gremlin:make"
// defaultDockerTimeoutSeconds is the timeout for dialing the docker remote API.
defaultDockerTimeoutSeconds uint = 10
// waitForCleanupSleep is the sleep duration in milliseconds
// for the waiting after container cleanup before checking the state of the manager.
waitForCleanupSleep = 10 * time.Millisecond
taskArn = "gremlin"
taskDefinitionFamily = "docker-gremlin"
taskDefinitionVersion = "1"
containerName = "gremlin-container"
)
var endpoint = utils.DefaultIfBlank(os.Getenv(engine.DOCKER_ENDPOINT_ENV_VARIABLE), engine.DOCKER_DEFAULT_ENDPOINT)
var client, _ = docker.NewClient(endpoint)
var cfg = config.DefaultConfig()
func init() {
// Set DockerGraphPath as per changes in 1.6
cfg.DockerGraphPath = "/var/run/docker"
}
// createGremlin creates the gremlin container using the docker client.
// It is used only in the test code.
func createGremlin(client *docker.Client) (*docker.Container, error) {
container, err := client.CreateContainer(docker.CreateContainerOptions{
Config: &docker.Config{
func (dg *DockerGoClient) pullImage(image string) DockerContainerMetadata {
log.Debug("Pulling image", "image", image)
client := dg.dockerClient
// Special case; this image is not one that should be pulled, but rather
// should be created locally if necessary
if image == emptyvolume.Image+":"+emptyvolume.Tag {
err := dg.createScratchImageIfNotExists()
if err != nil {
return DockerContainerMetadata{Error: &api.DefaultNamedError{Name: "CreateEmptyVolumeError", Err: "Could not create empty volume " + err.Error()}}
}
return DockerContainerMetadata{}
}
authConfig := dockerauth.GetAuthconfig(image)
// Workaround for devicemapper bug. See:
// https://github.com/docker/docker/issues/9718
pullLock.Lock()
defer pullLock.Unlock()
pullDebugOut, pullWriter := io.Pipe()
defer pullWriter.Close()
repository, tag := parsers.ParseRepositoryTag(image)
tag = utils.DefaultIfBlank(tag, dockerDefaultTag)
opts := docker.PullImageOptions{
Repository: repository + ":" + tag,
OutputStream: pullWriter,
}
timeout := ttime.After(dockerPullBeginTimeout)
// pullBegan is a channel indicating that we have seen at least one line of data on the 'OutputStream' above.
// It is here to guard against a bug wherin docker never writes anything to that channel and hangs in pulling forever.
pullBegan := make(chan bool, 1)
// pullBeganOnce ensures we only indicate it began once (since our channel will only be read 0 or 1 times)
pullBeganOnce := sync.Once{}
go func() {
reader := bufio.NewReader(pullDebugOut)
var line string
var err error
for err == nil {
line, err = reader.ReadString('\n')
if err != nil {
break
}
pullBeganOnce.Do(func() {
pullBegan <- true
})
log.Debug("Pulling image", "image", image, "status", line)
if strings.Contains(line, "already being pulled by another client. Waiting.") {
// This can mean the deamon is 'hung' in pulling status for this image, but we can't be sure.
log.Error("Image 'pull' status marked as already being pulled", "image", image, "status", line)
}
}
if err != nil && err != io.EOF {
log.Warn("Error reading pull image status", "image", image, "err", err)
}
}()
pullFinished := make(chan error, 1)
go func() {
pullFinished <- client.PullImage(opts, authConfig)
log.Debug("Pulling image complete", "image", image)
}()
select {
case <-pullBegan:
break
case err := <-pullFinished:
if err != nil {
return DockerContainerMetadata{Error: CannotXContainerError{"Pull", err.Error()}}
}
return DockerContainerMetadata{}
case <-timeout:
return DockerContainerMetadata{Error: &DockerTimeoutError{dockerPullBeginTimeout, "pullBegin"}}
}
log.Debug("Pull began for image", "image", image)
defer log.Debug("Pull completed for image", "image", image)
err := <-pullFinished
if err != nil {
return DockerContainerMetadata{Error: CannotXContainerError{"Pull", err.Error()}}
}
return DockerContainerMetadata{}
}
func removeImage(img string) {
endpoint := utils.DefaultIfBlank(os.Getenv(DOCKER_ENDPOINT_ENV_VARIABLE), DOCKER_DEFAULT_ENDPOINT)
client, _ := docker.NewClient(endpoint)
client.RemoveImage(img)
}
