Remove unused engine-api packages

Signed-off-by: Michael Crosby <crosbymichael@gmail.com>

vendor/src/github.com/docker/engine-api/client/checkpoint_create.go

@@ -1,13 +0,0 @@
-package client
-
-import (
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// CheckpointCreate creates a checkpoint from the given container with the given name
-func (cli *Client) CheckpointCreate(ctx context.Context, container string, options types.CheckpointCreateOptions) error {
-	resp, err := cli.post(ctx, "/containers/"+container+"/checkpoints", nil, options, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/checkpoint_delete.go

@@ -1,12 +0,0 @@
-package client
-
-import (
-	"golang.org/x/net/context"
-)
-
-// CheckpointDelete deletes the checkpoint with the given name from the given container
-func (cli *Client) CheckpointDelete(ctx context.Context, containerID string, checkpointID string) error {
-	resp, err := cli.delete(ctx, "/containers/"+containerID+"/checkpoints/"+checkpointID, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/checkpoint_list.go

@@ -1,22 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// CheckpointList returns the volumes configured in the docker host.
-func (cli *Client) CheckpointList(ctx context.Context, container string) ([]types.Checkpoint, error) {
-	var checkpoints []types.Checkpoint
-
-	resp, err := cli.get(ctx, "/containers/"+container+"/checkpoints", nil, nil)
-	if err != nil {
-		return checkpoints, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&checkpoints)
-	ensureReaderClosed(resp)
-	return checkpoints, err
-}

vendor/src/github.com/docker/engine-api/client/client.go

@@ -1,156 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/docker/engine-api/client/transport"
-	"github.com/docker/go-connections/tlsconfig"
-)
-
-// DefaultVersion is the version of the current stable API
-const DefaultVersion string = "1.23"
-
-// Client is the API client that performs all operations
-// against a docker server.
-type Client struct {
-	// host holds the server address to connect to
-	host string
-	// proto holds the client protocol i.e. unix.
-	proto string
-	// addr holds the client address.
-	addr string
-	// basePath holds the path to prepend to the requests.
-	basePath string
-	// transport is the interface to send request with, it implements transport.Client.
-	transport transport.Client
-	// version of the server to talk to.
-	version string
-	// custom http headers configured by users.
-	customHTTPHeaders map[string]string
-}
-
-// NewEnvClient initializes a new API client based on environment variables.
-// Use DOCKER_HOST to set the url to the docker server.
-// Use DOCKER_API_VERSION to set the version of the API to reach, leave empty for latest.
-// Use DOCKER_CERT_PATH to load the tls certificates from.
-// Use DOCKER_TLS_VERIFY to enable or disable TLS verification, off by default.
-func NewEnvClient() (*Client, error) {
-	var client *http.Client
-	if dockerCertPath := os.Getenv("DOCKER_CERT_PATH"); dockerCertPath != "" {
-		options := tlsconfig.Options{
-			CAFile:             filepath.Join(dockerCertPath, "ca.pem"),
-			CertFile:           filepath.Join(dockerCertPath, "cert.pem"),
-			KeyFile:            filepath.Join(dockerCertPath, "key.pem"),
-			InsecureSkipVerify: os.Getenv("DOCKER_TLS_VERIFY") == "",
-		}
-		tlsc, err := tlsconfig.Client(options)
-		if err != nil {
-			return nil, err
-		}
-
-		client = &http.Client{
-			Transport: &http.Transport{
-				TLSClientConfig: tlsc,
-			},
-		}
-	}
-
-	host := os.Getenv("DOCKER_HOST")
-	if host == "" {
-		host = DefaultDockerHost
-	}
-
-	version := os.Getenv("DOCKER_API_VERSION")
-	if version == "" {
-		version = DefaultVersion
-	}
-
-	return NewClient(host, version, client, nil)
-}
-
-// NewClient initializes a new API client for the given host and API version.
-// It uses the given http client as transport.
-// It also initializes the custom http headers to add to each request.
-//
-// It won't send any version information if the version number is empty. It is
-// highly recommended that you set a version or your client may break if the
-// server is upgraded.
-func NewClient(host string, version string, client *http.Client, httpHeaders map[string]string) (*Client, error) {
-	proto, addr, basePath, err := ParseHost(host)
-	if err != nil {
-		return nil, err
-	}
-
-	transport, err := transport.NewTransportWithHTTP(proto, addr, client)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Client{
-		host:              host,
-		proto:             proto,
-		addr:              addr,
-		basePath:          basePath,
-		transport:         transport,
-		version:           version,
-		customHTTPHeaders: httpHeaders,
-	}, nil
-}
-
-// getAPIPath returns the versioned request path to call the api.
-// It appends the query parameters to the path if they are not empty.
-func (cli *Client) getAPIPath(p string, query url.Values) string {
-	var apiPath string
-	if cli.version != "" {
-		v := strings.TrimPrefix(cli.version, "v")
-		apiPath = fmt.Sprintf("%s/v%s%s", cli.basePath, v, p)
-	} else {
-		apiPath = fmt.Sprintf("%s%s", cli.basePath, p)
-	}
-
-	u := &url.URL{
-		Path: apiPath,
-	}
-	if len(query) > 0 {
-		u.RawQuery = query.Encode()
-	}
-	return u.String()
-}
-
-// ClientVersion returns the version string associated with this
-// instance of the Client. Note that this value can be changed
-// via the DOCKER_API_VERSION env var.
-func (cli *Client) ClientVersion() string {
-	return cli.version
-}
-
-// UpdateClientVersion updates the version string associated with this
-// instance of the Client.
-func (cli *Client) UpdateClientVersion(v string) {
-	cli.version = v
-}
-
-// ParseHost verifies that the given host strings is valid.
-func ParseHost(host string) (string, string, string, error) {
-	protoAddrParts := strings.SplitN(host, "://", 2)
-	if len(protoAddrParts) == 1 {
-		return "", "", "", fmt.Errorf("unable to parse docker host `%s`", host)
-	}
-
-	var basePath string
-	proto, addr := protoAddrParts[0], protoAddrParts[1]
-	if proto == "tcp" {
-		parsed, err := url.Parse("tcp://" + addr)
-		if err != nil {
-			return "", "", "", err
-		}
-		addr = parsed.Host
-		basePath = parsed.Path
-	}
-	return proto, addr, basePath, nil
-}

vendor/src/github.com/docker/engine-api/client/client_unix.go

@@ -1,6 +0,0 @@
-// +build linux freebsd solaris openbsd darwin
-
-package client
-
-// DefaultDockerHost defines os specific default if DOCKER_HOST is unset
-const DefaultDockerHost = "unix:///var/run/docker.sock"

vendor/src/github.com/docker/engine-api/client/client_windows.go

@@ -1,4 +0,0 @@
-package client
-
-// DefaultDockerHost defines os specific default if DOCKER_HOST is unset
-const DefaultDockerHost = "npipe:////./pipe/docker_engine"

vendor/src/github.com/docker/engine-api/client/container_attach.go

@@ -1,34 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ContainerAttach attaches a connection to a container in the server.
-// It returns a types.HijackedConnection with the hijacked connection
-// and the a reader to get output. It's up to the called to close
-// the hijacked connection by calling types.HijackedResponse.Close.
-func (cli *Client) ContainerAttach(ctx context.Context, container string, options types.ContainerAttachOptions) (types.HijackedResponse, error) {
-	query := url.Values{}
-	if options.Stream {
-		query.Set("stream", "1")
-	}
-	if options.Stdin {
-		query.Set("stdin", "1")
-	}
-	if options.Stdout {
-		query.Set("stdout", "1")
-	}
-	if options.Stderr {
-		query.Set("stderr", "1")
-	}
-	if options.DetachKeys != "" {
-		query.Set("detachKeys", options.DetachKeys)
-	}
-
-	headers := map[string][]string{"Content-Type": {"text/plain"}}
-	return cli.postHijacked(ctx, "/containers/"+container+"/attach", query, nil, headers)
-}

vendor/src/github.com/docker/engine-api/client/container_commit.go

@@ -1,53 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"errors"
-	"net/url"
-
-	distreference "github.com/docker/distribution/reference"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/reference"
-	"golang.org/x/net/context"
-)
-
-// ContainerCommit applies changes into a container and creates a new tagged image.
-func (cli *Client) ContainerCommit(ctx context.Context, container string, options types.ContainerCommitOptions) (types.ContainerCommitResponse, error) {
-	var repository, tag string
-	if options.Reference != "" {
-		distributionRef, err := distreference.ParseNamed(options.Reference)
-		if err != nil {
-			return types.ContainerCommitResponse{}, err
-		}
-
-		if _, isCanonical := distributionRef.(distreference.Canonical); isCanonical {
-			return types.ContainerCommitResponse{}, errors.New("refusing to create a tag with a digest reference")
-		}
-
-		tag = reference.GetTagFromNamedRef(distributionRef)
-		repository = distributionRef.Name()
-	}
-
-	query := url.Values{}
-	query.Set("container", container)
-	query.Set("repo", repository)
-	query.Set("tag", tag)
-	query.Set("comment", options.Comment)
-	query.Set("author", options.Author)
-	for _, change := range options.Changes {
-		query.Add("changes", change)
-	}
-	if options.Pause != true {
-		query.Set("pause", "0")
-	}
-
-	var response types.ContainerCommitResponse
-	resp, err := cli.post(ctx, "/commit", query, options.Config, nil)
-	if err != nil {
-		return response, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&response)
-	ensureReaderClosed(resp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/container_copy.go

@@ -1,97 +0,0 @@
-package client
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"path/filepath"
-	"strings"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-)
-
-// ContainerStatPath returns Stat information about a path inside the container filesystem.
-func (cli *Client) ContainerStatPath(ctx context.Context, containerID, path string) (types.ContainerPathStat, error) {
-	query := url.Values{}
-	query.Set("path", filepath.ToSlash(path)) // Normalize the paths used in the API.
-
-	urlStr := fmt.Sprintf("/containers/%s/archive", containerID)
-	response, err := cli.head(ctx, urlStr, query, nil)
-	if err != nil {
-		return types.ContainerPathStat{}, err
-	}
-	defer ensureReaderClosed(response)
-	return getContainerPathStatFromHeader(response.header)
-}
-
-// CopyToContainer copies content into the container filesystem.
-func (cli *Client) CopyToContainer(ctx context.Context, container, path string, content io.Reader, options types.CopyToContainerOptions) error {
-	query := url.Values{}
-	query.Set("path", filepath.ToSlash(path)) // Normalize the paths used in the API.
-	// Do not allow for an existing directory to be overwritten by a non-directory and vice versa.
-	if !options.AllowOverwriteDirWithFile {
-		query.Set("noOverwriteDirNonDir", "true")
-	}
-
-	apiPath := fmt.Sprintf("/containers/%s/archive", container)
-
-	response, err := cli.putRaw(ctx, apiPath, query, content, nil)
-	if err != nil {
-		return err
-	}
-	defer ensureReaderClosed(response)
-
-	if response.statusCode != http.StatusOK {
-		return fmt.Errorf("unexpected status code from daemon: %d", response.statusCode)
-	}
-
-	return nil
-}
-
-// CopyFromContainer gets the content from the container and returns it as a Reader
-// to manipulate it in the host. It's up to the caller to close the reader.
-func (cli *Client) CopyFromContainer(ctx context.Context, container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-	query := make(url.Values, 1)
-	query.Set("path", filepath.ToSlash(srcPath)) // Normalize the paths used in the API.
-
-	apiPath := fmt.Sprintf("/containers/%s/archive", container)
-	response, err := cli.get(ctx, apiPath, query, nil)
-	if err != nil {
-		return nil, types.ContainerPathStat{}, err
-	}
-
-	if response.statusCode != http.StatusOK {
-		return nil, types.ContainerPathStat{}, fmt.Errorf("unexpected status code from daemon: %d", response.statusCode)
-	}
-
-	// In order to get the copy behavior right, we need to know information
-	// about both the source and the destination. The response headers include
-	// stat info about the source that we can use in deciding exactly how to
-	// copy it locally. Along with the stat info about the local destination,
-	// we have everything we need to handle the multiple possibilities there
-	// can be when copying a file/dir from one location to another file/dir.
-	stat, err := getContainerPathStatFromHeader(response.header)
-	if err != nil {
-		return nil, stat, fmt.Errorf("unable to get resource stat from response: %s", err)
-	}
-	return response.body, stat, err
-}
-
-func getContainerPathStatFromHeader(header http.Header) (types.ContainerPathStat, error) {
-	var stat types.ContainerPathStat
-
-	encodedStat := header.Get("X-Docker-Container-Path-Stat")
-	statDecoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(encodedStat))
-
-	err := json.NewDecoder(statDecoder).Decode(&stat)
-	if err != nil {
-		err = fmt.Errorf("unable to decode container path stat header: %s", err)
-	}
-
-	return stat, err
-}

vendor/src/github.com/docker/engine-api/client/container_create.go

@@ -1,46 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-	"strings"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/container"
-	"github.com/docker/engine-api/types/network"
-	"golang.org/x/net/context"
-)
-
-type configWrapper struct {
-	*container.Config
-	HostConfig       *container.HostConfig
-	NetworkingConfig *network.NetworkingConfig
-}
-
-// ContainerCreate creates a new container based in the given configuration.
-// It can be associated with a name, but it's not mandatory.
-func (cli *Client) ContainerCreate(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (types.ContainerCreateResponse, error) {
-	var response types.ContainerCreateResponse
-	query := url.Values{}
-	if containerName != "" {
-		query.Set("name", containerName)
-	}
-
-	body := configWrapper{
-		Config:           config,
-		HostConfig:       hostConfig,
-		NetworkingConfig: networkingConfig,
-	}
-
-	serverResp, err := cli.post(ctx, "/containers/create", query, body, nil)
-	if err != nil {
-		if serverResp.statusCode == 404 && strings.Contains(err.Error(), "No such image") {
-			return response, imageNotFoundError{config.Image}
-		}
-		return response, err
-	}
-
-	err = json.NewDecoder(serverResp.body).Decode(&response)
-	ensureReaderClosed(serverResp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/container_diff.go

@@ -1,23 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ContainerDiff shows differences in a container filesystem since it was started.
-func (cli *Client) ContainerDiff(ctx context.Context, containerID string) ([]types.ContainerChange, error) {
-	var changes []types.ContainerChange
-
-	serverResp, err := cli.get(ctx, "/containers/"+containerID+"/changes", url.Values{}, nil)
-	if err != nil {
-		return changes, err
-	}
-
-	err = json.NewDecoder(serverResp.body).Decode(&changes)
-	ensureReaderClosed(serverResp)
-	return changes, err
-}

vendor/src/github.com/docker/engine-api/client/container_exec.go

@@ -1,49 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ContainerExecCreate creates a new exec configuration to run an exec process.
-func (cli *Client) ContainerExecCreate(ctx context.Context, container string, config types.ExecConfig) (types.ContainerExecCreateResponse, error) {
-	var response types.ContainerExecCreateResponse
-	resp, err := cli.post(ctx, "/containers/"+container+"/exec", nil, config, nil)
-	if err != nil {
-		return response, err
-	}
-	err = json.NewDecoder(resp.body).Decode(&response)
-	ensureReaderClosed(resp)
-	return response, err
-}
-
-// ContainerExecStart starts an exec process already created in the docker host.
-func (cli *Client) ContainerExecStart(ctx context.Context, execID string, config types.ExecStartCheck) error {
-	resp, err := cli.post(ctx, "/exec/"+execID+"/start", nil, config, nil)
-	ensureReaderClosed(resp)
-	return err
-}
-
-// ContainerExecAttach attaches a connection to an exec process in the server.
-// It returns a types.HijackedConnection with the hijacked connection
-// and the a reader to get output. It's up to the called to close
-// the hijacked connection by calling types.HijackedResponse.Close.
-func (cli *Client) ContainerExecAttach(ctx context.Context, execID string, config types.ExecConfig) (types.HijackedResponse, error) {
-	headers := map[string][]string{"Content-Type": {"application/json"}}
-	return cli.postHijacked(ctx, "/exec/"+execID+"/start", nil, config, headers)
-}
-
-// ContainerExecInspect returns information about a specific exec process on the docker host.
-func (cli *Client) ContainerExecInspect(ctx context.Context, execID string) (types.ContainerExecInspect, error) {
-	var response types.ContainerExecInspect
-	resp, err := cli.get(ctx, "/exec/"+execID+"/json", nil, nil)
-	if err != nil {
-		return response, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&response)
-	ensureReaderClosed(resp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/container_export.go

@@ -1,20 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-
-	"golang.org/x/net/context"
-)
-
-// ContainerExport retrieves the raw contents of a container
-// and returns them as an io.ReadCloser. It's up to the caller
-// to close the stream.
-func (cli *Client) ContainerExport(ctx context.Context, containerID string) (io.ReadCloser, error) {
-	serverResp, err := cli.get(ctx, "/containers/"+containerID+"/export", url.Values{}, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return serverResp.body, nil
-}

vendor/src/github.com/docker/engine-api/client/container_inspect.go

@@ -1,54 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ContainerInspect returns the container information.
-func (cli *Client) ContainerInspect(ctx context.Context, containerID string) (types.ContainerJSON, error) {
-	serverResp, err := cli.get(ctx, "/containers/"+containerID+"/json", nil, nil)
-	if err != nil {
-		if serverResp.statusCode == http.StatusNotFound {
-			return types.ContainerJSON{}, containerNotFoundError{containerID}
-		}
-		return types.ContainerJSON{}, err
-	}
-
-	var response types.ContainerJSON
-	err = json.NewDecoder(serverResp.body).Decode(&response)
-	ensureReaderClosed(serverResp)
-	return response, err
-}
-
-// ContainerInspectWithRaw returns the container information and its raw representation.
-func (cli *Client) ContainerInspectWithRaw(ctx context.Context, containerID string, getSize bool) (types.ContainerJSON, []byte, error) {
-	query := url.Values{}
-	if getSize {
-		query.Set("size", "1")
-	}
-	serverResp, err := cli.get(ctx, "/containers/"+containerID+"/json", query, nil)
-	if err != nil {
-		if serverResp.statusCode == http.StatusNotFound {
-			return types.ContainerJSON{}, nil, containerNotFoundError{containerID}
-		}
-		return types.ContainerJSON{}, nil, err
-	}
-	defer ensureReaderClosed(serverResp)
-
-	body, err := ioutil.ReadAll(serverResp.body)
-	if err != nil {
-		return types.ContainerJSON{}, nil, err
-	}
-
-	var response types.ContainerJSON
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&response)
-	return response, body, err
-}

vendor/src/github.com/docker/engine-api/client/container_kill.go

@@ -1,17 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"golang.org/x/net/context"
-)
-
-// ContainerKill terminates the container process but does not remove the container from the docker host.
-func (cli *Client) ContainerKill(ctx context.Context, containerID, signal string) error {
-	query := url.Values{}
-	query.Set("signal", signal)
-
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/kill", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_list.go

@@ -1,56 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-	"strconv"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"golang.org/x/net/context"
-)
-
-// ContainerList returns the list of containers in the docker host.
-func (cli *Client) ContainerList(ctx context.Context, options types.ContainerListOptions) ([]types.Container, error) {
-	query := url.Values{}
-
-	if options.All {
-		query.Set("all", "1")
-	}
-
-	if options.Limit != -1 {
-		query.Set("limit", strconv.Itoa(options.Limit))
-	}
-
-	if options.Since != "" {
-		query.Set("since", options.Since)
-	}
-
-	if options.Before != "" {
-		query.Set("before", options.Before)
-	}
-
-	if options.Size {
-		query.Set("size", "1")
-	}
-
-	if options.Filter.Len() > 0 {
-		filterJSON, err := filters.ToParamWithVersion(cli.version, options.Filter)
-
-		if err != nil {
-			return nil, err
-		}
-
-		query.Set("filters", filterJSON)
-	}
-
-	resp, err := cli.get(ctx, "/containers/json", query, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	var containers []types.Container
-	err = json.NewDecoder(resp.body).Decode(&containers)
-	ensureReaderClosed(resp)
-	return containers, err
-}

vendor/src/github.com/docker/engine-api/client/container_logs.go

@@ -1,52 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-	"time"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-	timetypes "github.com/docker/engine-api/types/time"
-)
-
-// ContainerLogs returns the logs generated by a container in an io.ReadCloser.
-// It's up to the caller to close the stream.
-func (cli *Client) ContainerLogs(ctx context.Context, container string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
-	query := url.Values{}
-	if options.ShowStdout {
-		query.Set("stdout", "1")
-	}
-
-	if options.ShowStderr {
-		query.Set("stderr", "1")
-	}
-
-	if options.Since != "" {
-		ts, err := timetypes.GetTimestamp(options.Since, time.Now())
-		if err != nil {
-			return nil, err
-		}
-		query.Set("since", ts)
-	}
-
-	if options.Timestamps {
-		query.Set("timestamps", "1")
-	}
-
-	if options.Details {
-		query.Set("details", "1")
-	}
-
-	if options.Follow {
-		query.Set("follow", "1")
-	}
-	query.Set("tail", options.Tail)
-
-	resp, err := cli.get(ctx, "/containers/"+container+"/logs", query, nil)
-	if err != nil {
-		return nil, err
-	}
-	return resp.body, nil
-}

vendor/src/github.com/docker/engine-api/client/container_pause.go

@@ -1,10 +0,0 @@
-package client
-
-import "golang.org/x/net/context"
-
-// ContainerPause pauses the main process of a given container without terminating it.
-func (cli *Client) ContainerPause(ctx context.Context, containerID string) error {
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/pause", nil, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_remove.go

@@ -1,27 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ContainerRemove kills and removes a container from the docker host.
-func (cli *Client) ContainerRemove(ctx context.Context, containerID string, options types.ContainerRemoveOptions) error {
-	query := url.Values{}
-	if options.RemoveVolumes {
-		query.Set("v", "1")
-	}
-	if options.RemoveLinks {
-		query.Set("link", "1")
-	}
-
-	if options.Force {
-		query.Set("force", "1")
-	}
-
-	resp, err := cli.delete(ctx, "/containers/"+containerID, query, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_rename.go

@@ -1,16 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"golang.org/x/net/context"
-)
-
-// ContainerRename changes the name of a given container.
-func (cli *Client) ContainerRename(ctx context.Context, containerID, newContainerName string) error {
-	query := url.Values{}
-	query.Set("name", newContainerName)
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/rename", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_resize.go

@@ -1,29 +0,0 @@
-package client
-
-import (
-	"net/url"
-	"strconv"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ContainerResize changes the size of the tty for a container.
-func (cli *Client) ContainerResize(ctx context.Context, containerID string, options types.ResizeOptions) error {
-	return cli.resize(ctx, "/containers/"+containerID, options.Height, options.Width)
-}
-
-// ContainerExecResize changes the size of the tty for an exec process running inside a container.
-func (cli *Client) ContainerExecResize(ctx context.Context, execID string, options types.ResizeOptions) error {
-	return cli.resize(ctx, "/exec/"+execID, options.Height, options.Width)
-}
-
-func (cli *Client) resize(ctx context.Context, basePath string, height, width int) error {
-	query := url.Values{}
-	query.Set("h", strconv.Itoa(height))
-	query.Set("w", strconv.Itoa(width))
-
-	resp, err := cli.post(ctx, basePath+"/resize", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_restart.go

@@ -1,22 +0,0 @@
-package client
-
-import (
-	"net/url"
-	"time"
-
-	timetypes "github.com/docker/engine-api/types/time"
-	"golang.org/x/net/context"
-)
-
-// ContainerRestart stops and starts a container again.
-// It makes the daemon to wait for the container to be up again for
-// a specific amount of time, given the timeout.
-func (cli *Client) ContainerRestart(ctx context.Context, containerID string, timeout *time.Duration) error {
-	query := url.Values{}
-	if timeout != nil {
-		query.Set("t", timetypes.DurationToSecondsString(*timeout))
-	}
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/restart", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_start.go

@@ -1,21 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-)
-
-// ContainerStart sends a request to the docker daemon to start a container.
-func (cli *Client) ContainerStart(ctx context.Context, containerID string, options types.ContainerStartOptions) error {
-	query := url.Values{}
-	if len(options.CheckpointID) != 0 {
-		query.Set("checkpoint", options.CheckpointID)
-	}
-
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/start", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_stats.go

@@ -1,24 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-
-	"golang.org/x/net/context"
-)
-
-// ContainerStats returns near realtime stats for a given container.
-// It's up to the caller to close the io.ReadCloser returned.
-func (cli *Client) ContainerStats(ctx context.Context, containerID string, stream bool) (io.ReadCloser, error) {
-	query := url.Values{}
-	query.Set("stream", "0")
-	if stream {
-		query.Set("stream", "1")
-	}
-
-	resp, err := cli.get(ctx, "/containers/"+containerID+"/stats", query, nil)
-	if err != nil {
-		return nil, err
-	}
-	return resp.body, err
-}

vendor/src/github.com/docker/engine-api/client/container_stop.go

@@ -1,21 +0,0 @@
-package client
-
-import (
-	"net/url"
-	"time"
-
-	timetypes "github.com/docker/engine-api/types/time"
-	"golang.org/x/net/context"
-)
-
-// ContainerStop stops a container without terminating the process.
-// The process is blocked until the container stops or the timeout expires.
-func (cli *Client) ContainerStop(ctx context.Context, containerID string, timeout *time.Duration) error {
-	query := url.Values{}
-	if timeout != nil {
-		query.Set("t", timetypes.DurationToSecondsString(*timeout))
-	}
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/stop", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_top.go

@@ -1,28 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-	"strings"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ContainerTop shows process information from within a container.
-func (cli *Client) ContainerTop(ctx context.Context, containerID string, arguments []string) (types.ContainerProcessList, error) {
-	var response types.ContainerProcessList
-	query := url.Values{}
-	if len(arguments) > 0 {
-		query.Set("ps_args", strings.Join(arguments, " "))
-	}
-
-	resp, err := cli.get(ctx, "/containers/"+containerID+"/top", query, nil)
-	if err != nil {
-		return response, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&response)
-	ensureReaderClosed(resp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/container_unpause.go

@@ -1,10 +0,0 @@
-package client
-
-import "golang.org/x/net/context"
-
-// ContainerUnpause resumes the process execution within a container
-func (cli *Client) ContainerUnpause(ctx context.Context, containerID string) error {
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/unpause", nil, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/container_update.go

@@ -1,23 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/container"
-	"golang.org/x/net/context"
-)
-
-// ContainerUpdate updates resources of a container
-func (cli *Client) ContainerUpdate(ctx context.Context, containerID string, updateConfig container.UpdateConfig) (types.ContainerUpdateResponse, error) {
-	var response types.ContainerUpdateResponse
-	serverResp, err := cli.post(ctx, "/containers/"+containerID+"/update", nil, updateConfig, nil)
-	if err != nil {
-		return response, err
-	}
-
-	err = json.NewDecoder(serverResp.body).Decode(&response)
-
-	ensureReaderClosed(serverResp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/container_wait.go

@@ -1,26 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-)
-
-// ContainerWait pauses execution until a container exits.
-// It returns the API status code as response of its readiness.
-func (cli *Client) ContainerWait(ctx context.Context, containerID string) (int, error) {
-	resp, err := cli.post(ctx, "/containers/"+containerID+"/wait", nil, nil, nil)
-	if err != nil {
-		return -1, err
-	}
-	defer ensureReaderClosed(resp)
-
-	var res types.ContainerWaitResponse
-	if err := json.NewDecoder(resp.body).Decode(&res); err != nil {
-		return -1, err
-	}
-
-	return res.StatusCode, nil
-}

vendor/src/github.com/docker/engine-api/client/errors.go

@@ -1,208 +0,0 @@
-package client
-
-import (
-	"errors"
-	"fmt"
-)
-
-// ErrConnectionFailed is an error raised when the connection between the client and the server failed.
-var ErrConnectionFailed = errors.New("Cannot connect to the Docker daemon. Is the docker daemon running on this host?")
-
-// ErrorConnectionFailed returns an error with host in the error message when connection to docker daemon failed.
-func ErrorConnectionFailed(host string) error {
-	return fmt.Errorf("Cannot connect to the Docker daemon at %s. Is the docker daemon running?", host)
-}
-
-type notFound interface {
-	error
-	NotFound() bool // Is the error a NotFound error
-}
-
-// IsErrNotFound returns true if the error is caused with an
-// object (image, container, network, volume, …) is not found in the docker host.
-func IsErrNotFound(err error) bool {
-	te, ok := err.(notFound)
-	return ok && te.NotFound()
-}
-
-// imageNotFoundError implements an error returned when an image is not in the docker host.
-type imageNotFoundError struct {
-	imageID string
-}
-
-// NoFound indicates that this error type is of NotFound
-func (e imageNotFoundError) NotFound() bool {
-	return true
-}
-
-// Error returns a string representation of an imageNotFoundError
-func (e imageNotFoundError) Error() string {
-	return fmt.Sprintf("Error: No such image: %s", e.imageID)
-}
-
-// IsErrImageNotFound returns true if the error is caused
-// when an image is not found in the docker host.
-func IsErrImageNotFound(err error) bool {
-	return IsErrNotFound(err)
-}
-
-// containerNotFoundError implements an error returned when a container is not in the docker host.
-type containerNotFoundError struct {
-	containerID string
-}
-
-// NoFound indicates that this error type is of NotFound
-func (e containerNotFoundError) NotFound() bool {
-	return true
-}
-
-// Error returns a string representation of a containerNotFoundError
-func (e containerNotFoundError) Error() string {
-	return fmt.Sprintf("Error: No such container: %s", e.containerID)
-}
-
-// IsErrContainerNotFound returns true if the error is caused
-// when a container is not found in the docker host.
-func IsErrContainerNotFound(err error) bool {
-	return IsErrNotFound(err)
-}
-
-// networkNotFoundError implements an error returned when a network is not in the docker host.
-type networkNotFoundError struct {
-	networkID string
-}
-
-// NoFound indicates that this error type is of NotFound
-func (e networkNotFoundError) NotFound() bool {
-	return true
-}
-
-// Error returns a string representation of a networkNotFoundError
-func (e networkNotFoundError) Error() string {
-	return fmt.Sprintf("Error: No such network: %s", e.networkID)
-}
-
-// IsErrNetworkNotFound returns true if the error is caused
-// when a network is not found in the docker host.
-func IsErrNetworkNotFound(err error) bool {
-	return IsErrNotFound(err)
-}
-
-// volumeNotFoundError implements an error returned when a volume is not in the docker host.
-type volumeNotFoundError struct {
-	volumeID string
-}
-
-// NoFound indicates that this error type is of NotFound
-func (e volumeNotFoundError) NotFound() bool {
-	return true
-}
-
-// Error returns a string representation of a networkNotFoundError
-func (e volumeNotFoundError) Error() string {
-	return fmt.Sprintf("Error: No such volume: %s", e.volumeID)
-}
-
-// IsErrVolumeNotFound returns true if the error is caused
-// when a volume is not found in the docker host.
-func IsErrVolumeNotFound(err error) bool {
-	return IsErrNotFound(err)
-}
-
-// unauthorizedError represents an authorization error in a remote registry.
-type unauthorizedError struct {
-	cause error
-}
-
-// Error returns a string representation of an unauthorizedError
-func (u unauthorizedError) Error() string {
-	return u.cause.Error()
-}
-
-// IsErrUnauthorized returns true if the error is caused
-// when a remote registry authentication fails
-func IsErrUnauthorized(err error) bool {
-	_, ok := err.(unauthorizedError)
-	return ok
-}
-
-// nodeNotFoundError implements an error returned when a node is not found.
-type nodeNotFoundError struct {
-	nodeID string
-}
-
-// Error returns a string representation of a nodeNotFoundError
-func (e nodeNotFoundError) Error() string {
-	return fmt.Sprintf("Error: No such node: %s", e.nodeID)
-}
-
-// NoFound indicates that this error type is of NotFound
-func (e nodeNotFoundError) NotFound() bool {
-	return true
-}
-
-// IsErrNodeNotFound returns true if the error is caused
-// when a node is not found.
-func IsErrNodeNotFound(err error) bool {
-	_, ok := err.(nodeNotFoundError)
-	return ok
-}
-
-// serviceNotFoundError implements an error returned when a service is not found.
-type serviceNotFoundError struct {
-	serviceID string
-}
-
-// Error returns a string representation of a serviceNotFoundError
-func (e serviceNotFoundError) Error() string {
-	return fmt.Sprintf("Error: No such service: %s", e.serviceID)
-}
-
-// NoFound indicates that this error type is of NotFound
-func (e serviceNotFoundError) NotFound() bool {
-	return true
-}
-
-// IsErrServiceNotFound returns true if the error is caused
-// when a service is not found.
-func IsErrServiceNotFound(err error) bool {
-	_, ok := err.(serviceNotFoundError)
-	return ok
-}
-
-// taskNotFoundError implements an error returned when a task is not found.
-type taskNotFoundError struct {
-	taskID string
-}
-
-// Error returns a string representation of a taskNotFoundError
-func (e taskNotFoundError) Error() string {
-	return fmt.Sprintf("Error: No such task: %s", e.taskID)
-}
-
-// NoFound indicates that this error type is of NotFound
-func (e taskNotFoundError) NotFound() bool {
-	return true
-}
-
-// IsErrTaskNotFound returns true if the error is caused
-// when a task is not found.
-func IsErrTaskNotFound(err error) bool {
-	_, ok := err.(taskNotFoundError)
-	return ok
-}
-
-type pluginPermissionDenied struct {
-	name string
-}
-
-func (e pluginPermissionDenied) Error() string {
-	return "Permission denied while installing plugin " + e.name
-}
-
-// IsErrPluginPermissionDenied returns true if the error is caused
-// when a user denies a plugin's permissions
-func IsErrPluginPermissionDenied(err error) bool {
-	_, ok := err.(pluginPermissionDenied)
-	return ok
-}

vendor/src/github.com/docker/engine-api/client/events.go

@@ -1,48 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-	"time"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	timetypes "github.com/docker/engine-api/types/time"
-)
-
-// Events returns a stream of events in the daemon in a ReadCloser.
-// It's up to the caller to close the stream.
-func (cli *Client) Events(ctx context.Context, options types.EventsOptions) (io.ReadCloser, error) {
-	query := url.Values{}
-	ref := time.Now()
-
-	if options.Since != "" {
-		ts, err := timetypes.GetTimestamp(options.Since, ref)
-		if err != nil {
-			return nil, err
-		}
-		query.Set("since", ts)
-	}
-	if options.Until != "" {
-		ts, err := timetypes.GetTimestamp(options.Until, ref)
-		if err != nil {
-			return nil, err
-		}
-		query.Set("until", ts)
-	}
-	if options.Filters.Len() > 0 {
-		filterJSON, err := filters.ToParamWithVersion(cli.version, options.Filters)
-		if err != nil {
-			return nil, err
-		}
-		query.Set("filters", filterJSON)
-	}
-
-	serverResponse, err := cli.get(ctx, "/events", query, nil)
-	if err != nil {
-		return nil, err
-	}
-	return serverResponse.body, nil
-}

vendor/src/github.com/docker/engine-api/client/hijack.go

@@ -1,174 +0,0 @@
-package client
-
-import (
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net"
-	"net/http/httputil"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/go-connections/sockets"
-	"golang.org/x/net/context"
-)
-
-// tlsClientCon holds tls information and a dialed connection.
-type tlsClientCon struct {
-	*tls.Conn
-	rawConn net.Conn
-}
-
-func (c *tlsClientCon) CloseWrite() error {
-	// Go standard tls.Conn doesn't provide the CloseWrite() method so we do it
-	// on its underlying connection.
-	if conn, ok := c.rawConn.(types.CloseWriter); ok {
-		return conn.CloseWrite()
-	}
-	return nil
-}
-
-// postHijacked sends a POST request and hijacks the connection.
-func (cli *Client) postHijacked(ctx context.Context, path string, query url.Values, body interface{}, headers map[string][]string) (types.HijackedResponse, error) {
-	bodyEncoded, err := encodeData(body)
-	if err != nil {
-		return types.HijackedResponse{}, err
-	}
-
-	req, err := cli.newRequest("POST", path, query, bodyEncoded, headers)
-	if err != nil {
-		return types.HijackedResponse{}, err
-	}
-	req.Host = cli.addr
-
-	req.Header.Set("Connection", "Upgrade")
-	req.Header.Set("Upgrade", "tcp")
-
-	conn, err := dial(cli.proto, cli.addr, cli.transport.TLSConfig())
-	if err != nil {
-		if strings.Contains(err.Error(), "connection refused") {
-			return types.HijackedResponse{}, fmt.Errorf("Cannot connect to the Docker daemon. Is 'docker daemon' running on this host?")
-		}
-		return types.HijackedResponse{}, err
-	}
-
-	// When we set up a TCP connection for hijack, there could be long periods
-	// of inactivity (a long running command with no output) that in certain
-	// network setups may cause ECONNTIMEOUT, leaving the client in an unknown
-	// state. Setting TCP KeepAlive on the socket connection will prohibit
-	// ECONNTIMEOUT unless the socket connection truly is broken
-	if tcpConn, ok := conn.(*net.TCPConn); ok {
-		tcpConn.SetKeepAlive(true)
-		tcpConn.SetKeepAlivePeriod(30 * time.Second)
-	}
-
-	clientconn := httputil.NewClientConn(conn, nil)
-	defer clientconn.Close()
-
-	// Server hijacks the connection, error 'connection closed' expected
-	_, err = clientconn.Do(req)
-
-	rwc, br := clientconn.Hijack()
-
-	return types.HijackedResponse{Conn: rwc, Reader: br}, err
-}
-
-func tlsDial(network, addr string, config *tls.Config) (net.Conn, error) {
-	return tlsDialWithDialer(new(net.Dialer), network, addr, config)
-}
-
-// We need to copy Go's implementation of tls.Dial (pkg/cryptor/tls/tls.go) in
-// order to return our custom tlsClientCon struct which holds both the tls.Conn
-// object _and_ its underlying raw connection. The rationale for this is that
-// we need to be able to close the write end of the connection when attaching,
-// which tls.Conn does not provide.
-func tlsDialWithDialer(dialer *net.Dialer, network, addr string, config *tls.Config) (net.Conn, error) {
-	// We want the Timeout and Deadline values from dialer to cover the
-	// whole process: TCP connection and TLS handshake. This means that we
-	// also need to start our own timers now.
-	timeout := dialer.Timeout
-
-	if !dialer.Deadline.IsZero() {
-		deadlineTimeout := dialer.Deadline.Sub(time.Now())
-		if timeout == 0 || deadlineTimeout < timeout {
-			timeout = deadlineTimeout
-		}
-	}
-
-	var errChannel chan error
-
-	if timeout != 0 {
-		errChannel = make(chan error, 2)
-		time.AfterFunc(timeout, func() {
-			errChannel <- errors.New("")
-		})
-	}
-
-	proxyDialer, err := sockets.DialerFromEnvironment(dialer)
-	if err != nil {
-		return nil, err
-	}
-
-	rawConn, err := proxyDialer.Dial(network, addr)
-	if err != nil {
-		return nil, err
-	}
-	// When we set up a TCP connection for hijack, there could be long periods
-	// of inactivity (a long running command with no output) that in certain
-	// network setups may cause ECONNTIMEOUT, leaving the client in an unknown
-	// state. Setting TCP KeepAlive on the socket connection will prohibit
-	// ECONNTIMEOUT unless the socket connection truly is broken
-	if tcpConn, ok := rawConn.(*net.TCPConn); ok {
-		tcpConn.SetKeepAlive(true)
-		tcpConn.SetKeepAlivePeriod(30 * time.Second)
-	}
-
-	colonPos := strings.LastIndex(addr, ":")
-	if colonPos == -1 {
-		colonPos = len(addr)
-	}
-	hostname := addr[:colonPos]
-
-	// If no ServerName is set, infer the ServerName
-	// from the hostname we're connecting to.
-	if config.ServerName == "" {
-		// Make a copy to avoid polluting argument or default.
-		c := *config
-		c.ServerName = hostname
-		config = &c
-	}
-
-	conn := tls.Client(rawConn, config)
-
-	if timeout == 0 {
-		err = conn.Handshake()
-	} else {
-		go func() {
-			errChannel <- conn.Handshake()
-		}()
-
-		err = <-errChannel
-	}
-
-	if err != nil {
-		rawConn.Close()
-		return nil, err
-	}
-
-	// This is Docker difference with standard's crypto/tls package: returned a
-	// wrapper which holds both the TLS and raw connections.
-	return &tlsClientCon{conn, rawConn}, nil
-}
-
-func dial(proto, addr string, tlsConfig *tls.Config) (net.Conn, error) {
-	if tlsConfig != nil && proto != "unix" && proto != "npipe" {
-		// Notice this isn't Go standard's tls.Dial function
-		return tlsDial(proto, addr, tlsConfig)
-	}
-	if proto == "npipe" {
-		return sockets.DialPipe(addr, 32*time.Second)
-	}
-	return net.Dial(proto, addr)
-}

vendor/src/github.com/docker/engine-api/client/image_build.go

@@ -1,123 +0,0 @@
-package client
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"io"
-	"net/http"
-	"net/url"
-	"regexp"
-	"strconv"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/container"
-)
-
-var headerRegexp = regexp.MustCompile(`\ADocker/.+\s\((.+)\)\z`)
-
-// ImageBuild sends request to the daemon to build images.
-// The Body in the response implement an io.ReadCloser and it's up to the caller to
-// close it.
-func (cli *Client) ImageBuild(ctx context.Context, buildContext io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
-	query, err := imageBuildOptionsToQuery(options)
-	if err != nil {
-		return types.ImageBuildResponse{}, err
-	}
-
-	headers := http.Header(make(map[string][]string))
-	buf, err := json.Marshal(options.AuthConfigs)
-	if err != nil {
-		return types.ImageBuildResponse{}, err
-	}
-	headers.Add("X-Registry-Config", base64.URLEncoding.EncodeToString(buf))
-	headers.Set("Content-Type", "application/tar")
-
-	serverResp, err := cli.postRaw(ctx, "/build", query, buildContext, headers)
-	if err != nil {
-		return types.ImageBuildResponse{}, err
-	}
-
-	osType := getDockerOS(serverResp.header.Get("Server"))
-
-	return types.ImageBuildResponse{
-		Body:   serverResp.body,
-		OSType: osType,
-	}, nil
-}
-
-func imageBuildOptionsToQuery(options types.ImageBuildOptions) (url.Values, error) {
-	query := url.Values{
-		"t": options.Tags,
-	}
-	if options.SuppressOutput {
-		query.Set("q", "1")
-	}
-	if options.RemoteContext != "" {
-		query.Set("remote", options.RemoteContext)
-	}
-	if options.NoCache {
-		query.Set("nocache", "1")
-	}
-	if options.Remove {
-		query.Set("rm", "1")
-	} else {
-		query.Set("rm", "0")
-	}
-
-	if options.ForceRemove {
-		query.Set("forcerm", "1")
-	}
-
-	if options.PullParent {
-		query.Set("pull", "1")
-	}
-
-	if options.Squash {
-		query.Set("squash", "1")
-	}
-
-	if !container.Isolation.IsDefault(options.Isolation) {
-		query.Set("isolation", string(options.Isolation))
-	}
-
-	query.Set("cpusetcpus", options.CPUSetCPUs)
-	query.Set("cpusetmems", options.CPUSetMems)
-	query.Set("cpushares", strconv.FormatInt(options.CPUShares, 10))
-	query.Set("cpuquota", strconv.FormatInt(options.CPUQuota, 10))
-	query.Set("cpuperiod", strconv.FormatInt(options.CPUPeriod, 10))
-	query.Set("memory", strconv.FormatInt(options.Memory, 10))
-	query.Set("memswap", strconv.FormatInt(options.MemorySwap, 10))
-	query.Set("cgroupparent", options.CgroupParent)
-	query.Set("shmsize", strconv.FormatInt(options.ShmSize, 10))
-	query.Set("dockerfile", options.Dockerfile)
-
-	ulimitsJSON, err := json.Marshal(options.Ulimits)
-	if err != nil {
-		return query, err
-	}
-	query.Set("ulimits", string(ulimitsJSON))
-
-	buildArgsJSON, err := json.Marshal(options.BuildArgs)
-	if err != nil {
-		return query, err
-	}
-	query.Set("buildargs", string(buildArgsJSON))
-
-	labelsJSON, err := json.Marshal(options.Labels)
-	if err != nil {
-		return query, err
-	}
-	query.Set("labels", string(labelsJSON))
-	return query, nil
-}
-
-func getDockerOS(serverHeader string) string {
-	var osType string
-	matches := headerRegexp.FindStringSubmatch(serverHeader)
-	if len(matches) > 0 {
-		osType = matches[1]
-	}
-	return osType
-}

vendor/src/github.com/docker/engine-api/client/image_create.go

@@ -1,34 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/reference"
-)
-
-// ImageCreate creates a new image based in the parent options.
-// It returns the JSON content in the response body.
-func (cli *Client) ImageCreate(ctx context.Context, parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error) {
-	repository, tag, err := reference.Parse(parentReference)
-	if err != nil {
-		return nil, err
-	}
-
-	query := url.Values{}
-	query.Set("fromImage", repository)
-	query.Set("tag", tag)
-	resp, err := cli.tryImageCreate(ctx, query, options.RegistryAuth)
-	if err != nil {
-		return nil, err
-	}
-	return resp.body, nil
-}
-
-func (cli *Client) tryImageCreate(ctx context.Context, query url.Values, registryAuth string) (serverResponse, error) {
-	headers := map[string][]string{"X-Registry-Auth": {registryAuth}}
-	return cli.post(ctx, "/images/create", query, nil, headers)
-}

vendor/src/github.com/docker/engine-api/client/image_history.go

@@ -1,22 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ImageHistory returns the changes in an image in history format.
-func (cli *Client) ImageHistory(ctx context.Context, imageID string) ([]types.ImageHistory, error) {
-	var history []types.ImageHistory
-	serverResp, err := cli.get(ctx, "/images/"+imageID+"/history", url.Values{}, nil)
-	if err != nil {
-		return history, err
-	}
-
-	err = json.NewDecoder(serverResp.body).Decode(&history)
-	ensureReaderClosed(serverResp)
-	return history, err
-}

vendor/src/github.com/docker/engine-api/client/image_import.go

@@ -1,37 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/distribution/reference"
-	"github.com/docker/engine-api/types"
-)
-
-// ImageImport creates a new image based in the source options.
-// It returns the JSON content in the response body.
-func (cli *Client) ImageImport(ctx context.Context, source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error) {
-	if ref != "" {
-		//Check if the given image name can be resolved
-		if _, err := reference.ParseNamed(ref); err != nil {
-			return nil, err
-		}
-	}
-
-	query := url.Values{}
-	query.Set("fromSrc", source.SourceName)
-	query.Set("repo", ref)
-	query.Set("tag", options.Tag)
-	query.Set("message", options.Message)
-	for _, change := range options.Changes {
-		query.Add("changes", change)
-	}
-
-	resp, err := cli.postRaw(ctx, "/images/create", query, source.Source, nil)
-	if err != nil {
-		return nil, err
-	}
-	return resp.body, nil
-}

vendor/src/github.com/docker/engine-api/client/image_inspect.go

@@ -1,33 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ImageInspectWithRaw returns the image information and its raw representation.
-func (cli *Client) ImageInspectWithRaw(ctx context.Context, imageID string) (types.ImageInspect, []byte, error) {
-	serverResp, err := cli.get(ctx, "/images/"+imageID+"/json", nil, nil)
-	if err != nil {
-		if serverResp.statusCode == http.StatusNotFound {
-			return types.ImageInspect{}, nil, imageNotFoundError{imageID}
-		}
-		return types.ImageInspect{}, nil, err
-	}
-	defer ensureReaderClosed(serverResp)
-
-	body, err := ioutil.ReadAll(serverResp.body)
-	if err != nil {
-		return types.ImageInspect{}, nil, err
-	}
-
-	var response types.ImageInspect
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&response)
-	return response, body, err
-}

vendor/src/github.com/docker/engine-api/client/image_list.go

@@ -1,40 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"golang.org/x/net/context"
-)
-
-// ImageList returns a list of images in the docker host.
-func (cli *Client) ImageList(ctx context.Context, options types.ImageListOptions) ([]types.Image, error) {
-	var images []types.Image
-	query := url.Values{}
-
-	if options.Filters.Len() > 0 {
-		filterJSON, err := filters.ToParamWithVersion(cli.version, options.Filters)
-		if err != nil {
-			return images, err
-		}
-		query.Set("filters", filterJSON)
-	}
-	if options.MatchName != "" {
-		// FIXME rename this parameter, to not be confused with the filters flag
-		query.Set("filter", options.MatchName)
-	}
-	if options.All {
-		query.Set("all", "1")
-	}
-
-	serverResp, err := cli.get(ctx, "/images/json", query, nil)
-	if err != nil {
-		return images, err
-	}
-
-	err = json.NewDecoder(serverResp.body).Decode(&images)
-	ensureReaderClosed(serverResp)
-	return images, err
-}

vendor/src/github.com/docker/engine-api/client/image_load.go

@@ -1,30 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-)
-
-// ImageLoad loads an image in the docker host from the client host.
-// It's up to the caller to close the io.ReadCloser in the
-// ImageLoadResponse returned by this function.
-func (cli *Client) ImageLoad(ctx context.Context, input io.Reader, quiet bool) (types.ImageLoadResponse, error) {
-	v := url.Values{}
-	v.Set("quiet", "0")
-	if quiet {
-		v.Set("quiet", "1")
-	}
-	headers := map[string][]string{"Content-Type": {"application/x-tar"}}
-	resp, err := cli.postRaw(ctx, "/images/load", v, input, headers)
-	if err != nil {
-		return types.ImageLoadResponse{}, err
-	}
-	return types.ImageLoadResponse{
-		Body: resp.body,
-		JSON: resp.header.Get("Content-Type") == "application/json",
-	}, nil
-}

vendor/src/github.com/docker/engine-api/client/image_pull.go

@@ -1,46 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/http"
-	"net/url"
-
-	"golang.org/x/net/context"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/reference"
-)
-
-// ImagePull requests the docker host to pull an image from a remote registry.
-// It executes the privileged function if the operation is unauthorized
-// and it tries one more time.
-// It's up to the caller to handle the io.ReadCloser and close it properly.
-//
-// FIXME(vdemeester): there is currently used in a few way in docker/docker
-// - if not in trusted content, ref is used to pass the whole reference, and tag is empty
-// - if in trusted content, ref is used to pass the reference name, and tag for the digest
-func (cli *Client) ImagePull(ctx context.Context, ref string, options types.ImagePullOptions) (io.ReadCloser, error) {
-	repository, tag, err := reference.Parse(ref)
-	if err != nil {
-		return nil, err
-	}
-
-	query := url.Values{}
-	query.Set("fromImage", repository)
-	if tag != "" && !options.All {
-		query.Set("tag", tag)
-	}
-
-	resp, err := cli.tryImageCreate(ctx, query, options.RegistryAuth)
-	if resp.statusCode == http.StatusUnauthorized && options.PrivilegeFunc != nil {
-		newAuthHeader, privilegeErr := options.PrivilegeFunc()
-		if privilegeErr != nil {
-			return nil, privilegeErr
-		}
-		resp, err = cli.tryImageCreate(ctx, query, newAuthHeader)
-	}
-	if err != nil {
-		return nil, err
-	}
-	return resp.body, nil
-}

vendor/src/github.com/docker/engine-api/client/image_push.go

@@ -1,54 +0,0 @@
-package client
-
-import (
-	"errors"
-	"io"
-	"net/http"
-	"net/url"
-
-	"golang.org/x/net/context"
-
-	distreference "github.com/docker/distribution/reference"
-	"github.com/docker/engine-api/types"
-)
-
-// ImagePush requests the docker host to push an image to a remote registry.
-// It executes the privileged function if the operation is unauthorized
-// and it tries one more time.
-// It's up to the caller to handle the io.ReadCloser and close it properly.
-func (cli *Client) ImagePush(ctx context.Context, ref string, options types.ImagePushOptions) (io.ReadCloser, error) {
-	distributionRef, err := distreference.ParseNamed(ref)
-	if err != nil {
-		return nil, err
-	}
-
-	if _, isCanonical := distributionRef.(distreference.Canonical); isCanonical {
-		return nil, errors.New("cannot push a digest reference")
-	}
-
-	var tag = ""
-	if nameTaggedRef, isNamedTagged := distributionRef.(distreference.NamedTagged); isNamedTagged {
-		tag = nameTaggedRef.Tag()
-	}
-
-	query := url.Values{}
-	query.Set("tag", tag)
-
-	resp, err := cli.tryImagePush(ctx, distributionRef.Name(), query, options.RegistryAuth)
-	if resp.statusCode == http.StatusUnauthorized && options.PrivilegeFunc != nil {
-		newAuthHeader, privilegeErr := options.PrivilegeFunc()
-		if privilegeErr != nil {
-			return nil, privilegeErr
-		}
-		resp, err = cli.tryImagePush(ctx, distributionRef.Name(), query, newAuthHeader)
-	}
-	if err != nil {
-		return nil, err
-	}
-	return resp.body, nil
-}
-
-func (cli *Client) tryImagePush(ctx context.Context, imageID string, query url.Values, registryAuth string) (serverResponse, error) {
-	headers := map[string][]string{"X-Registry-Auth": {registryAuth}}
-	return cli.post(ctx, "/images/"+imageID+"/push", query, nil, headers)
-}

vendor/src/github.com/docker/engine-api/client/image_remove.go

@@ -1,31 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ImageRemove removes an image from the docker host.
-func (cli *Client) ImageRemove(ctx context.Context, imageID string, options types.ImageRemoveOptions) ([]types.ImageDelete, error) {
-	query := url.Values{}
-
-	if options.Force {
-		query.Set("force", "1")
-	}
-	if !options.PruneChildren {
-		query.Set("noprune", "1")
-	}
-
-	resp, err := cli.delete(ctx, "/images/"+imageID, query, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	var dels []types.ImageDelete
-	err = json.NewDecoder(resp.body).Decode(&dels)
-	ensureReaderClosed(resp)
-	return dels, err
-}

vendor/src/github.com/docker/engine-api/client/image_save.go

@@ -1,22 +0,0 @@
-package client
-
-import (
-	"io"
-	"net/url"
-
-	"golang.org/x/net/context"
-)
-
-// ImageSave retrieves one or more images from the docker host as an io.ReadCloser.
-// It's up to the caller to store the images and close the stream.
-func (cli *Client) ImageSave(ctx context.Context, imageIDs []string) (io.ReadCloser, error) {
-	query := url.Values{
-		"names": imageIDs,
-	}
-
-	resp, err := cli.get(ctx, "/images/get", query, nil)
-	if err != nil {
-		return nil, err
-	}
-	return resp.body, nil
-}

vendor/src/github.com/docker/engine-api/client/image_search.go

@@ -1,51 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/docker/engine-api/types/registry"
-	"golang.org/x/net/context"
-)
-
-// ImageSearch makes the docker host to search by a term in a remote registry.
-// The list of results is not sorted in any fashion.
-func (cli *Client) ImageSearch(ctx context.Context, term string, options types.ImageSearchOptions) ([]registry.SearchResult, error) {
-	var results []registry.SearchResult
-	query := url.Values{}
-	query.Set("term", term)
-	query.Set("limit", fmt.Sprintf("%d", options.Limit))
-
-	if options.Filters.Len() > 0 {
-		filterJSON, err := filters.ToParam(options.Filters)
-		if err != nil {
-			return results, err
-		}
-		query.Set("filters", filterJSON)
-	}
-
-	resp, err := cli.tryImageSearch(ctx, query, options.RegistryAuth)
-	if resp.statusCode == http.StatusUnauthorized && options.PrivilegeFunc != nil {
-		newAuthHeader, privilegeErr := options.PrivilegeFunc()
-		if privilegeErr != nil {
-			return results, privilegeErr
-		}
-		resp, err = cli.tryImageSearch(ctx, query, newAuthHeader)
-	}
-	if err != nil {
-		return results, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&results)
-	ensureReaderClosed(resp)
-	return results, err
-}
-
-func (cli *Client) tryImageSearch(ctx context.Context, query url.Values, registryAuth string) (serverResponse, error) {
-	headers := map[string][]string{"X-Registry-Auth": {registryAuth}}
-	return cli.get(ctx, "/images/search", query, headers)
-}

vendor/src/github.com/docker/engine-api/client/image_tag.go

@@ -1,34 +0,0 @@
-package client
-
-import (
-	"errors"
-	"fmt"
-	"net/url"
-
-	"golang.org/x/net/context"
-
-	distreference "github.com/docker/distribution/reference"
-	"github.com/docker/engine-api/types/reference"
-)
-
-// ImageTag tags an image in the docker host
-func (cli *Client) ImageTag(ctx context.Context, imageID, ref string) error {
-	distributionRef, err := distreference.ParseNamed(ref)
-	if err != nil {
-		return fmt.Errorf("Error parsing reference: %q is not a valid repository/tag", ref)
-	}
-
-	if _, isCanonical := distributionRef.(distreference.Canonical); isCanonical {
-		return errors.New("refusing to create a tag with a digest reference")
-	}
-
-	tag := reference.GetTagFromNamedRef(distributionRef)
-
-	query := url.Values{}
-	query.Set("repo", distributionRef.Name())
-	query.Set("tag", tag)
-
-	resp, err := cli.post(ctx, "/images/"+imageID+"/tag", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/info.go

@@ -1,26 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// Info returns information about the docker server.
-func (cli *Client) Info(ctx context.Context) (types.Info, error) {
-	var info types.Info
-	serverResp, err := cli.get(ctx, "/info", url.Values{}, nil)
-	if err != nil {
-		return info, err
-	}
-	defer ensureReaderClosed(serverResp)
-
-	if err := json.NewDecoder(serverResp.body).Decode(&info); err != nil {
-		return info, fmt.Errorf("Error reading remote info: %v", err)
-	}
-
-	return info, nil
-}

vendor/src/github.com/docker/engine-api/client/interface.go

@@ -1,135 +0,0 @@
-package client
-
-import (
-	"io"
-	"time"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/container"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/docker/engine-api/types/network"
-	"github.com/docker/engine-api/types/registry"
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// CommonAPIClient is the common methods between stable and experimental versions of APIClient.
-type CommonAPIClient interface {
-	ContainerAPIClient
-	ImageAPIClient
-	NodeAPIClient
-	NetworkAPIClient
-	ServiceAPIClient
-	SwarmAPIClient
-	SystemAPIClient
-	VolumeAPIClient
-	ClientVersion() string
-	ServerVersion(ctx context.Context) (types.Version, error)
-	UpdateClientVersion(v string)
-}
-
-// ContainerAPIClient defines API client methods for the containers
-type ContainerAPIClient interface {
-	ContainerAttach(ctx context.Context, container string, options types.ContainerAttachOptions) (types.HijackedResponse, error)
-	ContainerCommit(ctx context.Context, container string, options types.ContainerCommitOptions) (types.ContainerCommitResponse, error)
-	ContainerCreate(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (types.ContainerCreateResponse, error)
-	ContainerDiff(ctx context.Context, container string) ([]types.ContainerChange, error)
-	ContainerExecAttach(ctx context.Context, execID string, config types.ExecConfig) (types.HijackedResponse, error)
-	ContainerExecCreate(ctx context.Context, container string, config types.ExecConfig) (types.ContainerExecCreateResponse, error)
-	ContainerExecInspect(ctx context.Context, execID string) (types.ContainerExecInspect, error)
-	ContainerExecResize(ctx context.Context, execID string, options types.ResizeOptions) error
-	ContainerExecStart(ctx context.Context, execID string, config types.ExecStartCheck) error
-	ContainerExport(ctx context.Context, container string) (io.ReadCloser, error)
-	ContainerInspect(ctx context.Context, container string) (types.ContainerJSON, error)
-	ContainerInspectWithRaw(ctx context.Context, container string, getSize bool) (types.ContainerJSON, []byte, error)
-	ContainerKill(ctx context.Context, container, signal string) error
-	ContainerList(ctx context.Context, options types.ContainerListOptions) ([]types.Container, error)
-	ContainerLogs(ctx context.Context, container string, options types.ContainerLogsOptions) (io.ReadCloser, error)
-	ContainerPause(ctx context.Context, container string) error
-	ContainerRemove(ctx context.Context, container string, options types.ContainerRemoveOptions) error
-	ContainerRename(ctx context.Context, container, newContainerName string) error
-	ContainerResize(ctx context.Context, container string, options types.ResizeOptions) error
-	ContainerRestart(ctx context.Context, container string, timeout *time.Duration) error
-	ContainerStatPath(ctx context.Context, container, path string) (types.ContainerPathStat, error)
-	ContainerStats(ctx context.Context, container string, stream bool) (io.ReadCloser, error)
-	ContainerStart(ctx context.Context, container string, options types.ContainerStartOptions) error
-	ContainerStop(ctx context.Context, container string, timeout *time.Duration) error
-	ContainerTop(ctx context.Context, container string, arguments []string) (types.ContainerProcessList, error)
-	ContainerUnpause(ctx context.Context, container string) error
-	ContainerUpdate(ctx context.Context, container string, updateConfig container.UpdateConfig) (types.ContainerUpdateResponse, error)
-	ContainerWait(ctx context.Context, container string) (int, error)
-	CopyFromContainer(ctx context.Context, container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error)
-	CopyToContainer(ctx context.Context, container, path string, content io.Reader, options types.CopyToContainerOptions) error
-}
-
-// ImageAPIClient defines API client methods for the images
-type ImageAPIClient interface {
-	ImageBuild(ctx context.Context, context io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error)
-	ImageCreate(ctx context.Context, parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error)
-	ImageHistory(ctx context.Context, image string) ([]types.ImageHistory, error)
-	ImageImport(ctx context.Context, source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error)
-	ImageInspectWithRaw(ctx context.Context, image string) (types.ImageInspect, []byte, error)
-	ImageList(ctx context.Context, options types.ImageListOptions) ([]types.Image, error)
-	ImageLoad(ctx context.Context, input io.Reader, quiet bool) (types.ImageLoadResponse, error)
-	ImagePull(ctx context.Context, ref string, options types.ImagePullOptions) (io.ReadCloser, error)
-	ImagePush(ctx context.Context, ref string, options types.ImagePushOptions) (io.ReadCloser, error)
-	ImageRemove(ctx context.Context, image string, options types.ImageRemoveOptions) ([]types.ImageDelete, error)
-	ImageSearch(ctx context.Context, term string, options types.ImageSearchOptions) ([]registry.SearchResult, error)
-	ImageSave(ctx context.Context, images []string) (io.ReadCloser, error)
-	ImageTag(ctx context.Context, image, ref string) error
-}
-
-// NetworkAPIClient defines API client methods for the networks
-type NetworkAPIClient interface {
-	NetworkConnect(ctx context.Context, networkID, container string, config *network.EndpointSettings) error
-	NetworkCreate(ctx context.Context, name string, options types.NetworkCreate) (types.NetworkCreateResponse, error)
-	NetworkDisconnect(ctx context.Context, networkID, container string, force bool) error
-	NetworkInspect(ctx context.Context, networkID string) (types.NetworkResource, error)
-	NetworkInspectWithRaw(ctx context.Context, networkID string) (types.NetworkResource, []byte, error)
-	NetworkList(ctx context.Context, options types.NetworkListOptions) ([]types.NetworkResource, error)
-	NetworkRemove(ctx context.Context, networkID string) error
-}
-
-// NodeAPIClient defines API client methods for the nodes
-type NodeAPIClient interface {
-	NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error)
-	NodeList(ctx context.Context, options types.NodeListOptions) ([]swarm.Node, error)
-	NodeRemove(ctx context.Context, nodeID string, options types.NodeRemoveOptions) error
-	NodeUpdate(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error
-}
-
-// ServiceAPIClient defines API client methods for the services
-type ServiceAPIClient interface {
-	ServiceCreate(ctx context.Context, service swarm.ServiceSpec, options types.ServiceCreateOptions) (types.ServiceCreateResponse, error)
-	ServiceInspectWithRaw(ctx context.Context, serviceID string) (swarm.Service, []byte, error)
-	ServiceList(ctx context.Context, options types.ServiceListOptions) ([]swarm.Service, error)
-	ServiceRemove(ctx context.Context, serviceID string) error
-	ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options types.ServiceUpdateOptions) error
-	TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error)
-	TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error)
-}
-
-// SwarmAPIClient defines API client methods for the swarm
-type SwarmAPIClient interface {
-	SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error)
-	SwarmJoin(ctx context.Context, req swarm.JoinRequest) error
-	SwarmLeave(ctx context.Context, force bool) error
-	SwarmInspect(ctx context.Context) (swarm.Swarm, error)
-	SwarmUpdate(ctx context.Context, version swarm.Version, swarm swarm.Spec, flags swarm.UpdateFlags) error
-}
-
-// SystemAPIClient defines API client methods for the system
-type SystemAPIClient interface {
-	Events(ctx context.Context, options types.EventsOptions) (io.ReadCloser, error)
-	Info(ctx context.Context) (types.Info, error)
-	RegistryLogin(ctx context.Context, auth types.AuthConfig) (types.AuthResponse, error)
-}
-
-// VolumeAPIClient defines API client methods for the volumes
-type VolumeAPIClient interface {
-	VolumeCreate(ctx context.Context, options types.VolumeCreateRequest) (types.Volume, error)
-	VolumeInspect(ctx context.Context, volumeID string) (types.Volume, error)
-	VolumeInspectWithRaw(ctx context.Context, volumeID string) (types.Volume, []byte, error)
-	VolumeList(ctx context.Context, filter filters.Args) (types.VolumesListResponse, error)
-	VolumeRemove(ctx context.Context, volumeID string, force bool) error
-}

vendor/src/github.com/docker/engine-api/client/interface_experimental.go

@@ -1,37 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// APIClient is an interface that clients that talk with a docker server must implement.
-type APIClient interface {
-	CommonAPIClient
-	CheckpointAPIClient
-	PluginAPIClient
-}
-
-// CheckpointAPIClient defines API client methods for the checkpoints
-type CheckpointAPIClient interface {
-	CheckpointCreate(ctx context.Context, container string, options types.CheckpointCreateOptions) error
-	CheckpointDelete(ctx context.Context, container string, checkpointID string) error
-	CheckpointList(ctx context.Context, container string) ([]types.Checkpoint, error)
-}
-
-// PluginAPIClient defines API client methods for the plugins
-type PluginAPIClient interface {
-	PluginList(ctx context.Context) (types.PluginsListResponse, error)
-	PluginRemove(ctx context.Context, name string, options types.PluginRemoveOptions) error
-	PluginEnable(ctx context.Context, name string) error
-	PluginDisable(ctx context.Context, name string) error
-	PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) error
-	PluginPush(ctx context.Context, name string, registryAuth string) error
-	PluginSet(ctx context.Context, name string, args []string) error
-	PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error)
-}
-
-// Ensure that Client always implements APIClient.
-var _ APIClient = &Client{}

vendor/src/github.com/docker/engine-api/client/interface_stable.go

@@ -1,11 +0,0 @@
-// +build !experimental
-
-package client
-
-// APIClient is an interface that clients that talk with a docker server must implement.
-type APIClient interface {
-	CommonAPIClient
-}
-
-// Ensure that Client always implements APIClient.
-var _ APIClient = &Client{}

vendor/src/github.com/docker/engine-api/client/login.go

@@ -1,28 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// RegistryLogin authenticates the docker server with a given docker registry.
-// It returns UnauthorizerError when the authentication fails.
-func (cli *Client) RegistryLogin(ctx context.Context, auth types.AuthConfig) (types.AuthResponse, error) {
-	resp, err := cli.post(ctx, "/auth", url.Values{}, auth, nil)
-
-	if resp.statusCode == http.StatusUnauthorized {
-		return types.AuthResponse{}, unauthorizedError{err}
-	}
-	if err != nil {
-		return types.AuthResponse{}, err
-	}
-
-	var response types.AuthResponse
-	err = json.NewDecoder(resp.body).Decode(&response)
-	ensureReaderClosed(resp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/network_connect.go

@@ -1,18 +0,0 @@
-package client
-
-import (
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/network"
-	"golang.org/x/net/context"
-)
-
-// NetworkConnect connects a container to an existent network in the docker host.
-func (cli *Client) NetworkConnect(ctx context.Context, networkID, containerID string, config *network.EndpointSettings) error {
-	nc := types.NetworkConnect{
-		Container:      containerID,
-		EndpointConfig: config,
-	}
-	resp, err := cli.post(ctx, "/networks/"+networkID+"/connect", nil, nc, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/network_create.go

@@ -1,25 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// NetworkCreate creates a new network in the docker host.
-func (cli *Client) NetworkCreate(ctx context.Context, name string, options types.NetworkCreate) (types.NetworkCreateResponse, error) {
-	networkCreateRequest := types.NetworkCreateRequest{
-		NetworkCreate: options,
-		Name:          name,
-	}
-	var response types.NetworkCreateResponse
-	serverResp, err := cli.post(ctx, "/networks/create", nil, networkCreateRequest, nil)
-	if err != nil {
-		return response, err
-	}
-
-	json.NewDecoder(serverResp.body).Decode(&response)
-	ensureReaderClosed(serverResp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/network_disconnect.go

@@ -1,14 +0,0 @@
-package client
-
-import (
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// NetworkDisconnect disconnects a container from an existent network in the docker host.
-func (cli *Client) NetworkDisconnect(ctx context.Context, networkID, containerID string, force bool) error {
-	nd := types.NetworkDisconnect{Container: containerID, Force: force}
-	resp, err := cli.post(ctx, "/networks/"+networkID+"/disconnect", nil, nd, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/network_inspect.go

@@ -1,38 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// NetworkInspect returns the information for a specific network configured in the docker host.
-func (cli *Client) NetworkInspect(ctx context.Context, networkID string) (types.NetworkResource, error) {
-	networkResource, _, err := cli.NetworkInspectWithRaw(ctx, networkID)
-	return networkResource, err
-}
-
-// NetworkInspectWithRaw returns the information for a specific network configured in the docker host and its raw representation.
-func (cli *Client) NetworkInspectWithRaw(ctx context.Context, networkID string) (types.NetworkResource, []byte, error) {
-	var networkResource types.NetworkResource
-	resp, err := cli.get(ctx, "/networks/"+networkID, nil, nil)
-	if err != nil {
-		if resp.statusCode == http.StatusNotFound {
-			return networkResource, nil, networkNotFoundError{networkID}
-		}
-		return networkResource, nil, err
-	}
-	defer ensureReaderClosed(resp)
-
-	body, err := ioutil.ReadAll(resp.body)
-	if err != nil {
-		return networkResource, nil, err
-	}
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&networkResource)
-	return networkResource, body, err
-}

vendor/src/github.com/docker/engine-api/client/network_list.go

@@ -1,31 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"golang.org/x/net/context"
-)
-
-// NetworkList returns the list of networks configured in the docker host.
-func (cli *Client) NetworkList(ctx context.Context, options types.NetworkListOptions) ([]types.NetworkResource, error) {
-	query := url.Values{}
-	if options.Filters.Len() > 0 {
-		filterJSON, err := filters.ToParamWithVersion(cli.version, options.Filters)
-		if err != nil {
-			return nil, err
-		}
-
-		query.Set("filters", filterJSON)
-	}
-	var networkResources []types.NetworkResource
-	resp, err := cli.get(ctx, "/networks", query, nil)
-	if err != nil {
-		return networkResources, err
-	}
-	err = json.NewDecoder(resp.body).Decode(&networkResources)
-	ensureReaderClosed(resp)
-	return networkResources, err
-}

vendor/src/github.com/docker/engine-api/client/network_remove.go

@@ -1,10 +0,0 @@
-package client
-
-import "golang.org/x/net/context"
-
-// NetworkRemove removes an existent network from the docker host.
-func (cli *Client) NetworkRemove(ctx context.Context, networkID string) error {
-	resp, err := cli.delete(ctx, "/networks/"+networkID, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/node_inspect.go

@@ -1,33 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// NodeInspectWithRaw returns the node information.
-func (cli *Client) NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error) {
-	serverResp, err := cli.get(ctx, "/nodes/"+nodeID, nil, nil)
-	if err != nil {
-		if serverResp.statusCode == http.StatusNotFound {
-			return swarm.Node{}, nil, nodeNotFoundError{nodeID}
-		}
-		return swarm.Node{}, nil, err
-	}
-	defer ensureReaderClosed(serverResp)
-
-	body, err := ioutil.ReadAll(serverResp.body)
-	if err != nil {
-		return swarm.Node{}, nil, err
-	}
-
-	var response swarm.Node
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&response)
-	return response, body, err
-}

vendor/src/github.com/docker/engine-api/client/node_list.go

@@ -1,36 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// NodeList returns the list of nodes.
-func (cli *Client) NodeList(ctx context.Context, options types.NodeListOptions) ([]swarm.Node, error) {
-	query := url.Values{}
-
-	if options.Filter.Len() > 0 {
-		filterJSON, err := filters.ToParam(options.Filter)
-
-		if err != nil {
-			return nil, err
-		}
-
-		query.Set("filters", filterJSON)
-	}
-
-	resp, err := cli.get(ctx, "/nodes", query, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	var nodes []swarm.Node
-	err = json.NewDecoder(resp.body).Decode(&nodes)
-	ensureReaderClosed(resp)
-	return nodes, err
-}

vendor/src/github.com/docker/engine-api/client/node_remove.go

@@ -1,21 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-
-	"golang.org/x/net/context"
-)
-
-// NodeRemove removes a Node.
-func (cli *Client) NodeRemove(ctx context.Context, nodeID string, options types.NodeRemoveOptions) error {
-	query := url.Values{}
-	if options.Force {
-		query.Set("force", "1")
-	}
-
-	resp, err := cli.delete(ctx, "/nodes/"+nodeID, query, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/node_update.go

@@ -1,18 +0,0 @@
-package client
-
-import (
-	"net/url"
-	"strconv"
-
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// NodeUpdate updates a Node.
-func (cli *Client) NodeUpdate(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error {
-	query := url.Values{}
-	query.Set("version", strconv.FormatUint(version.Index, 10))
-	resp, err := cli.post(ctx, "/nodes/"+nodeID+"/update", query, node, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/plugin_disable.go

@@ -1,14 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"golang.org/x/net/context"
-)
-
-// PluginDisable disables a plugin
-func (cli *Client) PluginDisable(ctx context.Context, name string) error {
-	resp, err := cli.post(ctx, "/plugins/"+name+"/disable", nil, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/plugin_enable.go

@@ -1,14 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"golang.org/x/net/context"
-)
-
-// PluginEnable enables a plugin
-func (cli *Client) PluginEnable(ctx context.Context, name string) error {
-	resp, err := cli.post(ctx, "/plugins/"+name+"/enable", nil, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/plugin_inspect.go

@@ -1,30 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// PluginInspectWithRaw inspects an existing plugin
-func (cli *Client) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error) {
-	resp, err := cli.get(ctx, "/plugins/"+name, nil, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	defer ensureReaderClosed(resp)
-	body, err := ioutil.ReadAll(resp.body)
-	if err != nil {
-		return nil, nil, err
-	}
-	var p types.Plugin
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&p)
-	return &p, body, err
-}

vendor/src/github.com/docker/engine-api/client/plugin_install.go

@@ -1,59 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// PluginInstall installs a plugin
-func (cli *Client) PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) error {
-	// FIXME(vdemeester) name is a ref, we might want to parse/validate it here.
-	query := url.Values{}
-	query.Set("name", name)
-	resp, err := cli.tryPluginPull(ctx, query, options.RegistryAuth)
-	if resp.statusCode == http.StatusUnauthorized && options.PrivilegeFunc != nil {
-		newAuthHeader, privilegeErr := options.PrivilegeFunc()
-		if privilegeErr != nil {
-			ensureReaderClosed(resp)
-			return privilegeErr
-		}
-		resp, err = cli.tryPluginPull(ctx, query, newAuthHeader)
-	}
-	if err != nil {
-		ensureReaderClosed(resp)
-		return err
-	}
-	var privileges types.PluginPrivileges
-	if err := json.NewDecoder(resp.body).Decode(&privileges); err != nil {
-		ensureReaderClosed(resp)
-		return err
-	}
-	ensureReaderClosed(resp)
-
-	if !options.AcceptAllPermissions && options.AcceptPermissionsFunc != nil && len(privileges) > 0 {
-		accept, err := options.AcceptPermissionsFunc(privileges)
-		if err != nil {
-			return err
-		}
-		if !accept {
-			resp, _ := cli.delete(ctx, "/plugins/"+name, nil, nil)
-			ensureReaderClosed(resp)
-			return pluginPermissionDenied{name}
-		}
-	}
-	if options.Disabled {
-		return nil
-	}
-	return cli.PluginEnable(ctx, name)
-}
-
-func (cli *Client) tryPluginPull(ctx context.Context, query url.Values, registryAuth string) (serverResponse, error) {
-	headers := map[string][]string{"X-Registry-Auth": {registryAuth}}
-	return cli.post(ctx, "/plugins/pull", query, nil, headers)
-}

vendor/src/github.com/docker/engine-api/client/plugin_list.go

@@ -1,23 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// PluginList returns the installed plugins
-func (cli *Client) PluginList(ctx context.Context) (types.PluginsListResponse, error) {
-	var plugins types.PluginsListResponse
-	resp, err := cli.get(ctx, "/plugins", nil, nil)
-	if err != nil {
-		return plugins, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&plugins)
-	ensureReaderClosed(resp)
-	return plugins, err
-}

vendor/src/github.com/docker/engine-api/client/plugin_push.go

@@ -1,15 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"golang.org/x/net/context"
-)
-
-// PluginPush pushes a plugin to a registry
-func (cli *Client) PluginPush(ctx context.Context, name string, registryAuth string) error {
-	headers := map[string][]string{"X-Registry-Auth": {registryAuth}}
-	resp, err := cli.post(ctx, "/plugins/"+name+"/push", nil, nil, headers)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/plugin_remove.go

@@ -1,22 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// PluginRemove removes a plugin
-func (cli *Client) PluginRemove(ctx context.Context, name string, options types.PluginRemoveOptions) error {
-	query := url.Values{}
-	if options.Force {
-		query.Set("force", "1")
-	}
-
-	resp, err := cli.delete(ctx, "/plugins/"+name, query, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/plugin_set.go

@@ -1,14 +0,0 @@
-// +build experimental
-
-package client
-
-import (
-	"golang.org/x/net/context"
-)
-
-// PluginSet modifies settings for an existing plugin
-func (cli *Client) PluginSet(ctx context.Context, name string, args []string) error {
-	resp, err := cli.post(ctx, "/plugins/"+name+"/set", nil, args, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/request.go

@@ -1,208 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/docker/engine-api/client/transport/cancellable"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/versions"
-	"golang.org/x/net/context"
-)
-
-// serverResponse is a wrapper for http API responses.
-type serverResponse struct {
-	body       io.ReadCloser
-	header     http.Header
-	statusCode int
-}
-
-// head sends an http request to the docker API using the method HEAD.
-func (cli *Client) head(ctx context.Context, path string, query url.Values, headers map[string][]string) (serverResponse, error) {
-	return cli.sendRequest(ctx, "HEAD", path, query, nil, headers)
-}
-
-// getWithContext sends an http request to the docker API using the method GET with a specific go context.
-func (cli *Client) get(ctx context.Context, path string, query url.Values, headers map[string][]string) (serverResponse, error) {
-	return cli.sendRequest(ctx, "GET", path, query, nil, headers)
-}
-
-// postWithContext sends an http request to the docker API using the method POST with a specific go context.
-func (cli *Client) post(ctx context.Context, path string, query url.Values, obj interface{}, headers map[string][]string) (serverResponse, error) {
-	return cli.sendRequest(ctx, "POST", path, query, obj, headers)
-}
-
-func (cli *Client) postRaw(ctx context.Context, path string, query url.Values, body io.Reader, headers map[string][]string) (serverResponse, error) {
-	return cli.sendClientRequest(ctx, "POST", path, query, body, headers)
-}
-
-// put sends an http request to the docker API using the method PUT.
-func (cli *Client) put(ctx context.Context, path string, query url.Values, obj interface{}, headers map[string][]string) (serverResponse, error) {
-	return cli.sendRequest(ctx, "PUT", path, query, obj, headers)
-}
-
-// put sends an http request to the docker API using the method PUT.
-func (cli *Client) putRaw(ctx context.Context, path string, query url.Values, body io.Reader, headers map[string][]string) (serverResponse, error) {
-	return cli.sendClientRequest(ctx, "PUT", path, query, body, headers)
-}
-
-// delete sends an http request to the docker API using the method DELETE.
-func (cli *Client) delete(ctx context.Context, path string, query url.Values, headers map[string][]string) (serverResponse, error) {
-	return cli.sendRequest(ctx, "DELETE", path, query, nil, headers)
-}
-
-func (cli *Client) sendRequest(ctx context.Context, method, path string, query url.Values, obj interface{}, headers map[string][]string) (serverResponse, error) {
-	var body io.Reader
-
-	if obj != nil {
-		var err error
-		body, err = encodeData(obj)
-		if err != nil {
-			return serverResponse{}, err
-		}
-		if headers == nil {
-			headers = make(map[string][]string)
-		}
-		headers["Content-Type"] = []string{"application/json"}
-	}
-
-	return cli.sendClientRequest(ctx, method, path, query, body, headers)
-}
-
-func (cli *Client) sendClientRequest(ctx context.Context, method, path string, query url.Values, body io.Reader, headers map[string][]string) (serverResponse, error) {
-	serverResp := serverResponse{
-		body:       nil,
-		statusCode: -1,
-	}
-
-	expectedPayload := (method == "POST" || method == "PUT")
-	if expectedPayload && body == nil {
-		body = bytes.NewReader([]byte{})
-	}
-
-	req, err := cli.newRequest(method, path, query, body, headers)
-	if err != nil {
-		return serverResp, err
-	}
-
-	if cli.proto == "unix" || cli.proto == "npipe" {
-		// For local communications, it doesn't matter what the host is. We just
-		// need a valid and meaningful host name. (See #189)
-		req.Host = "docker"
-	}
-	req.URL.Host = cli.addr
-	req.URL.Scheme = cli.transport.Scheme()
-
-	if expectedPayload && req.Header.Get("Content-Type") == "" {
-		req.Header.Set("Content-Type", "text/plain")
-	}
-
-	resp, err := cancellable.Do(ctx, cli.transport, req)
-	if err != nil {
-		if !cli.transport.Secure() && strings.Contains(err.Error(), "malformed HTTP response") {
-			return serverResp, fmt.Errorf("%v.\n* Are you trying to connect to a TLS-enabled daemon without TLS?", err)
-		}
-
-		if cli.transport.Secure() && strings.Contains(err.Error(), "bad certificate") {
-			return serverResp, fmt.Errorf("The server probably has client authentication (--tlsverify) enabled. Please check your TLS client certification settings: %v", err)
-		}
-
-		// Don't decorate context sentinel errors; users may be comparing to
-		// them directly.
-		switch err {
-		case context.Canceled, context.DeadlineExceeded:
-			return serverResp, err
-		}
-
-		if err, ok := err.(net.Error); ok {
-			if err.Timeout() {
-				return serverResp, ErrorConnectionFailed(cli.host)
-			}
-			if !err.Temporary() {
-				if strings.Contains(err.Error(), "connection refused") || strings.Contains(err.Error(), "dial unix") {
-					return serverResp, ErrorConnectionFailed(cli.host)
-				}
-			}
-		}
-		return serverResp, fmt.Errorf("An error occurred trying to connect: %v", err)
-	}
-
-	if resp != nil {
-		serverResp.statusCode = resp.StatusCode
-	}
-
-	if serverResp.statusCode < 200 || serverResp.statusCode >= 400 {
-		body, err := ioutil.ReadAll(resp.Body)
-		if err != nil {
-			return serverResp, err
-		}
-		if len(body) == 0 {
-			return serverResp, fmt.Errorf("Error: request returned %s for API route and version %s, check if the server supports the requested API version", http.StatusText(serverResp.statusCode), req.URL)
-		}
-
-		var errorMessage string
-		if (cli.version == "" || versions.GreaterThan(cli.version, "1.23")) &&
-			resp.Header.Get("Content-Type") == "application/json" {
-			var errorResponse types.ErrorResponse
-			if err := json.Unmarshal(body, &errorResponse); err != nil {
-				return serverResp, fmt.Errorf("Error reading JSON: %v", err)
-			}
-			errorMessage = errorResponse.Message
-		} else {
-			errorMessage = string(body)
-		}
-
-		return serverResp, fmt.Errorf("Error response from daemon: %s", strings.TrimSpace(errorMessage))
-	}
-
-	serverResp.body = resp.Body
-	serverResp.header = resp.Header
-	return serverResp, nil
-}
-
-func (cli *Client) newRequest(method, path string, query url.Values, body io.Reader, headers map[string][]string) (*http.Request, error) {
-	apiPath := cli.getAPIPath(path, query)
-	req, err := http.NewRequest(method, apiPath, body)
-	if err != nil {
-		return nil, err
-	}
-
-	// Add CLI Config's HTTP Headers BEFORE we set the Docker headers
-	// then the user can't change OUR headers
-	for k, v := range cli.customHTTPHeaders {
-		req.Header.Set(k, v)
-	}
-
-	if headers != nil {
-		for k, v := range headers {
-			req.Header[k] = v
-		}
-	}
-
-	return req, nil
-}
-
-func encodeData(data interface{}) (*bytes.Buffer, error) {
-	params := bytes.NewBuffer(nil)
-	if data != nil {
-		if err := json.NewEncoder(params).Encode(data); err != nil {
-			return nil, err
-		}
-	}
-	return params, nil
-}
-
-func ensureReaderClosed(response serverResponse) {
-	if body := response.body; body != nil {
-		// Drain up to 512 bytes and close the body to let the Transport reuse the connection
-		io.CopyN(ioutil.Discard, body, 512)
-		response.body.Close()
-	}
-}

vendor/src/github.com/docker/engine-api/client/service_create.go

@@ -1,30 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// ServiceCreate creates a new Service.
-func (cli *Client) ServiceCreate(ctx context.Context, service swarm.ServiceSpec, options types.ServiceCreateOptions) (types.ServiceCreateResponse, error) {
-	var headers map[string][]string
-
-	if options.EncodedRegistryAuth != "" {
-		headers = map[string][]string{
-			"X-Registry-Auth": []string{options.EncodedRegistryAuth},
-		}
-	}
-
-	var response types.ServiceCreateResponse
-	resp, err := cli.post(ctx, "/services/create", nil, service, headers)
-	if err != nil {
-		return response, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&response)
-	ensureReaderClosed(resp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/service_inspect.go

@@ -1,33 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// ServiceInspectWithRaw returns the service information and the raw data.
-func (cli *Client) ServiceInspectWithRaw(ctx context.Context, serviceID string) (swarm.Service, []byte, error) {
-	serverResp, err := cli.get(ctx, "/services/"+serviceID, nil, nil)
-	if err != nil {
-		if serverResp.statusCode == http.StatusNotFound {
-			return swarm.Service{}, nil, serviceNotFoundError{serviceID}
-		}
-		return swarm.Service{}, nil, err
-	}
-	defer ensureReaderClosed(serverResp)
-
-	body, err := ioutil.ReadAll(serverResp.body)
-	if err != nil {
-		return swarm.Service{}, nil, err
-	}
-
-	var response swarm.Service
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&response)
-	return response, body, err
-}

vendor/src/github.com/docker/engine-api/client/service_list.go

@@ -1,35 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// ServiceList returns the list of services.
-func (cli *Client) ServiceList(ctx context.Context, options types.ServiceListOptions) ([]swarm.Service, error) {
-	query := url.Values{}
-
-	if options.Filter.Len() > 0 {
-		filterJSON, err := filters.ToParam(options.Filter)
-		if err != nil {
-			return nil, err
-		}
-
-		query.Set("filters", filterJSON)
-	}
-
-	resp, err := cli.get(ctx, "/services", query, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	var services []swarm.Service
-	err = json.NewDecoder(resp.body).Decode(&services)
-	ensureReaderClosed(resp)
-	return services, err
-}

vendor/src/github.com/docker/engine-api/client/service_remove.go

@@ -1,10 +0,0 @@
-package client
-
-import "golang.org/x/net/context"
-
-// ServiceRemove kills and removes a service.
-func (cli *Client) ServiceRemove(ctx context.Context, serviceID string) error {
-	resp, err := cli.delete(ctx, "/services/"+serviceID, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/service_update.go

@@ -1,30 +0,0 @@
-package client
-
-import (
-	"net/url"
-	"strconv"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// ServiceUpdate updates a Service.
-func (cli *Client) ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options types.ServiceUpdateOptions) error {
-	var (
-		headers map[string][]string
-		query   = url.Values{}
-	)
-
-	if options.EncodedRegistryAuth != "" {
-		headers = map[string][]string{
-			"X-Registry-Auth": []string{options.EncodedRegistryAuth},
-		}
-	}
-
-	query.Set("version", strconv.FormatUint(version.Index, 10))
-
-	resp, err := cli.post(ctx, "/services/"+serviceID+"/update", query, service, headers)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/swarm_init.go

@@ -1,21 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// SwarmInit initializes the Swarm.
-func (cli *Client) SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error) {
-	serverResp, err := cli.post(ctx, "/swarm/init", nil, req, nil)
-	if err != nil {
-		return "", err
-	}
-
-	var response string
-	err = json.NewDecoder(serverResp.body).Decode(&response)
-	ensureReaderClosed(serverResp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/swarm_inspect.go

@@ -1,21 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// SwarmInspect inspects the Swarm.
-func (cli *Client) SwarmInspect(ctx context.Context) (swarm.Swarm, error) {
-	serverResp, err := cli.get(ctx, "/swarm", nil, nil)
-	if err != nil {
-		return swarm.Swarm{}, err
-	}
-
-	var response swarm.Swarm
-	err = json.NewDecoder(serverResp.body).Decode(&response)
-	ensureReaderClosed(serverResp)
-	return response, err
-}

vendor/src/github.com/docker/engine-api/client/swarm_join.go

@@ -1,13 +0,0 @@
-package client
-
-import (
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// SwarmJoin joins the Swarm.
-func (cli *Client) SwarmJoin(ctx context.Context, req swarm.JoinRequest) error {
-	resp, err := cli.post(ctx, "/swarm/join", nil, req, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/swarm_leave.go

@@ -1,18 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"golang.org/x/net/context"
-)
-
-// SwarmLeave leaves the Swarm.
-func (cli *Client) SwarmLeave(ctx context.Context, force bool) error {
-	query := url.Values{}
-	if force {
-		query.Set("force", "1")
-	}
-	resp, err := cli.post(ctx, "/swarm/leave", query, nil, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/swarm_update.go

@@ -1,21 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"net/url"
-	"strconv"
-
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// SwarmUpdate updates the Swarm.
-func (cli *Client) SwarmUpdate(ctx context.Context, version swarm.Version, swarm swarm.Spec, flags swarm.UpdateFlags) error {
-	query := url.Values{}
-	query.Set("version", strconv.FormatUint(version.Index, 10))
-	query.Set("rotateWorkerToken", fmt.Sprintf("%v", flags.RotateWorkerToken))
-	query.Set("rotateManagerToken", fmt.Sprintf("%v", flags.RotateManagerToken))
-	resp, err := cli.post(ctx, "/swarm/update", query, swarm, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/client/task_inspect.go

@@ -1,34 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/docker/engine-api/types/swarm"
-
-	"golang.org/x/net/context"
-)
-
-// TaskInspectWithRaw returns the task information and its raw representation..
-func (cli *Client) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error) {
-	serverResp, err := cli.get(ctx, "/tasks/"+taskID, nil, nil)
-	if err != nil {
-		if serverResp.statusCode == http.StatusNotFound {
-			return swarm.Task{}, nil, taskNotFoundError{taskID}
-		}
-		return swarm.Task{}, nil, err
-	}
-	defer ensureReaderClosed(serverResp)
-
-	body, err := ioutil.ReadAll(serverResp.body)
-	if err != nil {
-		return swarm.Task{}, nil, err
-	}
-
-	var response swarm.Task
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&response)
-	return response, body, err
-}

vendor/src/github.com/docker/engine-api/client/task_list.go

@@ -1,35 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/docker/engine-api/types/swarm"
-	"golang.org/x/net/context"
-)
-
-// TaskList returns the list of tasks.
-func (cli *Client) TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error) {
-	query := url.Values{}
-
-	if options.Filter.Len() > 0 {
-		filterJSON, err := filters.ToParam(options.Filter)
-		if err != nil {
-			return nil, err
-		}
-
-		query.Set("filters", filterJSON)
-	}
-
-	resp, err := cli.get(ctx, "/tasks", query, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	var tasks []swarm.Task
-	err = json.NewDecoder(resp.body).Decode(&tasks)
-	ensureReaderClosed(resp)
-	return tasks, err
-}

vendor/src/github.com/docker/engine-api/client/transport/cancellable/canceler.go

@@ -1,23 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.5
-
-package cancellable
-
-import (
-	"net/http"
-
-	"github.com/docker/engine-api/client/transport"
-)
-
-func canceler(client transport.Sender, req *http.Request) func() {
-	// TODO(djd): Respect any existing value of req.Cancel.
-	ch := make(chan struct{})
-	req.Cancel = ch
-
-	return func() {
-		close(ch)
-	}
-}

vendor/src/github.com/docker/engine-api/client/transport/cancellable/canceler_go14.go

@@ -1,27 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.5
-
-package cancellable
-
-import (
-	"net/http"
-
-	"github.com/docker/engine-api/client/transport"
-)
-
-type requestCanceler interface {
-	CancelRequest(*http.Request)
-}
-
-func canceler(client transport.Sender, req *http.Request) func() {
-	rc, ok := client.(requestCanceler)
-	if !ok {
-		return func() {}
-	}
-	return func() {
-		rc.CancelRequest(req)
-	}
-}

vendor/src/github.com/docker/engine-api/client/transport/cancellable/cancellable.go

@@ -1,115 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package cancellable provides helper function to cancel http requests.
-package cancellable
-
-import (
-	"io"
-	"net/http"
-	"sync"
-
-	"github.com/docker/engine-api/client/transport"
-
-	"golang.org/x/net/context"
-)
-
-func nop() {}
-
-var (
-	testHookContextDoneBeforeHeaders = nop
-	testHookDoReturned               = nop
-	testHookDidBodyClose             = nop
-)
-
-// Do sends an HTTP request with the provided transport.Sender and returns an HTTP response.
-// If the client is nil, http.DefaultClient is used.
-// If the context is canceled or times out, ctx.Err() will be returned.
-//
-// FORK INFORMATION:
-//
-// This function deviates from the upstream version in golang.org/x/net/context/ctxhttp by
-// taking a Sender interface rather than a *http.Client directly. That allow us to use
-// this function with mocked clients and hijacked connections.
-func Do(ctx context.Context, client transport.Sender, req *http.Request) (*http.Response, error) {
-	if client == nil {
-		client = http.DefaultClient
-	}
-
-	// Request cancelation changed in Go 1.5, see canceler.go and canceler_go14.go.
-	cancel := canceler(client, req)
-
-	type responseAndError struct {
-		resp *http.Response
-		err  error
-	}
-	result := make(chan responseAndError, 1)
-
-	go func() {
-		resp, err := client.Do(req)
-		testHookDoReturned()
-		result <- responseAndError{resp, err}
-	}()
-
-	var resp *http.Response
-
-	select {
-	case <-ctx.Done():
-		testHookContextDoneBeforeHeaders()
-		cancel()
-		// Clean up after the goroutine calling client.Do:
-		go func() {
-			if r := <-result; r.resp != nil && r.resp.Body != nil {
-				testHookDidBodyClose()
-				r.resp.Body.Close()
-			}
-		}()
-		return nil, ctx.Err()
-	case r := <-result:
-		var err error
-		resp, err = r.resp, r.err
-		if err != nil {
-			return resp, err
-		}
-	}
-
-	c := make(chan struct{})
-	go func() {
-		select {
-		case <-ctx.Done():
-			cancel()
-		case <-c:
-			// The response's Body is closed.
-		}
-	}()
-	resp.Body = &notifyingReader{ReadCloser: resp.Body, notify: c}
-
-	return resp, nil
-}
-
-// notifyingReader is an io.ReadCloser that closes the notify channel after
-// Close is called or a Read fails on the underlying ReadCloser.
-type notifyingReader struct {
-	io.ReadCloser
-	notify     chan<- struct{}
-	notifyOnce sync.Once
-}
-
-func (r *notifyingReader) Read(p []byte) (int, error) {
-	n, err := r.ReadCloser.Read(p)
-	if err != nil {
-		r.notifyOnce.Do(func() {
-			close(r.notify)
-		})
-	}
-	return n, err
-}
-
-func (r *notifyingReader) Close() error {
-	err := r.ReadCloser.Close()
-	r.notifyOnce.Do(func() {
-		close(r.notify)
-	})
-	return err
-}

vendor/src/github.com/docker/engine-api/client/transport/client.go

@@ -1,47 +0,0 @@
-package transport
-
-import (
-	"crypto/tls"
-	"net/http"
-)
-
-// Sender is an interface that clients must implement
-// to be able to send requests to a remote connection.
-type Sender interface {
-	// Do sends request to a remote endpoint.
-	Do(*http.Request) (*http.Response, error)
-}
-
-// Client is an interface that abstracts all remote connections.
-type Client interface {
-	Sender
-	// Secure tells whether the connection is secure or not.
-	Secure() bool
-	// Scheme returns the connection protocol the client uses.
-	Scheme() string
-	// TLSConfig returns any TLS configuration the client uses.
-	TLSConfig() *tls.Config
-}
-
-// tlsInfo returns information about the TLS configuration.
-type tlsInfo struct {
-	tlsConfig *tls.Config
-}
-
-// TLSConfig returns the TLS configuration.
-func (t *tlsInfo) TLSConfig() *tls.Config {
-	return t.tlsConfig
-}
-
-// Scheme returns protocol scheme to use.
-func (t *tlsInfo) Scheme() string {
-	if t.tlsConfig != nil {
-		return "https"
-	}
-	return "http"
-}
-
-// Secure returns true if there is a TLS configuration.
-func (t *tlsInfo) Secure() bool {
-	return t.tlsConfig != nil
-}

vendor/src/github.com/docker/engine-api/client/transport/transport.go

@@ -1,57 +0,0 @@
-// Package transport provides function to send request to remote endpoints.
-package transport
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/docker/go-connections/sockets"
-)
-
-// apiTransport holds information about the http transport to connect with the API.
-type apiTransport struct {
-	*http.Client
-	*tlsInfo
-	transport *http.Transport
-}
-
-// NewTransportWithHTTP creates a new transport based on the provided proto, address and http client.
-// It uses Docker's default http transport configuration if the client is nil.
-// It does not modify the client's transport if it's not nil.
-func NewTransportWithHTTP(proto, addr string, client *http.Client) (Client, error) {
-	var transport *http.Transport
-
-	if client != nil {
-		tr, ok := client.Transport.(*http.Transport)
-		if !ok {
-			return nil, fmt.Errorf("unable to verify TLS configuration, invalid transport %v", client.Transport)
-		}
-		transport = tr
-	} else {
-		transport = defaultTransport(proto, addr)
-		client = &http.Client{
-			Transport: transport,
-		}
-	}
-
-	return &apiTransport{
-		Client:    client,
-		tlsInfo:   &tlsInfo{transport.TLSClientConfig},
-		transport: transport,
-	}, nil
-}
-
-// CancelRequest stops a request execution.
-func (a *apiTransport) CancelRequest(req *http.Request) {
-	a.transport.CancelRequest(req)
-}
-
-// defaultTransport creates a new http.Transport with Docker's
-// default transport configuration.
-func defaultTransport(proto, addr string) *http.Transport {
-	tr := new(http.Transport)
-	sockets.ConfigureTransport(tr, proto, addr)
-	return tr
-}
-
-var _ Client = &apiTransport{}

vendor/src/github.com/docker/engine-api/client/version.go

@@ -1,21 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// ServerVersion returns information of the docker client and server host.
-func (cli *Client) ServerVersion(ctx context.Context) (types.Version, error) {
-	resp, err := cli.get(ctx, "/version", nil, nil)
-	if err != nil {
-		return types.Version{}, err
-	}
-
-	var server types.Version
-	err = json.NewDecoder(resp.body).Decode(&server)
-	ensureReaderClosed(resp)
-	return server, err
-}

vendor/src/github.com/docker/engine-api/client/volume_create.go

@@ -1,20 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// VolumeCreate creates a volume in the docker host.
-func (cli *Client) VolumeCreate(ctx context.Context, options types.VolumeCreateRequest) (types.Volume, error) {
-	var volume types.Volume
-	resp, err := cli.post(ctx, "/volumes/create", nil, options, nil)
-	if err != nil {
-		return volume, err
-	}
-	err = json.NewDecoder(resp.body).Decode(&volume)
-	ensureReaderClosed(resp)
-	return volume, err
-}

vendor/src/github.com/docker/engine-api/client/volume_inspect.go

@@ -1,38 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/docker/engine-api/types"
-	"golang.org/x/net/context"
-)
-
-// VolumeInspect returns the information about a specific volume in the docker host.
-func (cli *Client) VolumeInspect(ctx context.Context, volumeID string) (types.Volume, error) {
-	volume, _, err := cli.VolumeInspectWithRaw(ctx, volumeID)
-	return volume, err
-}
-
-// VolumeInspectWithRaw returns the information about a specific volume in the docker host and its raw representation
-func (cli *Client) VolumeInspectWithRaw(ctx context.Context, volumeID string) (types.Volume, []byte, error) {
-	var volume types.Volume
-	resp, err := cli.get(ctx, "/volumes/"+volumeID, nil, nil)
-	if err != nil {
-		if resp.statusCode == http.StatusNotFound {
-			return volume, nil, volumeNotFoundError{volumeID}
-		}
-		return volume, nil, err
-	}
-	defer ensureReaderClosed(resp)
-
-	body, err := ioutil.ReadAll(resp.body)
-	if err != nil {
-		return volume, nil, err
-	}
-	rdr := bytes.NewReader(body)
-	err = json.NewDecoder(rdr).Decode(&volume)
-	return volume, body, err
-}

vendor/src/github.com/docker/engine-api/client/volume_list.go

@@ -1,32 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"net/url"
-
-	"github.com/docker/engine-api/types"
-	"github.com/docker/engine-api/types/filters"
-	"golang.org/x/net/context"
-)
-
-// VolumeList returns the volumes configured in the docker host.
-func (cli *Client) VolumeList(ctx context.Context, filter filters.Args) (types.VolumesListResponse, error) {
-	var volumes types.VolumesListResponse
-	query := url.Values{}
-
-	if filter.Len() > 0 {
-		filterJSON, err := filters.ToParamWithVersion(cli.version, filter)
-		if err != nil {
-			return volumes, err
-		}
-		query.Set("filters", filterJSON)
-	}
-	resp, err := cli.get(ctx, "/volumes", query, nil)
-	if err != nil {
-		return volumes, err
-	}
-
-	err = json.NewDecoder(resp.body).Decode(&volumes)
-	ensureReaderClosed(resp)
-	return volumes, err
-}

vendor/src/github.com/docker/engine-api/client/volume_remove.go

@@ -1,18 +0,0 @@
-package client
-
-import (
-	"net/url"
-
-	"golang.org/x/net/context"
-)
-
-// VolumeRemove removes a volume from the docker host.
-func (cli *Client) VolumeRemove(ctx context.Context, volumeID string, force bool) error {
-	query := url.Values{}
-	if force {
-		query.Set("force", "1")
-	}
-	resp, err := cli.delete(ctx, "/volumes/"+volumeID, query, nil)
-	ensureReaderClosed(resp)
-	return err
-}

vendor/src/github.com/docker/engine-api/types/auth.go

@@ -1,22 +0,0 @@
-package types
-
-// AuthConfig contains authorization information for connecting to a Registry
-type AuthConfig struct {
-	Username string `json:"username,omitempty"`
-	Password string `json:"password,omitempty"`
-	Auth     string `json:"auth,omitempty"`
-
-	// Email is an optional value associated with the username.
-	// This field is deprecated and will be removed in a later
-	// version of docker.
-	Email string `json:"email,omitempty"`
-
-	ServerAddress string `json:"serveraddress,omitempty"`
-
-	// IdentityToken is used to authenticate the user and get
-	// an access token for the registry.
-	IdentityToken string `json:"identitytoken,omitempty"`
-
-	// RegistryToken is a bearer token to be sent to a registry
-	RegistryToken string `json:"registrytoken,omitempty"`
-}

vendor/src/github.com/docker/engine-api/types/blkiodev/blkio.go

@@ -1,23 +0,0 @@
-package blkiodev
-
-import "fmt"
-
-// WeightDevice is a structure that holds device:weight pair
-type WeightDevice struct {
-	Path   string
-	Weight uint16
-}
-
-func (w *WeightDevice) String() string {
-	return fmt.Sprintf("%s:%d", w.Path, w.Weight)
-}
-
-// ThrottleDevice is a structure that holds device:rate_per_second pair
-type ThrottleDevice struct {
-	Path string
-	Rate uint64
-}
-
-func (t *ThrottleDevice) String() string {
-	return fmt.Sprintf("%s:%d", t.Path, t.Rate)
-}

vendor/src/github.com/docker/engine-api/types/client.go

@@ -1,300 +0,0 @@
-package types
-
-import (
-	"bufio"
-	"io"
-	"net"
-
-	"github.com/docker/engine-api/types/container"
-	"github.com/docker/engine-api/types/filters"
-	"github.com/docker/go-units"
-)
-
-// CheckpointCreateOptions holds parameters to create a checkpoint from a container
-type CheckpointCreateOptions struct {
-	CheckpointID string
-	Exit         bool
-}
-
-// ContainerAttachOptions holds parameters to attach to a container.
-type ContainerAttachOptions struct {
-	Stream     bool
-	Stdin      bool
-	Stdout     bool
-	Stderr     bool
-	DetachKeys string
-}
-
-// ContainerCommitOptions holds parameters to commit changes into a container.
-type ContainerCommitOptions struct {
-	Reference string
-	Comment   string
-	Author    string
-	Changes   []string
-	Pause     bool
-	Config    *container.Config
-}
-
-// ContainerExecInspect holds information returned by exec inspect.
-type ContainerExecInspect struct {
-	ExecID      string
-	ContainerID string
-	Running     bool
-	ExitCode    int
-}
-
-// ContainerListOptions holds parameters to list containers with.
-type ContainerListOptions struct {
-	Quiet  bool
-	Size   bool
-	All    bool
-	Latest bool
-	Since  string
-	Before string
-	Limit  int
-	Filter filters.Args
-}
-
-// ContainerLogsOptions holds parameters to filter logs with.
-type ContainerLogsOptions struct {
-	ShowStdout bool
-	ShowStderr bool
-	Since      string
-	Timestamps bool
-	Follow     bool
-	Tail       string
-	Details    bool
-}
-
-// ContainerRemoveOptions holds parameters to remove containers.
-type ContainerRemoveOptions struct {
-	RemoveVolumes bool
-	RemoveLinks   bool
-	Force         bool
-}
-
-// ContainerStartOptions holds parameters to start containers.
-type ContainerStartOptions struct {
-	CheckpointID string
-}
-
-// CopyToContainerOptions holds information
-// about files to copy into a container
-type CopyToContainerOptions struct {
-	AllowOverwriteDirWithFile bool
-}
-
-// EventsOptions hold parameters to filter events with.
-type EventsOptions struct {
-	Since   string
-	Until   string
-	Filters filters.Args
-}
-
-// NetworkListOptions holds parameters to filter the list of networks with.
-type NetworkListOptions struct {
-	Filters filters.Args
-}
-
-// HijackedResponse holds connection information for a hijacked request.
-type HijackedResponse struct {
-	Conn   net.Conn
-	Reader *bufio.Reader
-}
-
-// Close closes the hijacked connection and reader.
-func (h *HijackedResponse) Close() {
-	h.Conn.Close()
-}
-
-// CloseWriter is an interface that implements structs
-// that close input streams to prevent from writing.
-type CloseWriter interface {
-	CloseWrite() error
-}
-
-// CloseWrite closes a readWriter for writing.
-func (h *HijackedResponse) CloseWrite() error {
-	if conn, ok := h.Conn.(CloseWriter); ok {
-		return conn.CloseWrite()
-	}
-	return nil
-}
-
-// ImageBuildOptions holds the information
-// necessary to build images.
-type ImageBuildOptions struct {
-	Tags           []string
-	SuppressOutput bool
-	RemoteContext  string
-	NoCache        bool
-	Remove         bool
-	ForceRemove    bool
-	PullParent     bool
-	Isolation      container.Isolation
-	CPUSetCPUs     string
-	CPUSetMems     string
-	CPUShares      int64
-	CPUQuota       int64
-	CPUPeriod      int64
-	Memory         int64
-	MemorySwap     int64
-	CgroupParent   string
-	ShmSize        int64
-	Dockerfile     string
-	Ulimits        []*units.Ulimit
-	BuildArgs      map[string]string
-	AuthConfigs    map[string]AuthConfig
-	Context        io.Reader
-	Labels         map[string]string
-	// squash the resulting image's layers to the parent
-	// preserves the original image and creates a new one from the parent with all
-	// the changes applied to a single layer
-	Squash bool
-}
-
-// ImageBuildResponse holds information
-// returned by a server after building
-// an image.
-type ImageBuildResponse struct {
-	Body   io.ReadCloser
-	OSType string
-}
-
-// ImageCreateOptions holds information to create images.
-type ImageCreateOptions struct {
-	RegistryAuth string // RegistryAuth is the base64 encoded credentials for the registry
-}
-
-// ImageImportSource holds source information for ImageImport
-type ImageImportSource struct {
-	Source     io.Reader // Source is the data to send to the server to create this image from (mutually exclusive with SourceName)
-	SourceName string    // SourceName is the name of the image to pull (mutually exclusive with Source)
-}
-
-// ImageImportOptions holds information to import images from the client host.
-type ImageImportOptions struct {
-	Tag     string   // Tag is the name to tag this image with. This attribute is deprecated.
-	Message string   // Message is the message to tag the image with
-	Changes []string // Changes are the raw changes to apply to this image
-}
-
-// ImageListOptions holds parameters to filter the list of images with.
-type ImageListOptions struct {
-	MatchName string
-	All       bool
-	Filters   filters.Args
-}
-
-// ImageLoadResponse returns information to the client about a load process.
-type ImageLoadResponse struct {
-	// Body must be closed to avoid a resource leak
-	Body io.ReadCloser
-	JSON bool
-}
-
-// ImagePullOptions holds information to pull images.
-type ImagePullOptions struct {
-	All           bool
-	RegistryAuth  string // RegistryAuth is the base64 encoded credentials for the registry
-	PrivilegeFunc RequestPrivilegeFunc
-}
-
-// RequestPrivilegeFunc is a function interface that
-// clients can supply to retry operations after
-// getting an authorization error.
-// This function returns the registry authentication
-// header value in base 64 format, or an error
-// if the privilege request fails.
-type RequestPrivilegeFunc func() (string, error)
-
-//ImagePushOptions holds information to push images.
-type ImagePushOptions ImagePullOptions
-
-// ImageRemoveOptions holds parameters to remove images.
-type ImageRemoveOptions struct {
-	Force         bool
-	PruneChildren bool
-}
-
-// ImageSearchOptions holds parameters to search images with.
-type ImageSearchOptions struct {
-	RegistryAuth  string
-	PrivilegeFunc RequestPrivilegeFunc
-	Filters       filters.Args
-	Limit         int
-}
-
-// ResizeOptions holds parameters to resize a tty.
-// It can be used to resize container ttys and
-// exec process ttys too.
-type ResizeOptions struct {
-	Height int
-	Width  int
-}
-
-// VersionResponse holds version information for the client and the server
-type VersionResponse struct {
-	Client *Version
-	Server *Version
-}
-
-// ServerOK returns true when the client could connect to the docker server
-// and parse the information received. It returns false otherwise.
-func (v VersionResponse) ServerOK() bool {
-	return v.Server != nil
-}
-
-// NodeListOptions holds parameters to list nodes with.
-type NodeListOptions struct {
-	Filter filters.Args
-}
-
-// NodeRemoveOptions holds parameters to remove nodes with.
-type NodeRemoveOptions struct {
-	Force bool
-}
-
-// ServiceCreateOptions contains the options to use when creating a service.
-type ServiceCreateOptions struct {
-	// EncodedRegistryAuth is the encoded registry authorization credentials to
-	// use when updating the service.
-	//
-	// This field follows the format of the X-Registry-Auth header.
-	EncodedRegistryAuth string
-}
-
-// ServiceCreateResponse contains the information returned to a client
-// on the  creation of a new service.
-type ServiceCreateResponse struct {
-	// ID is the ID of the created service.
-	ID string
-}
-
-// ServiceUpdateOptions contains the options to be used for updating services.
-type ServiceUpdateOptions struct {
-	// EncodedRegistryAuth is the encoded registry authorization credentials to
-	// use when updating the service.
-	//
-	// This field follows the format of the X-Registry-Auth header.
-	EncodedRegistryAuth string
-
-	// TODO(stevvooe): Consider moving the version parameter of ServiceUpdate
-	// into this field. While it does open API users up to racy writes, most
-	// users may not need that level of consistency in practice.
-}
-
-// ServiceListOptions holds parameters to list  services with.
-type ServiceListOptions struct {
-	Filter filters.Args
-}
-
-// TaskListOptions holds parameters to list  tasks with.
-type TaskListOptions struct {
-	Filter filters.Args
-}
-
-// PluginRemoveOptions holds parameters to remove plugins.
-type PluginRemoveOptions struct {
-	Force bool
-}

vendor/src/github.com/docker/engine-api/types/configs.go

@@ -1,61 +0,0 @@
-package types
-
-import (
-	"github.com/docker/engine-api/types/container"
-	"github.com/docker/engine-api/types/network"
-)
-
-// configs holds structs used for internal communication between the
-// frontend (such as an http server) and the backend (such as the
-// docker daemon).
-
-// ContainerCreateConfig is the parameter set to ContainerCreate()
-type ContainerCreateConfig struct {
-	Name             string
-	Config           *container.Config
-	HostConfig       *container.HostConfig
-	NetworkingConfig *network.NetworkingConfig
-	AdjustCPUShares  bool
-}
-
-// ContainerRmConfig holds arguments for the container remove
-// operation. This struct is used to tell the backend what operations
-// to perform.
-type ContainerRmConfig struct {
-	ForceRemove, RemoveVolume, RemoveLink bool
-}
-
-// ContainerCommitConfig contains build configs for commit operation,
-// and is used when making a commit with the current state of the container.
-type ContainerCommitConfig struct {
-	Pause   bool
-	Repo    string
-	Tag     string
-	Author  string
-	Comment string
-	// merge container config into commit config before commit
-	MergeConfigs bool
-	Config       *container.Config
-}
-
-// ExecConfig is a small subset of the Config struct that holds the configuration
-// for the exec feature of docker.
-type ExecConfig struct {
-	User         string   // User that will run the command
-	Privileged   bool     // Is the container in privileged mode
-	Tty          bool     // Attach standard streams to a tty.
-	AttachStdin  bool     // Attach the standard input, makes possible user interaction
-	AttachStderr bool     // Attach the standard error
-	AttachStdout bool     // Attach the standard output
-	Detach       bool     // Execute in detach mode
-	DetachKeys   string   // Escape keys for detach
-	Env          []string // Environment variables
-	Cmd          []string // Execution commands and args
-}
-
-// PluginRmConfig holds arguments for the plugin remove
-// operation. This struct is used to tell the backend what operations
-// to perform.
-type PluginRmConfig struct {
-	ForceRemove bool
-}

vendor/src/github.com/docker/engine-api/types/container/config.go

@@ -1,62 +0,0 @@
-package container
-
-import (
-	"time"
-
-	"github.com/docker/engine-api/types/strslice"
-	"github.com/docker/go-connections/nat"
-)
-
-// HealthConfig holds configuration settings for the HEALTHCHECK feature.
-type HealthConfig struct {
-	// Test is the test to perform to check that the container is healthy.
-	// An empty slice means to inherit the default.
-	// The options are:
-	// {} : inherit healthcheck
-	// {"NONE"} : disable healthcheck
-	// {"CMD", args...} : exec arguments directly
-	// {"CMD-SHELL", command} : run command with system's default shell
-	Test []string `json:",omitempty"`
-
-	// Zero means to inherit. Durations are expressed as integer nanoseconds.
-	Interval time.Duration `json:",omitempty"` // Interval is the time to wait between checks.
-	Timeout  time.Duration `json:",omitempty"` // Timeout is the time to wait before considering the check to have hung.
-
-	// Retries is the number of consecutive failures needed to consider a container as unhealthy.
-	// Zero means inherit.
-	Retries int `json:",omitempty"`
-}
-
-// Config contains the configuration data about a container.
-// It should hold only portable information about the container.
-// Here, "portable" means "independent from the host we are running on".
-// Non-portable information *should* appear in HostConfig.
-// All fields added to this struct must be marked `omitempty` to keep getting
-// predictable hashes from the old `v1Compatibility` configuration.
-type Config struct {
-	Hostname        string                // Hostname
-	Domainname      string                // Domainname
-	User            string                // User that will run the command(s) inside the container, also support user:group
-	AttachStdin     bool                  // Attach the standard input, makes possible user interaction
-	AttachStdout    bool                  // Attach the standard output
-	AttachStderr    bool                  // Attach the standard error
-	ExposedPorts    map[nat.Port]struct{} `json:",omitempty"` // List of exposed ports
-	Tty             bool                  // Attach standard streams to a tty, including stdin if it is not closed.
-	OpenStdin       bool                  // Open stdin
-	StdinOnce       bool                  // If true, close stdin after the 1 attached client disconnects.
-	Env             []string              // List of environment variable to set in the container
-	Cmd             strslice.StrSlice     // Command to run when starting the container
-	Healthcheck     *HealthConfig         `json:",omitempty"` // Healthcheck describes how to check the container is healthy
-	ArgsEscaped     bool                  `json:",omitempty"` // True if command is already escaped (Windows specific)
-	Image           string                // Name of the image as it was passed by the operator (eg. could be symbolic)
-	Volumes         map[string]struct{}   // List of volumes (mounts) used for the container
-	WorkingDir      string                // Current directory (PWD) in the command will be launched
-	Entrypoint      strslice.StrSlice     // Entrypoint to run when starting the container
-	NetworkDisabled bool                  `json:",omitempty"` // Is network disabled
-	MacAddress      string                `json:",omitempty"` // Mac Address of the container
-	OnBuild         []string              // ONBUILD metadata that were defined on the image Dockerfile
-	Labels          map[string]string     // List of labels set to this container
-	StopSignal      string                `json:",omitempty"` // Signal to stop a container
-	StopTimeout     *int                  `json:",omitempty"` // Timeout (in seconds) to stop a container
-	Shell           strslice.StrSlice     `json:",omitempty"` // Shell for shell-form of RUN, CMD, ENTRYPOINT
-}

vendor/src/github.com/docker/engine-api/types/container/host_config.go

@@ -1,324 +0,0 @@
-package container
-
-import (
-	"strings"
-
-	"github.com/docker/engine-api/types/blkiodev"
-	"github.com/docker/engine-api/types/mount"
-	"github.com/docker/engine-api/types/strslice"
-	"github.com/docker/go-connections/nat"
-	"github.com/docker/go-units"
-)
-
-// NetworkMode represents the container network stack.
-type NetworkMode string
-
-// Isolation represents the isolation technology of a container. The supported
-// values are platform specific
-type Isolation string
-
-// IsDefault indicates the default isolation technology of a container. On Linux this
-// is the native driver. On Windows, this is a Windows Server Container.
-func (i Isolation) IsDefault() bool {
-	return strings.ToLower(string(i)) == "default" || string(i) == ""
-}
-
-// IpcMode represents the container ipc stack.
-type IpcMode string
-
-// IsPrivate indicates whether the container uses its private ipc stack.
-func (n IpcMode) IsPrivate() bool {
-	return !(n.IsHost() || n.IsContainer())
-}
-
-// IsHost indicates whether the container uses the host's ipc stack.
-func (n IpcMode) IsHost() bool {
-	return n == "host"
-}
-
-// IsContainer indicates whether the container uses a container's ipc stack.
-func (n IpcMode) IsContainer() bool {
-	parts := strings.SplitN(string(n), ":", 2)
-	return len(parts) > 1 && parts[0] == "container"
-}
-
-// Valid indicates whether the ipc stack is valid.
-func (n IpcMode) Valid() bool {
-	parts := strings.Split(string(n), ":")
-	switch mode := parts[0]; mode {
-	case "", "host":
-	case "container":
-		if len(parts) != 2 || parts[1] == "" {
-			return false
-		}
-	default:
-		return false
-	}
-	return true
-}
-
-// Container returns the name of the container ipc stack is going to be used.
-func (n IpcMode) Container() string {
-	parts := strings.SplitN(string(n), ":", 2)
-	if len(parts) > 1 {
-		return parts[1]
-	}
-	return ""
-}
-
-// UsernsMode represents userns mode in the container.
-type UsernsMode string
-
-// IsHost indicates whether the container uses the host's userns.
-func (n UsernsMode) IsHost() bool {
-	return n == "host"
-}
-
-// IsPrivate indicates whether the container uses the a private userns.
-func (n UsernsMode) IsPrivate() bool {
-	return !(n.IsHost())
-}
-
-// Valid indicates whether the userns is valid.
-func (n UsernsMode) Valid() bool {
-	parts := strings.Split(string(n), ":")
-	switch mode := parts[0]; mode {
-	case "", "host":
-	default:
-		return false
-	}
-	return true
-}
-
-// CgroupSpec represents the cgroup to use for the container.
-type CgroupSpec string
-
-// IsContainer indicates whether the container is using another container cgroup
-func (c CgroupSpec) IsContainer() bool {
-	parts := strings.SplitN(string(c), ":", 2)
-	return len(parts) > 1 && parts[0] == "container"
-}
-
-// Valid indicates whether the cgroup spec is valid.
-func (c CgroupSpec) Valid() bool {
-	return c.IsContainer() || c == ""
-}
-
-// Container returns the name of the container whose cgroup will be used.
-func (c CgroupSpec) Container() string {
-	parts := strings.SplitN(string(c), ":", 2)
-	if len(parts) > 1 {
-		return parts[1]
-	}
-	return ""
-}
-
-// UTSMode represents the UTS namespace of the container.
-type UTSMode string
-
-// IsPrivate indicates whether the container uses its private UTS namespace.
-func (n UTSMode) IsPrivate() bool {
-	return !(n.IsHost())
-}
-
-// IsHost indicates whether the container uses the host's UTS namespace.
-func (n UTSMode) IsHost() bool {
-	return n == "host"
-}
-
-// Valid indicates whether the UTS namespace is valid.
-func (n UTSMode) Valid() bool {
-	parts := strings.Split(string(n), ":")
-	switch mode := parts[0]; mode {
-	case "", "host":
-	default:
-		return false
-	}
-	return true
-}
-
-// PidMode represents the pid namespace of the container.
-type PidMode string
-
-// IsPrivate indicates whether the container uses its own new pid namespace.
-func (n PidMode) IsPrivate() bool {
-	return !(n.IsHost() || n.IsContainer())
-}
-
-// IsHost indicates whether the container uses the host's pid namespace.
-func (n PidMode) IsHost() bool {
-	return n == "host"
-}
-
-// IsContainer indicates whether the container uses a container's pid namespace.
-func (n PidMode) IsContainer() bool {
-	parts := strings.SplitN(string(n), ":", 2)
-	return len(parts) > 1 && parts[0] == "container"
-}
-
-// Valid indicates whether the pid namespace is valid.
-func (n PidMode) Valid() bool {
-	parts := strings.Split(string(n), ":")
-	switch mode := parts[0]; mode {
-	case "", "host":
-	case "container":
-		if len(parts) != 2 || parts[1] == "" {
-			return false
-		}
-	default:
-		return false
-	}
-	return true
-}
-
-// Container returns the name of the container whose pid namespace is going to be used.
-func (n PidMode) Container() string {
-	parts := strings.SplitN(string(n), ":", 2)
-	if len(parts) > 1 {
-		return parts[1]
-	}
-	return ""
-}
-
-// DeviceMapping represents the device mapping between the host and the container.
-type DeviceMapping struct {
-	PathOnHost        string
-	PathInContainer   string
-	CgroupPermissions string
-}
-
-// RestartPolicy represents the restart policies of the container.
-type RestartPolicy struct {
-	Name              string
-	MaximumRetryCount int
-}
-
-// IsNone indicates whether the container has the "no" restart policy.
-// This means the container will not automatically restart when exiting.
-func (rp *RestartPolicy) IsNone() bool {
-	return rp.Name == "no" || rp.Name == ""
-}
-
-// IsAlways indicates whether the container has the "always" restart policy.
-// This means the container will automatically restart regardless of the exit status.
-func (rp *RestartPolicy) IsAlways() bool {
-	return rp.Name == "always"
-}
-
-// IsOnFailure indicates whether the container has the "on-failure" restart policy.
-// This means the container will automatically restart of exiting with a non-zero exit status.
-func (rp *RestartPolicy) IsOnFailure() bool {
-	return rp.Name == "on-failure"
-}
-
-// IsUnlessStopped indicates whether the container has the
-// "unless-stopped" restart policy. This means the container will
-// automatically restart unless user has put it to stopped state.
-func (rp *RestartPolicy) IsUnlessStopped() bool {
-	return rp.Name == "unless-stopped"
-}
-
-// IsSame compares two RestartPolicy to see if they are the same
-func (rp *RestartPolicy) IsSame(tp *RestartPolicy) bool {
-	return rp.Name == tp.Name && rp.MaximumRetryCount == tp.MaximumRetryCount
-}
-
-// LogConfig represents the logging configuration of the container.
-type LogConfig struct {
-	Type   string
-	Config map[string]string
-}
-
-// Resources contains container's resources (cgroups config, ulimits...)
-type Resources struct {
-	// Applicable to all platforms
-	CPUShares int64 `json:"CpuShares"` // CPU shares (relative weight vs. other containers)
-	Memory    int64 // Memory limit (in bytes)
-
-	// Applicable to UNIX platforms
-	CgroupParent         string // Parent cgroup.
-	BlkioWeight          uint16 // Block IO weight (relative weight vs. other containers)
-	BlkioWeightDevice    []*blkiodev.WeightDevice
-	BlkioDeviceReadBps   []*blkiodev.ThrottleDevice
-	BlkioDeviceWriteBps  []*blkiodev.ThrottleDevice
-	BlkioDeviceReadIOps  []*blkiodev.ThrottleDevice
-	BlkioDeviceWriteIOps []*blkiodev.ThrottleDevice
-	CPUPeriod            int64           `json:"CpuPeriod"` // CPU CFS (Completely Fair Scheduler) period
-	CPUQuota             int64           `json:"CpuQuota"`  // CPU CFS (Completely Fair Scheduler) quota
-	CpusetCpus           string          // CpusetCpus 0-2, 0,1
-	CpusetMems           string          // CpusetMems 0-2, 0,1
-	Devices              []DeviceMapping // List of devices to map inside the container
-	DiskQuota            int64           // Disk limit (in bytes)
-	KernelMemory         int64           // Kernel memory limit (in bytes)
-	MemoryReservation    int64           // Memory soft limit (in bytes)
-	MemorySwap           int64           // Total memory usage (memory + swap); set `-1` to enable unlimited swap
-	MemorySwappiness     *int64          // Tuning container memory swappiness behaviour
-	OomKillDisable       *bool           // Whether to disable OOM Killer or not
-	PidsLimit            int64           // Setting pids limit for a container
-	Ulimits              []*units.Ulimit // List of ulimits to be set in the container
-
-	// Applicable to Windows
-	CPUCount           int64  `json:"CpuCount"`   // CPU count
-	CPUPercent         int64  `json:"CpuPercent"` // CPU percent
-	IOMaximumIOps      uint64 // Maximum IOps for the container system drive
-	IOMaximumBandwidth uint64 // Maximum IO in bytes per second for the container system drive
-}
-
-// UpdateConfig holds the mutable attributes of a Container.
-// Those attributes can be updated at runtime.
-type UpdateConfig struct {
-	// Contains container's resources (cgroups, ulimits)
-	Resources
-	RestartPolicy RestartPolicy
-}
-
-// HostConfig the non-portable Config structure of a container.
-// Here, "non-portable" means "dependent of the host we are running on".
-// Portable information *should* appear in Config.
-type HostConfig struct {
-	// Applicable to all platforms
-	Binds           []string      // List of volume bindings for this container
-	ContainerIDFile string        // File (path) where the containerId is written
-	LogConfig       LogConfig     // Configuration of the logs for this container
-	NetworkMode     NetworkMode   // Network mode to use for the container
-	PortBindings    nat.PortMap   // Port mapping between the exposed port (container) and the host
-	RestartPolicy   RestartPolicy // Restart policy to be used for the container
-	AutoRemove      bool          // Automatically remove container when it exits
-	VolumeDriver    string        // Name of the volume driver used to mount volumes
-	VolumesFrom     []string      // List of volumes to take from other container
-
-	// Applicable to UNIX platforms
-	CapAdd          strslice.StrSlice // List of kernel capabilities to add to the container
-	CapDrop         strslice.StrSlice // List of kernel capabilities to remove from the container
-	DNS             []string          `json:"Dns"`        // List of DNS server to lookup
-	DNSOptions      []string          `json:"DnsOptions"` // List of DNSOption to look for
-	DNSSearch       []string          `json:"DnsSearch"`  // List of DNSSearch to look for
-	ExtraHosts      []string          // List of extra hosts
-	GroupAdd        []string          // List of additional groups that the container process will run as
-	IpcMode         IpcMode           // IPC namespace to use for the container
-	Cgroup          CgroupSpec        // Cgroup to use for the container
-	Links           []string          // List of links (in the name:alias form)
-	OomScoreAdj     int               // Container preference for OOM-killing
-	PidMode         PidMode           // PID namespace to use for the container
-	Privileged      bool              // Is the container in privileged mode
-	PublishAllPorts bool              // Should docker publish all exposed port for the container
-	ReadonlyRootfs  bool              // Is the container root filesystem in read-only
-	SecurityOpt     []string          // List of string values to customize labels for MLS systems, such as SELinux.
-	StorageOpt      map[string]string `json:",omitempty"` // Storage driver options per container.
-	Tmpfs           map[string]string `json:",omitempty"` // List of tmpfs (mounts) used for the container
-	UTSMode         UTSMode           // UTS namespace to use for the container
-	UsernsMode      UsernsMode        // The user namespace to use for the container
-	ShmSize         int64             // Total shm memory usage
-	Sysctls         map[string]string `json:",omitempty"` // List of Namespaced sysctls used for the container
-	Runtime         string            `json:",omitempty"` // Runtime to use with this container
-
-	// Applicable to Windows
-	ConsoleSize [2]int    // Initial console size
-	Isolation   Isolation // Isolation technology of the container (eg default, hyperv)
-
-	// Contains container's resources (cgroups, ulimits)
-	Resources
-
-	// Mounts specs used by the container
-	Mounts []mount.Mount `json:",omitempty"`
-}

vendor/src/github.com/docker/engine-api/types/container/hostconfig_unix.go

@@ -1,81 +0,0 @@
-// +build !windows
-
-package container
-
-import "strings"
-
-// IsValid indicates if an isolation technology is valid
-func (i Isolation) IsValid() bool {
-	return i.IsDefault()
-}
-
-// IsPrivate indicates whether container uses it's private network stack.
-func (n NetworkMode) IsPrivate() bool {
-	return !(n.IsHost() || n.IsContainer())
-}
-
-// IsDefault indicates whether container uses the default network stack.
-func (n NetworkMode) IsDefault() bool {
-	return n == "default"
-}
-
-// NetworkName returns the name of the network stack.
-func (n NetworkMode) NetworkName() string {
-	if n.IsBridge() {
-		return "bridge"
-	} else if n.IsHost() {
-		return "host"
-	} else if n.IsContainer() {
-		return "container"
-	} else if n.IsNone() {
-		return "none"
-	} else if n.IsDefault() {
-		return "default"
-	} else if n.IsUserDefined() {
-		return n.UserDefined()
-	}
-	return ""
-}
-
-// IsBridge indicates whether container uses the bridge network stack
-func (n NetworkMode) IsBridge() bool {
-	return n == "bridge"
-}
-
-// IsHost indicates whether container uses the host network stack.
-func (n NetworkMode) IsHost() bool {
-	return n == "host"
-}
-
-// IsContainer indicates whether container uses a container network stack.
-func (n NetworkMode) IsContainer() bool {
-	parts := strings.SplitN(string(n), ":", 2)
-	return len(parts) > 1 && parts[0] == "container"
-}
-
-// IsNone indicates whether container isn't using a network stack.
-func (n NetworkMode) IsNone() bool {
-	return n == "none"
-}
-
-// ConnectedContainer is the id of the container which network this container is connected to.
-func (n NetworkMode) ConnectedContainer() string {
-	parts := strings.SplitN(string(n), ":", 2)
-	if len(parts) > 1 {
-		return parts[1]
-	}
-	return ""
-}
-
-// IsUserDefined indicates user-created network
-func (n NetworkMode) IsUserDefined() bool {
-	return !n.IsDefault() && !n.IsBridge() && !n.IsHost() && !n.IsNone() && !n.IsContainer()
-}
-
-//UserDefined indicates user-created network
-func (n NetworkMode) UserDefined() string {
-	if n.IsUserDefined() {
-		return string(n)
-	}
-	return ""
-}

vendor/src/github.com/docker/engine-api/types/container/hostconfig_windows.go

@@ -1,87 +0,0 @@
-package container
-
-import (
-	"strings"
-)
-
-// IsDefault indicates whether container uses the default network stack.
-func (n NetworkMode) IsDefault() bool {
-	return n == "default"
-}
-
-// IsNone indicates whether container isn't using a network stack.
-func (n NetworkMode) IsNone() bool {
-	return n == "none"
-}
-
-// IsContainer indicates whether container uses a container network stack.
-// Returns false as windows doesn't support this mode
-func (n NetworkMode) IsContainer() bool {
-	return false
-}
-
-// IsBridge indicates whether container uses the bridge network stack
-// in windows it is given the name NAT
-func (n NetworkMode) IsBridge() bool {
-	return n == "nat"
-}
-
-// IsHost indicates whether container uses the host network stack.
-// returns false as this is not supported by windows
-func (n NetworkMode) IsHost() bool {
-	return false
-}
-
-// IsPrivate indicates whether container uses its private network stack.
-func (n NetworkMode) IsPrivate() bool {
-	return !(n.IsHost() || n.IsContainer())
-}
-
-// ConnectedContainer is the id of the container which network this container is connected to.
-// Returns blank string on windows
-func (n NetworkMode) ConnectedContainer() string {
-	return ""
-}
-
-// IsUserDefined indicates user-created network
-func (n NetworkMode) IsUserDefined() bool {
-	return !n.IsDefault() && !n.IsNone() && !n.IsBridge()
-}
-
-// IsHyperV indicates the use of a Hyper-V partition for isolation
-func (i Isolation) IsHyperV() bool {
-	return strings.ToLower(string(i)) == "hyperv"
-}
-
-// IsProcess indicates the use of process isolation
-func (i Isolation) IsProcess() bool {
-	return strings.ToLower(string(i)) == "process"
-}
-
-// IsValid indicates if an isolation technology is valid
-func (i Isolation) IsValid() bool {
-	return i.IsDefault() || i.IsHyperV() || i.IsProcess()
-}
-
-// NetworkName returns the name of the network stack.
-func (n NetworkMode) NetworkName() string {
-	if n.IsDefault() {
-		return "default"
-	} else if n.IsBridge() {
-		return "nat"
-	} else if n.IsNone() {
-		return "none"
-	} else if n.IsUserDefined() {
-		return n.UserDefined()
-	}
-
-	return ""
-}
-
-//UserDefined indicates user-created network
-func (n NetworkMode) UserDefined() string {
-	if n.IsUserDefined() {
-		return string(n)
-	}
-	return ""
-}

vendor/src/github.com/docker/engine-api/types/errors.go

@@ -1,6 +0,0 @@
-package types
-
-// ErrorResponse is the response body of API errors.
-type ErrorResponse struct {
-	Message string `json:"message"`
-}