diff --git a/Godeps/_workspace/src/github.com/docker/libcompose/docker/container.go b/Godeps/_workspace/src/github.com/docker/libcompose/docker/container.go index d112c5bdd..be3eb0f09 100644 --- a/Godeps/_workspace/src/github.com/docker/libcompose/docker/container.go +++ b/Godeps/_workspace/src/github.com/docker/libcompose/docker/container.go @@ -16,6 +16,7 @@ import ( "github.com/docker/libcompose/logger" "github.com/docker/libcompose/project" "github.com/samalba/dockerclient" + "os" ) type Container struct { @@ -467,7 +468,7 @@ func PullImage(client dockerclient.Client, service *Service, image string) error Username: authConfig.Username, Password: authConfig.Password, Email: authConfig.Email, - }) + }, os.Stderr) if err != nil { logrus.Errorf("Failed to pull image %s: %v", image, err) diff --git a/Godeps/_workspace/src/github.com/samalba/dockerclient/auth_test.go b/Godeps/_workspace/src/github.com/samalba/dockerclient/auth_test.go old mode 100644 new mode 100755 diff --git a/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient.go b/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient.go index d8b11f4c1..7e900c7f0 100644 --- a/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient.go +++ b/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient.go @@ -14,6 +14,9 @@ import ( "strings" "sync/atomic" "time" + + "github.com/docker/docker/pkg/jsonmessage" + "github.com/docker/docker/pkg/term" ) const ( @@ -272,6 +275,56 @@ func (client *DockerClient) readJSONStream(stream io.ReadCloser, decode func(*js return resultChan } +func (client *DockerClient) ExecCreate(config *ExecConfig) (string, error) { + data, err := json.Marshal(config) + if err != nil { + return "", err + } + uri := fmt.Sprintf("/%s/containers/%s/exec", APIVersion, config.Container) + resp, err := client.doRequest("POST", uri, data, nil) + if err != nil { + return "", err + } + var createExecResp struct { + Id string + } + if err = json.Unmarshal(resp, &createExecResp); err != nil { + return "", err + } + return createExecResp.Id, nil +} + +func (client *DockerClient) ExecStart(id string, config *ExecConfig) error { + data, err := json.Marshal(config) + if err != nil { + return err + } + + uri := fmt.Sprintf("/%s/exec/%s/start", APIVersion, id) + if _, err := client.doRequest("POST", uri, data, nil); err != nil { + return err + } + + return nil +} + +func (client *DockerClient) ExecResize(id string, width, height int) error { + v := url.Values{} + + w := strconv.Itoa(width) + h := strconv.Itoa(height) + + v.Set("w", w) + v.Set("h", h) + + uri := fmt.Sprintf("/%s/exec/%s/resize?%s", APIVersion, id, v.Encode()) + if _, err := client.doRequest("POST", client.URL.String()+uri, nil, nil); err != nil { + return err + } + + return nil +} + func (client *DockerClient) StartContainer(id string, config *HostConfig) error { data, err := json.Marshal(config) if err != nil { @@ -475,11 +528,11 @@ func (client *DockerClient) Version() (*Version, error) { return version, nil } -func (client *DockerClient) PullImage(name string, auth *AuthConfig) error { +func (client *DockerClient) PullImage(name string, auth *AuthConfig, out ...io.Writer) (err error) { v := url.Values{} v.Set("fromImage", name) uri := fmt.Sprintf("/%s/images/create?%s", APIVersion, v.Encode()) - req, err := http.NewRequest("POST", client.URL.String()+uri, nil) + req, _ := http.NewRequest("POST", client.URL.String()+uri, nil) if auth != nil { encoded_auth, err := auth.encode() if err != nil { @@ -487,9 +540,10 @@ func (client *DockerClient) PullImage(name string, auth *AuthConfig) error { } req.Header.Add("X-Registry-Auth", encoded_auth) } - resp, err := client.HTTPClient.Do(req) + var resp *http.Response + resp, err = client.HTTPClient.Do(req) if err != nil { - return err + return } defer resp.Body.Close() @@ -504,16 +558,39 @@ func (client *DockerClient) PullImage(name string, auth *AuthConfig) error { return fmt.Errorf("%s", string(data)) } + errorReader := io.Reader(resp.Body) + var cliOut io.Writer + if len(out) > 0 { + cliOut = out[0] + } + if cliOut != nil { + pipeReader, pipeWriter := io.Pipe() + streamErrChan := make(chan error) + defer func() { + pipeWriter.Close() + if err == nil { + err = <-streamErrChan + } + }() + errorReader = io.TeeReader(resp.Body, pipeWriter) + go func() { + fd, isTerminalIn := term.GetFdInfo(cliOut) + streamErrChan <- jsonmessage.DisplayJSONMessagesStream(pipeReader, cliOut, fd, isTerminalIn) + }() + } var finalObj map[string]interface{} - for decoder := json.NewDecoder(resp.Body); err == nil; err = decoder.Decode(&finalObj) { + for decoder := json.NewDecoder(errorReader); err == nil; err = decoder.Decode(&finalObj) { } if err != io.EOF { - return err + return + } else { + err = nil } - if err, ok := finalObj["error"]; ok { - return fmt.Errorf("%v", err) + if errObj, ok := finalObj["error"]; ok { + err = fmt.Errorf("%v", errObj) + return } - return nil + return } func (client *DockerClient) InspectImage(id string) (*ImageInfo, error) { @@ -576,8 +653,14 @@ func (client *DockerClient) ListImages(all bool) ([]*Image, error) { return images, nil } -func (client *DockerClient) RemoveImage(name string) ([]*ImageDelete, error) { - uri := fmt.Sprintf("/%s/images/%s", APIVersion, name) +func (client *DockerClient) RemoveImage(name string, force bool) ([]*ImageDelete, error) { + argForce := 0 + if force { + argForce = 1 + } + + args := fmt.Sprintf("force=%d", argForce) + uri := fmt.Sprintf("/%s/images/%s?%s", APIVersion, name, args) data, err := client.doRequest("DELETE", uri, nil, nil) if err != nil { return nil, err @@ -606,30 +689,6 @@ func (client *DockerClient) UnpauseContainer(id string) error { return nil } -func (client *DockerClient) Exec(config *ExecConfig) (string, error) { - data, err := json.Marshal(config) - if err != nil { - return "", err - } - uri := fmt.Sprintf("/containers/%s/exec", config.Container) - resp, err := client.doRequest("POST", uri, data, nil) - if err != nil { - return "", err - } - var createExecResp struct { - Id string - } - if err = json.Unmarshal(resp, &createExecResp); err != nil { - return "", err - } - uri = fmt.Sprintf("/exec/%s/start", createExecResp.Id) - resp, err = client.doRequest("POST", uri, data, nil) - if err != nil { - return "", err - } - return createExecResp.Id, nil -} - func (client *DockerClient) RenameContainer(oldName string, newName string) error { uri := fmt.Sprintf("/containers/%s/rename?name=%s", oldName, newName) _, err := client.doRequest("POST", uri, nil, nil) @@ -712,3 +771,113 @@ func (client *DockerClient) BuildImage(image *BuildImage) (io.ReadCloser, error) uri := fmt.Sprintf("/%s/build?%s", APIVersion, v.Encode()) return client.doStreamRequest("POST", uri, image.Context, headers) } + +func (client *DockerClient) ListVolumes() ([]*Volume, error) { + uri := fmt.Sprintf("/%s/volumes", APIVersion) + data, err := client.doRequest("GET", uri, nil, nil) + if err != nil { + return nil, err + } + var volumesList VolumesListResponse + if err := json.Unmarshal(data, &volumesList); err != nil { + return nil, err + } + return volumesList.Volumes, nil +} + +func (client *DockerClient) RemoveVolume(name string) error { + uri := fmt.Sprintf("/%s/volumes/%s", APIVersion, name) + _, err := client.doRequest("DELETE", uri, nil, nil) + return err +} + +func (client *DockerClient) CreateVolume(request *VolumeCreateRequest) (*Volume, error) { + data, err := json.Marshal(request) + if err != nil { + return nil, err + } + uri := fmt.Sprintf("/%s/volumes", APIVersion) + data, err = client.doRequest("POST", uri, data, nil) + if err != nil { + return nil, err + } + volume := &Volume{} + err = json.Unmarshal(data, volume) + return volume, err +} + +func (client *DockerClient) ListNetworks(filters string) ([]*NetworkResource, error) { + uri := fmt.Sprintf("/%s/networks", APIVersion) + + if filters != "" { + uri += "&filters=" + filters + } + + data, err := client.doRequest("GET", uri, nil, nil) + if err != nil { + return nil, err + } + ret := []*NetworkResource{} + err = json.Unmarshal(data, &ret) + if err != nil { + return nil, err + } + return ret, nil +} + +func (client *DockerClient) InspectNetwork(id string) (*NetworkResource, error) { + uri := fmt.Sprintf("/%s/networks/%s", APIVersion, id) + + data, err := client.doRequest("GET", uri, nil, nil) + if err != nil { + return nil, err + } + ret := &NetworkResource{} + err = json.Unmarshal(data, ret) + if err != nil { + return nil, err + } + + return ret, nil +} + +func (client *DockerClient) CreateNetwork(config *NetworkCreate) (*NetworkCreateResponse, error) { + data, err := json.Marshal(config) + if err != nil { + return nil, err + } + uri := fmt.Sprintf("/%s/networks/create", APIVersion) + data, err = client.doRequest("POST", uri, data, nil) + if err != nil { + return nil, err + } + ret := &NetworkCreateResponse{} + err = json.Unmarshal(data, ret) + return ret, nil +} + +func (client *DockerClient) ConnectNetwork(id, container string) error { + data, err := json.Marshal(NetworkConnect{Container: container}) + if err != nil { + return err + } + uri := fmt.Sprintf("/%s/networks/%s/connect", APIVersion, id) + _, err = client.doRequest("POST", uri, data, nil) + return err +} + +func (client *DockerClient) DisconnectNetwork(id, container string) error { + data, err := json.Marshal(NetworkDisconnect{Container: container}) + if err != nil { + return err + } + uri := fmt.Sprintf("/%s/networks/%s/disconnect", APIVersion, id) + _, err = client.doRequest("POST", uri, data, nil) + return err +} + +func (client *DockerClient) RemoveNetwork(id string) error { + uri := fmt.Sprintf("/%s/networks/%s", APIVersion, id) + _, err := client.doRequest("DELETE", uri, nil, nil) + return err +} diff --git a/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient_test.go b/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient_test.go index 88257e01b..1ca0be3f0 100644 --- a/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient_test.go +++ b/Godeps/_workspace/src/github.com/samalba/dockerclient/dockerclient_test.go @@ -5,6 +5,7 @@ import ( "encoding/json" "fmt" "io" + "os" "reflect" "strings" "testing" @@ -31,6 +32,16 @@ func testDockerClient(t *testing.T) *DockerClient { return client } +func ExampleDockerClient_PullImage() { + docker, err := NewDockerClient("unix:///var/run/docker.sock", nil) + if err != nil { + panic(err) + } + if err := docker.PullImage("busybox", nil, os.Stdout); err != nil { + panic(err) + } +} + func TestInfo(t *testing.T) { client := testDockerClient(t) info, err := client.Info() @@ -70,14 +81,14 @@ func TestWait(t *testing.T) { func TestPullImage(t *testing.T) { client := testDockerClient(t) - err := client.PullImage("busybox", nil) + err := client.PullImage("busybox", nil) // old clients do not break on the API change if err != nil { - t.Fatal("unable to pull busybox") + t.Fatal("unable to pull busybox: %v", err) } - err = client.PullImage("haproxy", nil) + err = client.PullImage("haproxy", nil, os.Stderr) // io.Writer is optional if err != nil { - t.Fatal("unable to pull haproxy") + t.Fatal("unable to pull haproxy: %v", err) } err = client.PullImage("wrongimg", nil) @@ -119,6 +130,7 @@ func TestListContainersWithSize(t *testing.T) { cnt := containers[0] assertEqual(t, cnt.SizeRw, int64(123), "") } + func TestListContainersWithFilters(t *testing.T) { client := testDockerClient(t) containers, err := client.ListContainers(true, true, "{'id':['332375cfbc23edb921a21026314c3497674ba8bdcb2c85e0e65ebf2017f688ce']}") diff --git a/Godeps/_workspace/src/github.com/samalba/dockerclient/interface.go b/Godeps/_workspace/src/github.com/samalba/dockerclient/interface.go index 8a4881193..c67c9a336 100644 --- a/Godeps/_workspace/src/github.com/samalba/dockerclient/interface.go +++ b/Godeps/_workspace/src/github.com/samalba/dockerclient/interface.go @@ -16,7 +16,9 @@ type Client interface { CreateContainer(config *ContainerConfig, name string) (string, error) ContainerLogs(id string, options *LogOptions) (io.ReadCloser, error) ContainerChanges(id string) ([]*ContainerChanges, error) - Exec(config *ExecConfig) (string, error) + ExecCreate(config *ExecConfig) (string, error) + ExecStart(id string, config *ExecConfig) error + ExecResize(id string, width, height int) error StartContainer(id string, config *HostConfig) error StopContainer(id string, timeout int) error RestartContainer(id string, timeout int) error @@ -33,14 +35,23 @@ type Client interface { StopAllMonitorStats() TagImage(nameOrID string, repo string, tag string, force bool) error Version() (*Version, error) - PullImage(name string, auth *AuthConfig) error + PullImage(name string, auth *AuthConfig, out ...io.Writer) error LoadImage(reader io.Reader) error RemoveContainer(id string, force, volumes bool) error ListImages(all bool) ([]*Image, error) - RemoveImage(name string) ([]*ImageDelete, error) + RemoveImage(name string, force bool) ([]*ImageDelete, error) PauseContainer(name string) error UnpauseContainer(name string) error RenameContainer(oldName string, newName string) error ImportImage(source string, repository string, tag string, tar io.Reader) (io.ReadCloser, error) BuildImage(image *BuildImage) (io.ReadCloser, error) + ListVolumes() ([]*Volume, error) + RemoveVolume(name string) error + CreateVolume(request *VolumeCreateRequest) (*Volume, error) + ListNetworks(filters string) ([]*NetworkResource, error) + InspectNetwork(id string) (*NetworkResource, error) + CreateNetwork(config *NetworkCreate) (*NetworkCreateResponse, error) + ConnectNetwork(id, container string) error + DisconnectNetwork(id, container string) error + RemoveNetwork(id string) error } diff --git a/Godeps/_workspace/src/github.com/samalba/dockerclient/mockclient/mock.go b/Godeps/_workspace/src/github.com/samalba/dockerclient/mockclient/mock.go index ff982663a..1b8095484 100644 --- a/Godeps/_workspace/src/github.com/samalba/dockerclient/mockclient/mock.go +++ b/Godeps/_workspace/src/github.com/samalba/dockerclient/mockclient/mock.go @@ -106,8 +106,8 @@ func (client *MockClient) Version() (*dockerclient.Version, error) { return args.Get(0).(*dockerclient.Version), args.Error(1) } -func (client *MockClient) PullImage(name string, auth *dockerclient.AuthConfig) error { - args := client.Mock.Called(name, auth) +func (client *MockClient) PullImage(name string, auth *dockerclient.AuthConfig, out ...io.Writer) error { + args := client.Mock.Called(name, auth, out...) return args.Error(0) } @@ -126,8 +126,8 @@ func (client *MockClient) ListImages(all bool) ([]*dockerclient.Image, error) { return args.Get(0).([]*dockerclient.Image), args.Error(1) } -func (client *MockClient) RemoveImage(name string) ([]*dockerclient.ImageDelete, error) { - args := client.Mock.Called(name) +func (client *MockClient) RemoveImage(name string, force bool) ([]*dockerclient.ImageDelete, error) { + args := client.Mock.Called(name, force) return args.Get(0).([]*dockerclient.ImageDelete), args.Error(1) } @@ -141,11 +141,21 @@ func (client *MockClient) UnpauseContainer(name string) error { return args.Error(0) } -func (client *MockClient) Exec(config *dockerclient.ExecConfig) (string, error) { +func (client *MockClient) ExecCreate(config *dockerclient.ExecConfig) (string, error) { args := client.Mock.Called(config) return args.String(0), args.Error(1) } +func (client *MockClient) ExecStart(id string, config *dockerclient.ExecConfig) error { + args := client.Mock.Called(id, config) + return args.Error(0) +} + +func (client *MockClient) ExecResize(id string, width, height int) error { + args := client.Mock.Called(id, width, height) + return args.Error(0) +} + func (client *MockClient) RenameContainer(oldName string, newName string) error { args := client.Mock.Called(oldName, newName) return args.Error(0) @@ -160,3 +170,48 @@ func (client *MockClient) BuildImage(image *dockerclient.BuildImage) (io.ReadClo args := client.Mock.Called(image) return args.Get(0).(io.ReadCloser), args.Error(1) } + +func (client *MockClient) ListVolumes() ([]*dockerclient.Volume, error) { + args := client.Mock.Called() + return args.Get(0).([]*dockerclient.Volume), args.Error(1) +} + +func (client *MockClient) RemoveVolume(name string) error { + args := client.Mock.Called(name) + return args.Error(0) +} + +func (client *MockClient) CreateVolume(request *dockerclient.VolumeCreateRequest) (*dockerclient.Volume, error) { + args := client.Mock.Called(request) + return args.Get(0).(*dockerclient.Volume), args.Error(1) +} + +func (client *MockClient) ListNetworks(filters string) ([]*dockerclient.NetworkResource, error) { + args := client.Mock.Called(filters) + return args.Get(0).([]*dockerclient.NetworkResource), args.Error(1) +} + +func (client *MockClient) InspectNetwork(id string) (*dockerclient.NetworkResource, error) { + args := client.Mock.Called(id) + return args.Get(0).(*dockerclient.NetworkResource), args.Error(1) +} + +func (client *MockClient) CreateNetwork(config *dockerclient.NetworkCreate) (*dockerclient.NetworkCreateResponse, error) { + args := client.Mock.Called(config) + return args.Get(0).(*dockerclient.NetworkCreateResponse), args.Error(1) +} + +func (client *MockClient) ConnectNetwork(id, container string) error { + args := client.Mock.Called(id, container) + return args.Error(0) +} + +func (client *MockClient) DisconnectNetwork(id, container string) error { + args := client.Mock.Called(id, container) + return args.Error(0) +} + +func (client *MockClient) RemoveNetwork(id string) error { + args := client.Mock.Called(id) + return args.Error(0) +} diff --git a/Godeps/_workspace/src/github.com/samalba/dockerclient/nopclient/nop.go b/Godeps/_workspace/src/github.com/samalba/dockerclient/nopclient/nop.go new file mode 100644 index 000000000..7083b77fa --- /dev/null +++ b/Godeps/_workspace/src/github.com/samalba/dockerclient/nopclient/nop.go @@ -0,0 +1,183 @@ +package nopclient + +import ( + "errors" + "io" + + "github.com/samalba/dockerclient" +) + +var ( + ErrNoEngine = errors.New("Engine no longer exists") +) + +type NopClient struct { +} + +func NewNopClient() *NopClient { + return &NopClient{} +} + +func (client *NopClient) Info() (*dockerclient.Info, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) ListContainers(all bool, size bool, filters string) ([]dockerclient.Container, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) InspectContainer(id string) (*dockerclient.ContainerInfo, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) InspectImage(id string) (*dockerclient.ImageInfo, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) CreateContainer(config *dockerclient.ContainerConfig, name string) (string, error) { + return "", ErrNoEngine +} + +func (client *NopClient) ContainerLogs(id string, options *dockerclient.LogOptions) (io.ReadCloser, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) ContainerChanges(id string) ([]*dockerclient.ContainerChanges, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) StartContainer(id string, config *dockerclient.HostConfig) error { + return ErrNoEngine +} + +func (client *NopClient) StopContainer(id string, timeout int) error { + return ErrNoEngine +} + +func (client *NopClient) RestartContainer(id string, timeout int) error { + return ErrNoEngine +} + +func (client *NopClient) KillContainer(id, signal string) error { + return ErrNoEngine +} + +func (client *NopClient) Wait(id string) <-chan dockerclient.WaitResult { + return nil +} + +func (client *NopClient) MonitorEvents(options *dockerclient.MonitorEventsOptions, stopChan <-chan struct{}) (<-chan dockerclient.EventOrError, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) StartMonitorEvents(cb dockerclient.Callback, ec chan error, args ...interface{}) { + return +} + +func (client *NopClient) StopAllMonitorEvents() { + return +} + +func (client *NopClient) TagImage(nameOrID string, repo string, tag string, force bool) error { + return ErrNoEngine +} + +func (client *NopClient) StartMonitorStats(id string, cb dockerclient.StatCallback, ec chan error, args ...interface{}) { + return +} + +func (client *NopClient) StopAllMonitorStats() { + return +} + +func (client *NopClient) Version() (*dockerclient.Version, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) PullImage(name string, auth *dockerclient.AuthConfig, out ...io.Writer) error { + return ErrNoEngine +} + +func (client *NopClient) LoadImage(reader io.Reader) error { + return ErrNoEngine +} + +func (client *NopClient) RemoveContainer(id string, force, volumes bool) error { + return ErrNoEngine +} + +func (client *NopClient) ListImages(all bool) ([]*dockerclient.Image, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) RemoveImage(name string, force bool) ([]*dockerclient.ImageDelete, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) PauseContainer(name string) error { + return ErrNoEngine +} + +func (client *NopClient) UnpauseContainer(name string) error { + return ErrNoEngine +} + +func (client *NopClient) ExecCreate(config *dockerclient.ExecConfig) (string, error) { + return "", ErrNoEngine +} + +func (client *NopClient) ExecStart(id string, config *dockerclient.ExecConfig) error { + return ErrNoEngine +} + +func (client *NopClient) ExecResize(id string, width, height int) error { + return ErrNoEngine +} + +func (client *NopClient) RenameContainer(oldName string, newName string) error { + return ErrNoEngine +} + +func (client *NopClient) ImportImage(source string, repository string, tag string, tar io.Reader) (io.ReadCloser, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) BuildImage(image *dockerclient.BuildImage) (io.ReadCloser, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) ListVolumes() ([]*dockerclient.Volume, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) RemoveVolume(name string) error { + return ErrNoEngine +} + +func (client *NopClient) CreateVolume(request *dockerclient.VolumeCreateRequest) (*dockerclient.Volume, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) ListNetworks(filters string) ([]*dockerclient.NetworkResource, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) InspectNetwork(id string) (*dockerclient.NetworkResource, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) CreateNetwork(config *dockerclient.NetworkCreate) (*dockerclient.NetworkCreateResponse, error) { + return nil, ErrNoEngine +} + +func (client *NopClient) ConnectNetwork(id, container string) error { + return ErrNoEngine +} + +func (client *NopClient) DisconnectNetwork(id, container string) error { + return ErrNoEngine +} + +func (client *NopClient) RemoveNetwork(id string) error { + return ErrNoEngine +} diff --git a/Godeps/_workspace/src/github.com/samalba/dockerclient/types.go b/Godeps/_workspace/src/github.com/samalba/dockerclient/types.go index 15e1e8bcd..b1f5a006c 100644 --- a/Godeps/_workspace/src/github.com/samalba/dockerclient/types.go +++ b/Godeps/_workspace/src/github.com/samalba/dockerclient/types.go @@ -272,7 +272,9 @@ type RespContainersCreate struct { type Image struct { Created int64 Id string + Labels map[string]string ParentId string + RepoDigests []string RepoTags []string Size int64 VirtualSize int64 @@ -442,3 +444,60 @@ type BuildImage struct { CpuSetMems string CgroupParent string } + +type Volume struct { + Name string // Name is the name of the volume + Driver string // Driver is the Driver name used to create the volume + Mountpoint string // Mountpoint is the location on disk of the volume +} + +type VolumesListResponse struct { + Volumes []*Volume // Volumes is the list of volumes being returned +} + +type VolumeCreateRequest struct { + Name string // Name is the requested name of the volume + Driver string // Driver is the name of the driver that should be used to create the volume + DriverOpts map[string]string // DriverOpts holds the driver specific options to use for when creating the volume. +} + +// NetworkResource is the body of the "get network" http response message +type NetworkResource struct { + Name string `json:"name"` + ID string `json:"id"` + Driver string `json:"driver"` + Containers map[string]EndpointResource `json:"containers"` + Options map[string]interface{} `json:"options,omitempty"` +} + +//EndpointResource contains network resources allocated and usd for a container in a network +type EndpointResource struct { + EndpointID string `json:"endpoint"` + MacAddress string `json:"mac_address"` + IPv4Address string `json:"ipv4_address"` + IPv6Address string `json:"ipv6_address"` +} + +// NetworkCreate is the expected body of the "create network" http request message +type NetworkCreate struct { + Name string `json:"name"` + CheckDuplicate bool `json:"check_duplicate"` + Driver string `json:"driver"` + Options map[string]interface{} `json:"options"` +} + +// NetworkCreateResponse is the response message sent by the server for network create call +type NetworkCreateResponse struct { + ID string `json:"id"` + Warning string `json:"warning"` +} + +// NetworkConnect represents the data to be used to connect a container to the network +type NetworkConnect struct { + Container string `json:"container"` +} + +// NetworkDisconnect represents the data to be used to disconnect a container from the network +type NetworkDisconnect struct { + Container string `json:"container"` +}