docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1982 from MHBauer/apiClient-rmi 

use apiClient for various things
This commit is contained in:
Nishant Totla 2016-03-29 16:11:01 -07:00
parent 0b50dbd503 4516d1ae16
commit 2e9daede48
11 changed files with 133 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
api/handlers.go
View File

@ -268,7 +268,7 @@ func getNetworks(c *context, w http.ResponseWriter, r *http.Request) {
}
}
out := []*dockerclient.NetworkResource{}
out := []*apitypes.NetworkResource{}
networks := c.cluster.Networks().Filter(filters.Get("name"), filters.Get("id"), types)
for _, network := range networks {
tmp := (*network).NetworkResource
@ -308,7 +308,7 @@ func getVolume(c *context, w http.ResponseWriter, r *http.Request) {
// GET /volumes
func getVolumes(c *context, w http.ResponseWriter, r *http.Request) {
volumes := struct{ Volumes []*dockerclient.Volume }{}
volumes := struct{ Volumes []*apitypes.Volume }{}
for _, volume := range c.cluster.Volumes() {
tmp := (*volume).Volume
@ -613,7 +613,7 @@ func postNetworksCreate(c *context, w http.ResponseWriter, r *http.Request) {
// POST /volumes/create
func postVolumesCreate(c *context, w http.ResponseWriter, r *http.Request) {
var request dockerclient.VolumeCreateRequest
var request apitypes.VolumeCreateRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
httpError(w, err.Error(), http.StatusBadRequest)

4
cluster/cluster.go
View File

@ -22,7 +22,7 @@ type Cluster interface {
Image(IDOrName string) *Image
// Remove images from the cluster
RemoveImages(name string, force bool) ([]*dockerclient.ImageDelete, error)
RemoveImages(name string, force bool) ([]types.ImageDelete, error)
// Return all containers
Containers() Containers
@ -45,7 +45,7 @@ type Cluster interface {
RemoveNetwork(network *Network) error
// Create a volume
CreateVolume(request *dockerclient.VolumeCreateRequest) (*Volume, error)
CreateVolume(request *types.VolumeCreateRequest) (*Volume, error)
// Return all volumes
Volumes() Volumes

28
cluster/engine.go
View File

@ -19,6 +19,7 @@ import (
"github.com/docker/docker/pkg/version"
engineapi "github.com/docker/engine-api/client"
"github.com/docker/engine-api/types"
"github.com/docker/engine-api/types/filters"
engineapinop "github.com/docker/swarm/api/nopclient"
"github.com/samalba/dockerclient"
"github.com/samalba/dockerclient/nopclient"
@ -477,17 +478,17 @@ func (e *Engine) updateSpecs() error {
}
// RemoveImage deletes an image from the engine.
func (e *Engine) RemoveImage(image *Image, name string, force bool) ([]*dockerclient.ImageDelete, error) {
array, err := e.client.RemoveImage(name, force)
func (e *Engine) RemoveImage(name string, force bool) ([]types.ImageDelete, error) {
rmOpts := types.ImageRemoveOptions{name, force, true}
dels, err := e.apiClient.ImageRemove(context.TODO(), rmOpts)
e.CheckConnectionErr(err)
e.RefreshImages()
return array, err
return dels, err
}
// RemoveNetwork removes a network from the engine.
func (e *Engine) RemoveNetwork(network *Network) error {
err := e.client.RemoveNetwork(network.ID)
err := e.apiClient.NetworkRemove(context.TODO(), network.ID)
e.CheckConnectionErr(err)
if err != nil {
return err
@ -518,7 +519,7 @@ func (e *Engine) AddNetwork(network *Network) {
// RemoveVolume deletes a volume from the engine.
func (e *Engine) RemoveVolume(name string) error {
err := e.client.RemoveVolume(name)
err := e.apiClient.VolumeRemove(context.TODO(), name)
e.CheckConnectionErr(err)
if err != nil {
return err
@ -551,7 +552,8 @@ func (e *Engine) RefreshImages() error {
// RefreshNetworks refreshes the list of networks on the engine.
func (e *Engine) RefreshNetworks() error {
networks, err := e.client.ListNetworks("")
netLsOpts := types.NetworkListOptions{filters.NewArgs()}
networks, err := e.apiClient.NetworkList(context.TODO(), netLsOpts)
e.CheckConnectionErr(err)
if err != nil {
return err
@ -559,7 +561,7 @@ func (e *Engine) RefreshNetworks() error {
e.Lock()
e.networks = make(map[string]*Network)
for _, network := range networks {
e.networks[network.ID] = &Network{NetworkResource: *network, Engine: e}
e.networks[network.ID] = &Network{NetworkResource: network, Engine: e}
}
e.Unlock()
return nil
@ -567,14 +569,14 @@ func (e *Engine) RefreshNetworks() error {
// RefreshVolumes refreshes the list of volumes on the engine.
func (e *Engine) RefreshVolumes() error {
volumes, err := e.client.ListVolumes()
volumesLsRsp, err := e.apiClient.VolumeList(context.TODO(), filters.NewArgs())
e.CheckConnectionErr(err)
if err != nil {
return err
}
e.Lock()
e.volumes = make(map[string]*Volume)
for _, volume := range volumes {
for _, volume := range volumesLsRsp.Volumes {
e.volumes[volume.Name] = &Volume{Volume: *volume, Engine: e}
}
e.Unlock()
@ -885,8 +887,8 @@ func (e *Engine) CreateNetwork(request *dockerclient.NetworkCreate) (*dockerclie
}
// CreateVolume creates a volume in the engine
func (e *Engine) CreateVolume(request *dockerclient.VolumeCreateRequest) (*Volume, error) {
volume, err := e.client.CreateVolume(request)
func (e *Engine) CreateVolume(request *types.VolumeCreateRequest) (*Volume, error) {
volume, err := e.apiClient.VolumeCreate(context.TODO(), *request)
e.RefreshVolumes()
e.CheckConnectionErr(err)
@ -894,7 +896,7 @@ func (e *Engine) CreateVolume(request *dockerclient.VolumeCreateRequest) (*Volum
if err != nil {
return nil, err
}
return &Volume{Volume: *volume, Engine: e}, nil
return &Volume{Volume: volume, Engine: e}, nil
}

83
cluster/engine_test.go
View File

@ -7,6 +7,8 @@ import (
"testing"
"time"
"golang.org/x/net/context"
engineapi "github.com/docker/engine-api/client"
"github.com/docker/engine-api/types"
engineapimock "github.com/docker/swarm/api/mockclient"
@ -156,10 +158,14 @@ func TestEngineCpusMemory(t *testing.T) {
apiClient := engineapimock.NewMockClient()
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything,
mock.AnythingOfType("Args"),
).Return(types.VolumesListResponse{}, nil)
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil)
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil)
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
assert.NoError(t, engine.ConnectWithClient(client, apiClient))
@ -182,10 +188,14 @@ func TestEngineSpecs(t *testing.T) {
apiClient := engineapimock.NewMockClient()
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything,
mock.AnythingOfType("Args"),
).Return(types.VolumesListResponse{}, nil)
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil)
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil)
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
assert.NoError(t, engine.ConnectWithClient(client, apiClient))
@ -213,13 +223,17 @@ func TestEngineState(t *testing.T) {
apiClient := engineapimock.NewMockClient()
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything,
mock.AnythingOfType("Args"),
).Return(types.VolumesListResponse{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
// The client will return one container at first, then a second one will appear.
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{{Id: "one"}}, nil).Once()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil).Once()
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("InspectContainer", "one").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: 100}}, nil).Once()
client.On("ListContainers", true, false, fmt.Sprintf("{%q:[%q]}", "id", "two")).Return([]dockerclient.Container{{Id: "two"}}, nil).Once()
client.On("InspectContainer", "two").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: 100}}, nil).Once()
@ -265,11 +279,15 @@ func TestCreateContainer(t *testing.T) {
engine.setState(stateUnhealthy)
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything,
mock.AnythingOfType("Args"),
).Return(types.VolumesListResponse{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil).Once()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil).Once()
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
assert.NoError(t, engine.ConnectWithClient(client, apiClient))
assert.True(t, engine.isConnected())
@ -285,8 +303,6 @@ func TestCreateContainer(t *testing.T) {
client.On("CreateContainer", &mockConfig, name, auth).Return(id, nil).Once()
client.On("ListContainers", true, false, fmt.Sprintf(`{"id":[%q]}`, id)).Return([]dockerclient.Container{{Id: id}}, nil).Once()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil).Once()
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("InspectContainer", id).Return(&dockerclient.ContainerInfo{Config: &config.ContainerConfig}, nil).Once()
container, err := engine.Create(config, name, false, auth)
assert.Nil(t, err)
@ -310,8 +326,6 @@ func TestCreateContainer(t *testing.T) {
client.On("CreateContainer", &mockConfig, name, auth).Return(id, nil).Once()
client.On("ListContainers", true, false, fmt.Sprintf(`{"id":[%q]}`, id)).Return([]dockerclient.Container{{Id: id}}, nil).Once()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil).Once()
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("InspectContainer", id).Return(&dockerclient.ContainerInfo{Config: &config.ContainerConfig}, nil).Once()
container, err = engine.Create(config, name, true, auth)
assert.Nil(t, err)
@ -371,11 +385,15 @@ func TestUsedCpus(t *testing.T) {
apiClient.On("Info", mock.Anything).Return(mockInfo, nil).Once()
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything,
mock.AnythingOfType("Args"),
).Return(types.VolumesListResponse{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil).Once()
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{{Id: "test"}}, nil).Once()
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("InspectContainer", "test").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: cpuShares}}, nil).Once()
engine.ConnectWithClient(client, apiClient)
@ -405,11 +423,15 @@ func TestContainerRemovedDuringRefresh(t *testing.T) {
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything,
mock.AnythingOfType("Args"),
).Return(types.VolumesListResponse{}, nil)
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{container1, container2}, nil)
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("InspectContainer", "c1").Return(info1, errors.New("Not found"))
client.On("InspectContainer", "c2").Return(info2, nil)
@ -433,14 +455,18 @@ func TestDisconnect(t *testing.T) {
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything,
mock.AnythingOfType("Args"),
).Return(types.VolumesListResponse{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
client.On("StopAllMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
// The client will return one container at first, then a second one will appear.
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{{Id: "one"}}, nil).Once()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil).Once()
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
client.On("InspectContainer", "one").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: 100}}, nil).Once()
client.On("ListContainers", true, false, fmt.Sprintf("{%q:[%q]}", "id", "two")).Return([]dockerclient.Container{{Id: "two"}}, nil).Once()
client.On("InspectContainer", "two").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: 100}}, nil).Once()
@ -460,3 +486,24 @@ func TestDisconnect(t *testing.T) {
// Double disconnect shouldn't cause panic
engine.Disconnect()
}
func TestRemoveImage(t *testing.T) {
engine := NewEngine("test", 0, engOpts)
imageName := "test-image"
dIs := []types.ImageDelete{{Deleted: imageName}}
apiClient := engineapimock.NewMockClient()
apiClient.On("ImageRemove", context.TODO(),
mock.AnythingOfType("ImageRemoveOptions")).Return(dIs, nil)
engine.apiClient = apiClient
deletedImages, err := engine.RemoveImage("test-image", true)
if err != nil {
t.Errorf("encountered an unexpected error")
}
if deletedImages[0].Deleted != imageName {
t.Errorf("didn't get the image we removed")
}
apiClient.Mock.AssertExpectations(t)
}

6
cluster/mesos/cluster.go
View File

@ -249,7 +249,7 @@ func (c *Cluster) Image(IDOrName string) *cluster.Image {
}
// RemoveImages removes images from the cluster
func (c *Cluster) RemoveImages(name string, force bool) ([]*dockerclient.ImageDelete, error) {
func (c *Cluster) RemoveImages(name string, force bool) ([]types.ImageDelete, error) {
return nil, errNotSupported
}
@ -299,7 +299,7 @@ func (c *Cluster) refreshNetworks() {
}
// CreateVolume creates a volume in the cluster
func (c *Cluster) CreateVolume(request *dockerclient.VolumeCreateRequest) (*cluster.Volume, error) {
func (c *Cluster) CreateVolume(request *types.VolumeCreateRequest) (*cluster.Volume, error) {
return nil, errNotSupported
}
@ -358,7 +358,7 @@ func (c *Cluster) Container(IDOrName string) *cluster.Container {
}
// RemoveImage removes an image from the cluster
func (c *Cluster) RemoveImage(image *cluster.Image) ([]*dockerclient.ImageDelete, error) {
func (c *Cluster) RemoveImage(image *cluster.Image) ([]types.ImageDelete, error) {
return nil, errNotSupported
}

6
cluster/network.go
View File

@ -4,12 +4,12 @@ import (
"strings"
"github.com/docker/docker/pkg/stringid"
"github.com/samalba/dockerclient"
"github.com/docker/engine-api/types"
)
// Network is exported
type Network struct {
dockerclient.NetworkResource
types.NetworkResource
Engine *Engine
}
@ -98,7 +98,7 @@ func (network *Network) RemoveDuplicateEndpoints() *Network {
// Make a copy of the network
netCopy := *network
// clean up existing endpoints
netCopy.Containers = make(map[string]dockerclient.EndpointResource)
netCopy.Containers = make(map[string]types.EndpointResource)
// add the endpoint index from endpointMap
for _, index := range endpointMap {
netCopy.Containers[index] = network.Containers[index]

30
cluster/network_test.go
View File

@ -3,26 +3,26 @@ package cluster
import (
"testing"
"github.com/samalba/dockerclient"
"github.com/docker/engine-api/types"
"github.com/stretchr/testify/assert"
)
func TestNetworksFilter(t *testing.T) {
engine := &Engine{ID: "id"}
networks := Networks{
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "ababababab",
Name: "something",
}, engine},
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "aaaaaaaaaa1",
Name: "network_name",
}, engine},
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "bbbbbbbbbb",
Name: "somethingelse",
}, engine},
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "aaaaaaaaa2",
Name: "foo",
}, engine},
@ -39,31 +39,31 @@ func TestNetworkUniq(t *testing.T) {
engine1 := &Engine{ID: "id1"}
engine2 := &Engine{ID: "id2"}
networks := Networks{
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "global",
Name: "global",
Containers: map[string]dockerclient.EndpointResource{
Containers: map[string]types.EndpointResource{
"c1": {},
},
}, engine1},
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "global",
Name: "global",
Containers: map[string]dockerclient.EndpointResource{
Containers: map[string]types.EndpointResource{
"c2": {},
},
}, engine2},
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "local1",
Name: "local",
Containers: map[string]dockerclient.EndpointResource{
Containers: map[string]types.EndpointResource{
"c3": {},
},
}, engine1},
{dockerclient.NetworkResource{
{types.NetworkResource{
ID: "local2",
Name: "local",
Containers: map[string]dockerclient.EndpointResource{
Containers: map[string]types.EndpointResource{
"c4": {},
},
}, engine2},
@ -84,10 +84,10 @@ func TestNetworkUniq(t *testing.T) {
func TestRemoveDuplicateEndpoints(t *testing.T) {
engine1 := &Engine{ID: "id1"}
network := Network{
dockerclient.NetworkResource{
types.NetworkResource{
ID: "global",
Name: "voteappbase_voteapp",
Containers: map[string]dockerclient.EndpointResource{
Containers: map[string]types.EndpointResource{
"028771f7f6a54c486d441ecfc92aad68e0836a1f0a5a0c227c514f14848e2b54": {
Name: "voteappbase_worker_1",
EndpointID: "49f621862a0659f462870a6cd15874da44592e399f41da2a3019d81b7427315b",

8
cluster/swarm/cluster.go
View File

@ -419,17 +419,17 @@ func (c *Cluster) Image(IDOrName string) *cluster.Image {
}
// RemoveImages removes all the images that match `name` from the cluster
func (c *Cluster) RemoveImages(name string, force bool) ([]*dockerclient.ImageDelete, error) {
func (c *Cluster) RemoveImages(name string, force bool) ([]types.ImageDelete, error) {
c.Lock()
defer c.Unlock()
out := []*dockerclient.ImageDelete{}
out := []types.ImageDelete{}
errs := []string{}
var err error
for _, e := range c.engines {
for _, image := range e.Images() {
if image.Match(name, true) {
content, err := image.Engine.RemoveImage(image, name, force)
content, err := image.Engine.RemoveImage(name, force)
if err != nil {
errs = append(errs, fmt.Sprintf("%s: %s", image.Engine.Name, err.Error()))
continue
@ -492,7 +492,7 @@ func (c *Cluster) CreateNetwork(request *dockerclient.NetworkCreate) (response *
}
// CreateVolume creates a volume in the cluster
func (c *Cluster) CreateVolume(request *dockerclient.VolumeCreateRequest) (*cluster.Volume, error) {
func (c *Cluster) CreateVolume(request *types.VolumeCreateRequest) (*cluster.Volume, error) {
var (
wg sync.WaitGroup
volume *cluster.Volume

18
cluster/swarm/cluster_test.go
View File

@ -137,11 +137,13 @@ func TestImportImage(t *testing.T) {
apiClient := engineapimock.NewMockClient()
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything, mock.Anything).Return(types.VolumesListResponse{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil).Once()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil)
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
// connect client
engine.ConnectWithClient(client, apiClient)
@ -188,11 +190,13 @@ func TestLoadImage(t *testing.T) {
apiClient := engineapimock.NewMockClient()
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything, mock.Anything).Return(types.VolumesListResponse{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil).Once()
client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil)
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
// connect client
engine.ConnectWithClient(client, apiClient)
@ -242,11 +246,13 @@ func TestTagImage(t *testing.T) {
apiClient := engineapimock.NewMockClient()
apiClient.On("Info", mock.Anything).Return(mockInfo, nil)
apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil)
apiClient.On("NetworkList", mock.Anything,
mock.AnythingOfType("NetworkListOptions"),
).Return([]types.NetworkResource{}, nil)
apiClient.On("VolumeList", mock.Anything, mock.Anything).Return(types.VolumesListResponse{}, nil)
client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return()
client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil).Once()
client.On("ListImages", mock.Anything).Return(images, nil)
client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil)
client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil)
// connect client
engine.ConnectWithClient(client, apiClient)

4
cluster/volume.go
View File

@ -1,10 +1,10 @@
package cluster
import "github.com/samalba/dockerclient"
import "github.com/docker/engine-api/types"
// Volume is exported
type Volume struct {
dockerclient.Volume
types.Volume
Engine *Engine
}

18
cluster/volume_test.go
View File

@ -3,7 +3,7 @@ package cluster
import (
"testing"
"github.com/samalba/dockerclient"
"github.com/docker/engine-api/types"
"github.com/stretchr/testify/assert"
)
@ -16,56 +16,56 @@ func TestGet(t *testing.T) {
}
volumes := Volumes{
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t1",
Driver: "local",
},
Engine: engines[0],
},
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t2",
Driver: "local",
},
Engine: engines[0],
},
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t3",
Driver: "rexray",
},
Engine: engines[0],
},
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t4",
Driver: "flocker",
},
Engine: engines[0],
},
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t1",
Driver: "local",
},
Engine: engines[1],
},
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t2",
Driver: "local",
},
Engine: engines[1],
},
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t3",
Driver: "rexray",
},
Engine: engines[1],
},
&Volume{
Volume: dockerclient.Volume{
Volume: types.Volume{
Name: "t4",
Driver: "flocker",
},