// Gather starts stats collection
func (d *Docker) Gather(acc telegraf.Accumulator) error {
if d.client == nil {
var c *client.Client
var err error
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
if d.Endpoint == "ENV" {
c, err = client.NewEnvClient()
if err != nil {
return err
}
} else if d.Endpoint == "" {
c, err = client.NewClient("unix:///var/run/docker.sock", "", nil, defaultHeaders)
if err != nil {
return err
}
} else {
c, err = client.NewClient(d.Endpoint, "", nil, defaultHeaders)
if err != nil {
return err
}
}
d.client = c
}
// Get daemon info
err := d.gatherInfo(acc)
if err != nil {
fmt.Println(err.Error())
}
// List containers
opts := types.ContainerListOptions{}
ctx, cancel := context.WithTimeout(context.Background(), d.Timeout.Duration)
defer cancel()
containers, err := d.client.ContainerList(ctx, opts)
if err != nil {
return err
}
// Get container data
var wg sync.WaitGroup
wg.Add(len(containers))
for _, container := range containers {
go func(c types.Container) {
defer wg.Done()
err := d.gatherContainer(c, acc)
if err != nil {
log.Printf("Error gathering container %s stats: %s\n",
c.Names, err.Error())
}
}(container)
}
wg.Wait()
return nil
}
// Connect will initialize a connection to the Docker daemon running on the
// host, gather machine specs (memory, cpu, ...) and monitor state changes.
func (e *Engine) Connect(config *tls.Config) error {
host, _, err := net.SplitHostPort(e.Addr)
if err != nil {
return err
}
addr, err := net.ResolveIPAddr("ip4", host)
if err != nil {
return err
}
e.IP = addr.IP.String()
// create the HTTP Client and URL
httpClient, url, err := NewHTTPClientTimeout("tcp://"+e.Addr, config, time.Duration(requestTimeout), setTCPUserTimeout)
if err != nil {
return err
}
e.httpClient = httpClient
e.url = url
// Use HTTP Client created above to create a dockerclient client
c := dockerclient.NewDockerClientFromHTTP(url, httpClient, config)
// Use HTTP Client used by dockerclient to create engine-api client
apiClient, err := engineapi.NewClient("tcp://"+e.Addr, "", c.HTTPClient, nil)
if err != nil {
return err
}
return e.ConnectWithClient(c, apiClient)
}
// Get a *dockerapi.Client, either using the endpoint passed in, or using
// DOCKER_HOST, DOCKER_TLS_VERIFY, and DOCKER_CERT path per their spec
func getDockerClient(dockerEndpoint string) (*dockerapi.Client, error) {
if len(dockerEndpoint) > 0 {
glog.Infof("Connecting to docker on %s", dockerEndpoint)
return dockerapi.NewClient(dockerEndpoint, "", nil, nil)
}
return dockerapi.NewEnvClient()
}
func (provider *Docker) createClient() (client.APIClient, error) {
var httpClient *http.Client
httpHeaders := map[string]string{
"User-Agent": "Traefik " + version.Version,
}
if provider.TLS != nil {
config, err := provider.TLS.CreateTLSConfig()
if err != nil {
return nil, err
}
tr := &http.Transport{
TLSClientConfig: config,
}
proto, addr, _, err := client.ParseHost(provider.Endpoint)
if err != nil {
return nil, err
}
sockets.ConfigureTransport(tr, proto, addr)
httpClient = &http.Client{
Transport: tr,
}
}
var version string
if provider.SwarmMode {
version = SwarmAPIVersion
} else {
version = DockerAPIVersion
}
return client.NewClient(provider.Endpoint, version, httpClient, httpHeaders)
}
func main() {
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
cli, err := client.NewClient(dockerHost, "", nil, defaultHeaders)
if err != nil {
panic(err)
}
// get container info
c, err := cli.ContainerInspect(context.Background(), arg)
if err != nil {
logrus.Fatalf("inspecting container (%s) failed: %v", arg, err)
}
t := native.New()
spec, err := parse.Config(c, platform.OSType, platform.Architecture, t.Capabilities, idroot, idlen)
if err != nil {
logrus.Fatalf("Spec config conversion for %s failed: %v", arg, err)
}
// fill in hooks, if passed through command line
spec.Hooks = hooks
if err := writeConfig(spec); err != nil {
logrus.Fatal(err)
}
fmt.Printf("%s has been saved.\n", specConfig)
}
// NewEngineAPIClient creates a new Docker engine API client
func NewEngineAPIClient(config *api.DockerConfig) (*dockerapi.Client, error) {
var httpClient *http.Client
if config.UseTLS || config.TLSVerify {
tlscOptions := tlsconfig.Options{
InsecureSkipVerify: !config.TLSVerify,
}
if _, err := os.Stat(config.CAFile); !os.IsNotExist(err) {
tlscOptions.CAFile = config.CAFile
}
if _, err := os.Stat(config.CertFile); !os.IsNotExist(err) {
tlscOptions.CertFile = config.CertFile
}
if _, err := os.Stat(config.KeyFile); !os.IsNotExist(err) {
tlscOptions.KeyFile = config.KeyFile
}
tlsc, err := tlsconfig.Client(tlscOptions)
if err != nil {
return nil, err
}
httpClient = &http.Client{
Transport: &http.Transport{
TLSClientConfig: tlsc,
},
}
}
return dockerapi.NewClient(config.Endpoint, os.Getenv("DOCKER_API_VERSION"), httpClient, nil)
}
// Init Refcounts. Discover volume usage refcounts from Docker.
// This functions does not sync with mount/unmount handlers and should be called
// and completed BEFORE we start accepting Mount/unmount requests.
func (r refCountsMap) Init(d *vmdkDriver) {
c, err := client.NewClient(dockerUSocket, apiVersion, nil, defaultHeaders)
if err != nil {
log.Panicf("Failed to create client for Docker at %s.( %v)",
dockerUSocket, err)
}
log.Infof("Getting volume data from %s", dockerUSocket)
info, err := c.Info(context.Background())
if err != nil {
log.Infof("Can't connect to %s, skipping discovery", dockerUSocket)
// TODO: Issue #369
// Docker is not running, inform ESX to detach docker volumes, if any
// d.detachAllVolumes()
return
}
log.Debugf("Docker info: version=%s, root=%s, OS=%s",
info.ServerVersion, info.DockerRootDir, info.OperatingSystem)
// connects (and polls if needed) and then calls discovery
err = r.discoverAndSync(c, d)
if err != nil {
log.Errorf("Failed to discover mount refcounts(%v)", err)
return
}
log.Infof("Discovered %d volumes in use.", len(r))
for name, cnt := range r {
log.Infof("Volume name=%s count=%d mounted=%t device='%s'",
name, cnt.count, cnt.mounted, cnt.dev)
}
}
// NewDockerCli returns a DockerCli instance with IO output and error streams set by in, out and err.
// The key file, protocol (i.e. unix) and address are passed in as strings, along with the tls.Config. If the tls.Config
// is set the client scheme will be set to https.
// The client will be given a 32-second timeout (see https://github.com/docker/docker/pull/8035).
func NewDockerCli(in io.ReadCloser, out, err io.Writer, clientFlags *cli.ClientFlags) *DockerCli {
//创建cli对象
cli := &DockerCli{
in: in,
out: out,
err: err,
keyFile: clientFlags.Common.TrustKey,
}
//docker客户端模式的创建过程，如果需要安全认证，需要加载安全认证的证书。
cli.init = func() error {
clientFlags.PostParse()
configFile, e := cliconfig.Load(cliconfig.ConfigDir())
if e != nil {
fmt.Fprintf(cli.err, "WARNING: Error loading config file:%v\n", e)
}
if !configFile.ContainsAuth() {
credentials.DetectDefaultStore(configFile)
}
cli.configFile = configFile
host, err := getServerHost(clientFlags.Common.Hosts, clientFlags.Common.TLSOptions)
if err != nil {
return err
}
customHeaders := cli.configFile.HTTPHeaders
if customHeaders == nil {
customHeaders = map[string]string{}
}
customHeaders["User-Agent"] = clientUserAgent()
verStr := api.DefaultVersion.String()
if tmpStr := os.Getenv("DOCKER_API_VERSION"); tmpStr != "" {
verStr = tmpStr
}
httpClient, err := newHTTPClient(host, clientFlags.Common.TLSOptions)
if err != nil {
return err
}
client, err := client.NewClient(host, verStr, httpClient, customHeaders)
if err != nil {
return err
}
cli.client = client
if cli.in != nil {
cli.inFd, cli.isTerminalIn = term.GetFdInfo(cli.in)
}
if cli.out != nil {
cli.outFd, cli.isTerminalOut = term.GetFdInfo(cli.out)
}
return nil
}
return cli
}
func main() {
cli, err := client.NewClient("unix:///var/run/docker.sock", "v1.23", nil, nil)
if err != nil {
panic(err)
}
hostConfig := &container.HostConfig{
NetworkMode: "serverlessdockervotingapp_default",
Binds: []string{"/var/run/docker.sock:/var/run/docker.sock"},
}
http.Handle("/vote/", &dcgi.Handler{
Image: "bfirsh/serverless-vote",
Client: cli,
HostConfig: hostConfig,
Root: "/vote", // strip /vote from all URLs
})
http.Handle("/result/", &dcgi.Handler{
Image: "bfirsh/serverless-result",
Client: cli,
HostConfig: hostConfig,
Root: "/result",
})
http.ListenAndServe(":80", nil)
}
func (provider *Docker) createClient() (client.APIClient, error) {
var httpClient *http.Client
httpHeaders := map[string]string{
// FIXME(vdemeester) use version here O:)
"User-Agent": "Traefik",
}
if provider.TLS != nil {
tlsOptions := tlsconfig.Options{
CAFile: provider.TLS.CA,
CertFile: provider.TLS.Cert,
KeyFile: provider.TLS.Key,
InsecureSkipVerify: provider.TLS.InsecureSkipVerify,
}
config, err := tlsconfig.Client(tlsOptions)
if err != nil {
return nil, err
}
tr := &http.Transport{
TLSClientConfig: config,
}
proto, addr, _, err := client.ParseHost(provider.Endpoint)
if err != nil {
return nil, err
}
sockets.ConfigureTransport(tr, proto, addr)
httpClient = &http.Client{
Transport: tr,
}
}
return client.NewClient(provider.Endpoint, DockerAPIVersion, httpClient, httpHeaders)
}
func main() {
flags.Parse(os.Args)
if *images == "" {
log.Fatalf("Specify --images=foo:1.0,bar:2.0 etc")
}
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
cli, err := client.NewClient("unix:///var/run/docker.sock", "v1.21", nil, defaultHeaders)
if err != nil {
log.Fatal(err)
}
for _, image := range strings.Split(*images, ",") {
if len(strings.Split(image, ":")) != 2 {
log.Printf("Skipping untagged image %v", image)
continue
}
log.Printf("Pulling %v", image)
resp, err := cli.ImagePull(context.Background(), image, types.ImagePullOptions{})
if err != nil {
log.Fatalf("Failed to pull %v: %v", image, err)
}
var lines interface{}
for lineReader := bufio.NewReader(resp); err != io.EOF; {
err = json.NewDecoder(lineReader).Decode(&lines)
if m, ok := lines.(map[string]interface{}); ok {
log.Printf("%+v", m)
}
}
}
}
func newPlugin(dockerHost string) (*novolume, error) {
client, err := dockerclient.NewClient(dockerHost, dockerapi.DefaultVersion.String(), nil, nil)
if err != nil {
return nil, err
}
return &novolume{client: client}, nil
}
// NewDockerCli returns a DockerCli instance with IO output and error streams set by in, out and err.
// The key file, protocol (i.e. unix) and address are passed in as strings, along with the tls.Config. If the tls.Config
// is set the client scheme will be set to https.
// The client will be given a 32-second timeout (see https://github.com/docker/docker/pull/8035).
func NewDockerCli(in io.ReadCloser, out, err io.Writer, clientFlags *cli.ClientFlags) *DockerCli {
cli := &DockerCli{
in: in,
out: out,
err: err,
keyFile: clientFlags.Common.TrustKey,
}
cli.init = func() error {
clientFlags.PostParse()
configFile, e := cliconfig.Load(cliconfig.ConfigDir())
if e != nil {
fmt.Fprintf(cli.err, "WARNING: Error loading config file:%v\n", e)
}
cli.configFile = configFile
host, err := getServerHost(clientFlags.Common.Hosts, clientFlags.Common.TLSOptions)
if err != nil {
return err
}
customHeaders := cli.configFile.HTTPHeaders
if customHeaders == nil {
customHeaders = map[string]string{}
}
customHeaders["User-Agent"] = "Docker-Client/" + dockerversion.Version + " (" + runtime.GOOS + ")"
verStr := api.DefaultVersion.String()
if tmpStr := os.Getenv("DOCKER_API_VERSION"); tmpStr != "" {
verStr = tmpStr
}
clientTransport, err := newClientTransport(clientFlags.Common.TLSOptions)
if err != nil {
return err
}
client, err := client.NewClient(host, verStr, clientTransport, customHeaders)
if err != nil {
return err
}
cli.client = client
if cli.in != nil {
cli.inFd, cli.isTerminalIn = term.GetFdInfo(cli.in)
}
if cli.out != nil {
cli.outFd, cli.isTerminalOut = term.GetFdInfo(cli.out)
}
return nil
}
return cli
}
func buildTestImage(c *C) {
var endpoint string
if endpoint = os.Getenv("DOCKER_HOST"); endpoint == "" {
endpoint = client.DefaultDockerHost
}
const dockerFile = `
FROM alpine
COPY worker.sh /usr/bin/worker.sh
`
cl, err := client.NewClient(endpoint, "", nil, nil)
c.Assert(err, IsNil)
buf := new(bytes.Buffer)
tw := tar.NewWriter(buf)
files := []struct {
Name, Body string
Mode int64
}{
{"worker.sh", testsuite.ScriptWorkerSh, 0777},
{"Dockerfile", dockerFile, 0666},
}
for _, file := range files {
hdr := &tar.Header{
Name: file.Name,
Mode: file.Mode,
Size: int64(len(file.Body)),
}
c.Assert(tw.WriteHeader(hdr), IsNil)
_, err = tw.Write([]byte(file.Body))
c.Assert(err, IsNil)
}
c.Assert(tw.Close(), IsNil)
opts := types.ImageBuildOptions{
Tags: []string{"worker"},
}
resp, err := cl.ImageBuild(context.Background(), buf, opts)
c.Assert(err, IsNil)
defer resp.Body.Close()
io.Copy(ioutil.Discard, resp.Body)
err = cl.ImageTag(context.Background(), "worker", "localhost:5000/worker", types.ImageTagOptions{Force: true})
c.Assert(err, IsNil)
buildResp, err := cl.ImagePush(context.Background(), "localhost:5000/worker:latest", types.ImagePushOptions{RegistryAuth: "e30="})
c.Assert(err, IsNil)
defer buildResp.Close()
io.Copy(ioutil.Discard, buildResp)
}
func buildTestImage(c *C, endpoint string) {
const dockerFile = `
FROM ubuntu:trusty
COPY worker.sh /usr/bin/worker.sh
`
cl, err := client.NewClient(endpoint, "", nil, nil)
c.Assert(err, IsNil)
buf := new(bytes.Buffer)
tw := tar.NewWriter(buf)
files := []struct {
Name, Body string
Mode int64
}{
{"worker.sh", testsuite.ScriptWorkerSh, 0777},
{"Dockerfile", dockerFile, 0666},
}
for _, file := range files {
hdr := &tar.Header{
Name: file.Name,
Mode: file.Mode,
Size: int64(len(file.Body)),
}
c.Assert(tw.WriteHeader(hdr), IsNil)
_, err = tw.Write([]byte(file.Body))
c.Assert(err, IsNil)
}
c.Assert(tw.Close(), IsNil)
opts := types.ImageBuildOptions{
Tags: []string{"worker"},
}
resp, err := cl.ImageBuild(context.Background(), buf, opts)
c.Assert(err, IsNil)
defer resp.Body.Close()
for {
var p = make([]byte, 1024)
_, err := resp.Body.Read(p)
if err != nil {
c.Assert(err, Equals, io.EOF)
break
}
}
}
func init() {
var err error
dockerClient, err = client.NewClient("unix:///var/run/docker.sock", "", nil, nil)
if err != nil {
return
}
v, err := dockerClient.ServerVersion(context.Background())
if err != nil {
dockerClient = nil
return
}
dockerClient.UpdateClientVersion(v.APIVersion)
}
func NewDriver(scope string, vtepdev string) (*Driver, error) {
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
docker, err := dockerclient.NewClient("unix:///var/run/docker.sock", "v1.23", nil, defaultHeaders)
if err != nil {
log.Errorf("Error connecting to docker socket: %v", err)
return nil, err
}
d := &Driver{
scope: scope,
vtepdev: vtepdev,
networks: make(map[string]*NetworkState),
docker: docker,
}
return d, nil
}
func init() {
logger = log.NewLogger(log.NewConcurrentWriter(os.Stdout), "docker")
/*
log = logrus.New()
logger.Formatter = &logrus.TextFormatter{}
logger.Out = os.Stdout
logger.Level = logrus.DebugLevel
*/
defaultHeaders := map[string]string{"User-Agent": userAgent}
var err error
cli, err = client.NewClient(dockerDaemon, dockerVersion, nil, defaultHeaders)
if err != nil {
logger.Fatal("Failed to setup docker!", "err", err)
}
}
// TODO(random-liu): Add more validating items.
func (d *DockerValidator) Validate(spec SysSpec) error {
if spec.RuntimeSpec.DockerSpec == nil {
// If DockerSpec is not specified, assume current runtime is not
// docker, skip the docker configuration validation.
return nil
}
c, err := client.NewClient(dockerEndpoint, "", nil, nil)
if err != nil {
return fmt.Errorf("failed to create docker client: %v", err)
}
info, err := c.Info(context.Background())
if err != nil {
return fmt.Errorf("failed to get docker info: %v", err)
}
return d.validateDockerInfo(spec.RuntimeSpec.DockerSpec, info)
}
// NewBox ...
func NewBox(ctx context.Context, cfg isolate.BoxConfig) (isolate.Box, error) {
var config = &dockerBoxConfig{
DockerEndpoint: client.DefaultDockerHost,
SpawnConcurrency: defaultSpawnConcurrency,
}
decoderConfig := mapstructure.DecoderConfig{
WeaklyTypedInput: true,
Result: config,
TagName: "json",
}
decoder, err := mapstructure.NewDecoder(&decoderConfig)
if err != nil {
return nil, err
}
if err = decoder.Decode(cfg); err != nil {
return nil, err
}
client, err := client.NewClient(config.DockerEndpoint, config.APIVersion, nil, defaultHeaders)
if err != nil {
return nil, err
}
ctx, cancellation := context.WithCancel(ctx)
box := &Box{
ctx: ctx,
cancellation: cancellation,
client: client,
spawnSM: semaphore.New(config.SpawnConcurrency),
config: config,
containers: make(map[string]*process),
}
body, err := json.Marshal(config)
if err != nil {
return nil, err
}
dockerConfig.Set(string(body))
go box.watchEvents()
return box, nil
}
func (driver localPersistDriver) findExistingVolumesFromDockerDaemon() (error, map[string]string) {
// set up the ability to make API calls to the daemon
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
// need at least Docker 1.9 (API v1.21) for named Volume support
cli, err := client.NewClient("unix:///var/run/docker.sock", "v1.21", nil, defaultHeaders)
if err != nil {
return err, map[string]string{}
}
// grab ALL containers...
options := types.ContainerListOptions{All: true}
containers, err := cli.ContainerList(context.Background(), options)
// ...and check to see if any of them belong to this driver and recreate their references
var volumes = map[string]string{}
for _, container := range containers {
info, err := cli.ContainerInspect(context.Background(), container.ID)
if err != nil {
// something really weird happened here... PANIC
panic(err)
}
for _, mount := range info.Mounts {
if mount.Driver == driver.name {
// @TODO there could be multiple volumes (mounts) with this { name: source } combo, and while that's okay
// what if they is the same name with a different source? could that happen? if it could,
// it'd be bad, so maybe we want to panic here?
volumes[mount.Name] = mount.Source
}
}
}
if err != nil || len(volumes) == 0 {
fmt.Print("Attempting to load from file state... ")
return driver.findExistingVolumesFromStateFile()
}
return nil, volumes
}
func TestImagePullFromRegistry(t *testing.T) {
assert := assert.New(t)
var endpoint string
if endpoint = os.Getenv("DOCKER_HOST"); endpoint == "" {
endpoint = client.DefaultDockerHost
}
client, err := client.NewClient(endpoint, "", nil, defaultHeaders)
assert.NoError(err)
ctx := context.Background()
box := Box{
ctx: ctx,
client: client,
config: &dockerBoxConfig{},
}
var profile = isolate.Profile{
"registry": "docker.io",
}
t.Logf("Clean up docker.io/alpine:latest if it exists")
client.ImageRemove(ctx, "docker.io/alpine:latest", types.ImageRemoveOptions{Force: false, PruneChildren: false})
t.Logf("Spool via box on 'clean' system")
err = box.Spool(ctx, "alpine", profile)
assert.NoError(err)
imgs, err := client.ImageList(ctx, types.ImageListOptions{})
found := false
for _, img := range imgs {
if strings.Contains(img.RepoTags[0], "alpine") {
found = true
break
}
}
assert.NoError(err)
assert.True(found)
t.Logf("Spool an already spooled image")
err = box.Spool(ctx, "alpine", profile)
assert.NoError(err)
}
// New creates a new implementation of the STI Docker interface
func New(config *api.DockerConfig, auth api.AuthConfig) (Docker, error) {
var client *dockerapi.Client
var httpClient *http.Client
if config.CertFile != "" && config.KeyFile != "" && config.CAFile != "" {
tlscOptions := tlsconfig.Options{
CAFile: config.CAFile,
CertFile: config.CertFile,
KeyFile: config.KeyFile,
}
tlsc, tlsErr := tlsconfig.Client(tlscOptions)
if tlsErr != nil {
return nil, tlsErr
}
httpClient = &http.Client{
Transport: k8snet.SetTransportDefaults(&http.Transport{
TLSClientConfig: tlsc,
}),
}
}
client, err := dockerapi.NewClient(config.Endpoint, "", httpClient, nil)
if err != nil {
return nil, err
}
k8sDocker := dockertools.ConnectToDockerOrDie(config.Endpoint, 0)
return &stiDocker{
kubeDockerClient: k8sDocker,
client: client,
httpClient: httpClient,
dialer: &net.Dialer{},
pullAuth: dockertypes.AuthConfig{
Username: auth.Username,
Password: auth.Password,
Email: auth.Email,
ServerAddress: auth.ServerAddress,
},
endpoint: config.Endpoint,
}, nil
}
func newPlugin(dockerHost, configPath string) (*registryacl, error) {
client, err := dockerclient.NewClient(dockerHost, dockerapi.DefaultVersion.String(), nil, nil)
if err != nil {
return nil, err
}
if configPath == "" {
return nil, fmt.Errorf("Please specify a configuration file")
}
absConfig, err := filepath.Abs(configPath)
if err != nil {
return nil, err
}
b, err := ioutil.ReadFile(absConfig)
if err != nil {
return nil, err
}
var conf config
if _, err := toml.Decode(string(b), &conf); err != nil {
return nil, err
}
return ®istryacl{client: client, config: conf}, nil
}
// TestControllerFlowIntegration simply runs the Controller flow against a docker
// instance to make sure we don't blow up.
//
// This is great for ad-hoc testing while doing development. We can add more
// verification but it solves the problem of not being able to run tasks
// without a swarm setup.
//
// Run with something like this:
//
// go test -run TestControllerFlowIntegration -test.docker.addr unix:///var/run/docker.sock
//
func TestControllerFlowIntegration(t *testing.T) {
if dockerTestAddr == "" {
t.Skip("specify docker address to run integration")
}
ctx := context.Background()
client, err := engineapi.NewClient(dockerTestAddr, "", nil, nil)
assert.NoError(t, err)
assert.NotNil(t, client)
task := &api.Task{
ID: "dockerexec-integration-task-id",
ServiceID: "dockerexec-integration-service-id",
NodeID: "dockerexec-integration-node-id",
Spec: api.TaskSpec{
Runtime: &api.TaskSpec_Container{
Container: &api.ContainerSpec{
Command: []string{"sh", "-c", "sleep 5"},
Image: "alpine",
},
},
},
}
ctlr, err := newController(client, task)
assert.NoError(t, err)
assert.NotNil(t, ctlr)
assert.NoError(t, ctlr.Prepare(ctx))
assert.NoError(t, ctlr.Start(ctx))
assert.NoError(t, ctlr.Wait(ctx))
assert.NoError(t, ctlr.Shutdown(ctx))
assert.NoError(t, ctlr.Remove(ctx))
assert.NoError(t, ctlr.Close())
// NOTE(stevvooe): testify has no clue how to correctly do error equality.
if err := ctlr.Close(); err != exec.ErrControllerClosed {
t.Fatalf("expected controller to be closed: %v", err)
}
}
func main() {
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
cli, err := client.NewClient(dockerHost, "", nil, defaultHeaders)
if err != nil {
panic(err)
}
// get container info
c, err := cli.ContainerInspect(arg)
if err != nil {
logrus.Fatalf("inspecting container (%s) failed: %v", arg, err)
}
// get daemon info
info, err := cli.Info()
if err != nil {
logrus.Fatalf("getting daemon info failed: %v", err)
}
t := native.New()
spec, err := parse.Config(c, info, t.Capabilities)
if err != nil {
logrus.Fatalf("Spec config conversion for %s failed: %v", arg, err)
}
rspec, err := parse.RuntimeConfig(c)
if err != nil {
logrus.Fatalf("Spec runtime config conversion for %s failed: %v", arg, err)
}
// fill in hooks, if passed through command line
rspec.Hooks = hooks
if err := writeConfigs(spec, rspec); err != nil {
logrus.Fatal(err)
}
fmt.Printf("%s and %s have been saved.", specConfig, runtimeConfig)
}
// newDockerClient creates a new docker client from client options
func newDockerClient(co *clientutil.ClientOptions) (DockerClient, error) {
var httpClient *http.Client
tlsConfig := co.TLSConfig()
host := co.DaemonURL()
if tlsConfig != nil {
httpClient = &http.Client{
Transport: &http.Transport{
TLSClientConfig: tlsConfig,
},
}
}
apiClient, err := client.NewClient(host, os.Getenv("DOCKER_API_VERSION"), httpClient, nil)
if err != nil {
return DockerClient{}, err
}
return DockerClient{
Client: apiClient,
options: co,
}, nil
}
func main() {
runContainer()
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
cli, err := client.NewClient("unix:///var/run/docker.sock", "v1.21", nil, defaultHeaders)
if err != nil {
panic(err)
}
options := types.ContainerListOptions{All: true}
containers, err := cli.ContainerList(context.Background(), options)
if err != nil {
panic(err)
}
for _, c := range containers {
fmt.Println(c.ID)
fmt.Println(c.Names)
// fmt.Println(c)
}
}
func runContainer() {
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
cli, err := client.NewClient("unix:///var/run/docker.sock", "v1.21", nil, defaultHeaders)
if err != nil {
panic(err)
}
r, err := cli.ContainerCreate(context.Background(),
&container.Config{
Image: "ubuntu", Hostname: "",
User: "",
AttachStdin: true,
AttachStdout: true,
AttachStderr: true,
Tty: true,
Cmd: []string{"/bin/bash"},
OpenStdin: false,
StdinOnce: true,
WorkingDir: ""}, nil, nil, "")
if err != nil {
panic(err)
}
if r.ID != "container_id" {
fmt.Printf("expected `container_id`, got %s \n", r.ID)
fmt.Println(err)
fmt.Println(r)
fmt.Println()
fmt.Println()
}
err = cli.ContainerStart(context.Background(), r.ID)
if err != nil {
panic(err)
}
}
// NewAPIClientFromFlags creates a new APIClient from command line flags
func NewAPIClientFromFlags(clientFlags *cliflags.ClientFlags, configFile *configfile.ConfigFile) (client.APIClient, error) {
host, err := getServerHost(clientFlags.Common.Hosts, clientFlags.Common.TLSOptions)
if err != nil {
return &client.Client{}, err
}
customHeaders := configFile.HTTPHeaders
if customHeaders == nil {
customHeaders = map[string]string{}
}
customHeaders["User-Agent"] = clientUserAgent()
verStr := api.DefaultVersion
if tmpStr := os.Getenv("DOCKER_API_VERSION"); tmpStr != "" {
verStr = tmpStr
}
httpClient, err := newHTTPClient(host, clientFlags.Common.TLSOptions)
if err != nil {
return &client.Client{}, err
}
return client.NewClient(host, verStr, httpClient, customHeaders)
}