// 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) }