Refactoring & renaming

container/client.go

@@ -0,0 +1,165 @@
+package container
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/samalba/dockerclient"
+)
+
+const (
+	defaultStopSignal = "SIGTERM"
+	signalLabel       = "com.centurylinklabs.watchtower.stop-signal"
+)
+
+var (
+	pullImages bool
+)
+
+func init() {
+	pullImages = true
+}
+
+type ContainerFilter func(Container) bool
+
+type Client interface {
+	ListContainers(ContainerFilter) ([]Container, error)
+	RefreshImage(*Container) error
+	Stop(Container, time.Duration) error
+	Start(Container) error
+	Rename(Container, string) error
+}
+
+func NewClient() Client {
+	docker, err := dockerclient.NewDockerClient("unix:///var/run/docker.sock", nil)
+
+	if err != nil {
+		log.Fatalf("Error instantiating Docker client: %s\n", err)
+	}
+
+	return DockerClient{api: docker}
+}
+
+type DockerClient struct {
+	api dockerclient.Client
+}
+
+func (client DockerClient) ListContainers(fn ContainerFilter) ([]Container, error) {
+	cs := []Container{}
+
+	runningContainers, err := client.api.ListContainers(false, false, "")
+	if err != nil {
+		return nil, err
+	}
+
+	for _, runningContainer := range runningContainers {
+		containerInfo, err := client.api.InspectContainer(runningContainer.Id)
+		if err != nil {
+			return nil, err
+		}
+
+		imageInfo, err := client.api.InspectImage(containerInfo.Image)
+		if err != nil {
+			return nil, err
+		}
+
+		c := Container{containerInfo: containerInfo, imageInfo: imageInfo}
+		if fn(c) {
+			cs = append(cs, Container{containerInfo: containerInfo, imageInfo: imageInfo})
+		}
+	}
+
+	return cs, nil
+}
+
+func (client DockerClient) RefreshImage(c *Container) error {
+	containerInfo := c.containerInfo
+	oldImageInfo := c.imageInfo
+	imageName := containerInfo.Config.Image
+
+	if pullImages {
+		if !strings.Contains(imageName, ":") {
+			imageName = fmt.Sprintf("%s:latest", imageName)
+		}
+
+		log.Printf("Pulling %s for %s\n", imageName, c.Name())
+		if err := client.api.PullImage(imageName, nil); err != nil {
+			return err
+		}
+	}
+
+	newImageInfo, err := client.api.InspectImage(imageName)
+	if err != nil {
+		return err
+	}
+
+	if newImageInfo.Id != oldImageInfo.Id {
+		log.Printf("Found new %s image (%s)\n", imageName, newImageInfo.Id)
+		c.Stale = true
+	}
+
+	return nil
+}
+
+func (client DockerClient) Stop(c Container, timeout time.Duration) error {
+	signal := defaultStopSignal
+
+	if sig, ok := c.containerInfo.Config.Labels[signalLabel]; ok {
+		signal = sig
+	}
+
+	log.Printf("Stopping: %s\n", c.Name())
+
+	if err := client.api.KillContainer(c.containerInfo.Id, signal); err != nil {
+		return err
+	}
+
+	// Wait for container to exit, but proceed anyway after the timeout elapses
+	client.waitForStop(c, timeout)
+
+	return client.api.RemoveContainer(c.containerInfo.Id, true, false)
+}
+
+func (client DockerClient) Start(c Container) error {
+	config := c.runtimeConfig()
+	hostConfig := c.hostConfig()
+	name := c.Name()
+
+	if name == "" {
+		log.Printf("Starting new container from %s", c.containerInfo.Config.Image)
+	} else {
+		log.Printf("Starting %s\n", name)
+	}
+
+	newContainerId, err := client.api.CreateContainer(config, name)
+	if err != nil {
+		return err
+	}
+
+	return client.api.StartContainer(newContainerId, hostConfig)
+}
+
+func (client DockerClient) Rename(c Container, newName string) error {
+	return client.api.RenameContainer(c.containerInfo.Id, newName)
+}
+
+func (client DockerClient) waitForStop(c Container, waitTime time.Duration) error {
+	timeout := time.After(waitTime)
+
+	for {
+		select {
+		case <-timeout:
+			return nil
+		default:
+			if ci, err := client.api.InspectContainer(c.containerInfo.Id); err != nil {
+				return err
+			} else if !ci.State.Running {
+				return nil
+			}
+
+			time.Sleep(1 * time.Second)
+		}
+	}
+}

container/client_test.go

@@ -0,0 +1,378 @@
+package container
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/samalba/dockerclient"
+	"github.com/samalba/dockerclient/mockclient"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func allContainers(Container) bool { return true }
+func noContainers(Container) bool  { return false }
+
+func TestListContainers_Success(t *testing.T) {
+	ci := &dockerclient.ContainerInfo{Image: "abc123"}
+	ii := &dockerclient.ImageInfo{}
+	api := mockclient.NewMockClient()
+	api.On("ListContainers", false, false, "").Return([]dockerclient.Container{{Id: "foo"}}, nil)
+	api.On("InspectContainer", "foo").Return(ci, nil)
+	api.On("InspectImage", "abc123").Return(ii, nil)
+
+	client := DockerClient{api: api}
+	cs, err := client.ListContainers(allContainers)
+
+	assert.NoError(t, err)
+	assert.Len(t, cs, 1)
+	assert.Equal(t, ci, cs[0].containerInfo)
+	assert.Equal(t, ii, cs[0].imageInfo)
+	api.AssertExpectations(t)
+}
+
+func TestListContainers_Filter(t *testing.T) {
+	ci := &dockerclient.ContainerInfo{Image: "abc123"}
+	ii := &dockerclient.ImageInfo{}
+	api := mockclient.NewMockClient()
+	api.On("ListContainers", false, false, "").Return([]dockerclient.Container{{Id: "foo"}}, nil)
+	api.On("InspectContainer", "foo").Return(ci, nil)
+	api.On("InspectImage", "abc123").Return(ii, nil)
+
+	client := DockerClient{api: api}
+	cs, err := client.ListContainers(noContainers)
+
+	assert.NoError(t, err)
+	assert.Len(t, cs, 0)
+	api.AssertExpectations(t)
+}
+
+func TestListContainers_ListError(t *testing.T) {
+	api := mockclient.NewMockClient()
+	api.On("ListContainers", false, false, "").Return([]dockerclient.Container{}, errors.New("oops"))
+
+	client := DockerClient{api: api}
+	_, err := client.ListContainers(allContainers)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "oops")
+	api.AssertExpectations(t)
+}
+
+func TestListContainers_InspectContainerError(t *testing.T) {
+	api := mockclient.NewMockClient()
+	api.On("ListContainers", false, false, "").Return([]dockerclient.Container{{Id: "foo"}}, nil)
+	api.On("InspectContainer", "foo").Return(&dockerclient.ContainerInfo{}, errors.New("uh-oh"))
+
+	client := DockerClient{api: api}
+	_, err := client.ListContainers(allContainers)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "uh-oh")
+	api.AssertExpectations(t)
+}
+
+func TestListContainers_InspectImageError(t *testing.T) {
+	ci := &dockerclient.ContainerInfo{Image: "abc123"}
+	ii := &dockerclient.ImageInfo{}
+	api := mockclient.NewMockClient()
+	api.On("ListContainers", false, false, "").Return([]dockerclient.Container{{Id: "foo"}}, nil)
+	api.On("InspectContainer", "foo").Return(ci, nil)
+	api.On("InspectImage", "abc123").Return(ii, errors.New("whoops"))
+
+	client := DockerClient{api: api}
+	_, err := client.ListContainers(allContainers)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "whoops")
+	api.AssertExpectations(t)
+}
+
+func TestRefreshImage_NotStaleSuccess(t *testing.T) {
+	c := &Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:   "foo",
+			Config: &dockerclient.ContainerConfig{Image: "bar"},
+		},
+		imageInfo: &dockerclient.ImageInfo{Id: "abc123"},
+	}
+	newImageInfo := &dockerclient.ImageInfo{Id: "abc123"}
+
+	api := mockclient.NewMockClient()
+	api.On("PullImage", "bar:latest", mock.Anything).Return(nil)
+	api.On("InspectImage", "bar:latest").Return(newImageInfo, nil)
+
+	client := DockerClient{api: api}
+	err := client.RefreshImage(c)
+
+	assert.NoError(t, err)
+	assert.False(t, c.Stale)
+	api.AssertExpectations(t)
+}
+
+func TestRefreshImage_StaleSuccess(t *testing.T) {
+	c := &Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:   "foo",
+			Config: &dockerclient.ContainerConfig{Image: "bar:1.0"},
+		},
+		imageInfo: &dockerclient.ImageInfo{Id: "abc123"},
+	}
+	newImageInfo := &dockerclient.ImageInfo{Id: "xyz789"}
+
+	api := mockclient.NewMockClient()
+	api.On("PullImage", "bar:1.0", mock.Anything).Return(nil)
+	api.On("InspectImage", "bar:1.0").Return(newImageInfo, nil)
+
+	client := DockerClient{api: api}
+	err := client.RefreshImage(c)
+
+	assert.NoError(t, err)
+	assert.True(t, c.Stale)
+	api.AssertExpectations(t)
+}
+
+func TestRefreshImage_PullImageError(t *testing.T) {
+	c := &Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:   "foo",
+			Config: &dockerclient.ContainerConfig{Image: "bar:latest"},
+		},
+		imageInfo: &dockerclient.ImageInfo{Id: "abc123"},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("PullImage", "bar:latest", mock.Anything).Return(errors.New("oops"))
+
+	client := DockerClient{api: api}
+	err := client.RefreshImage(c)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "oops")
+	api.AssertExpectations(t)
+}
+
+func TestRefreshImage_InspectImageError(t *testing.T) {
+	c := &Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:   "foo",
+			Config: &dockerclient.ContainerConfig{Image: "bar:latest"},
+		},
+		imageInfo: &dockerclient.ImageInfo{Id: "abc123"},
+	}
+	newImageInfo := &dockerclient.ImageInfo{}
+
+	api := mockclient.NewMockClient()
+	api.On("PullImage", "bar:latest", mock.Anything).Return(nil)
+	api.On("InspectImage", "bar:latest").Return(newImageInfo, errors.New("uh-oh"))
+
+	client := DockerClient{api: api}
+	err := client.RefreshImage(c)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "uh-oh")
+	api.AssertExpectations(t)
+}
+
+func TestStop_DefaultSuccess(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:   "foo",
+			Id:     "abc123",
+			Config: &dockerclient.ContainerConfig{},
+		},
+	}
+
+	ci := &dockerclient.ContainerInfo{
+		State: &dockerclient.State{
+			Running: false,
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("KillContainer", "abc123", "SIGTERM").Return(nil)
+	api.On("InspectContainer", "abc123").Return(ci, nil)
+	api.On("RemoveContainer", "abc123", true, false).Return(nil)
+
+	client := DockerClient{api: api}
+	err := client.Stop(c, time.Second)
+
+	assert.NoError(t, err)
+	api.AssertExpectations(t)
+}
+
+func TestStop_CustomSignalSuccess(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name: "foo",
+			Id:   "abc123",
+			Config: &dockerclient.ContainerConfig{
+				Labels: map[string]string{"com.centurylinklabs.watchtower.stop-signal": "SIGUSR1"}},
+		},
+	}
+
+	ci := &dockerclient.ContainerInfo{
+		State: &dockerclient.State{
+			Running: false,
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("KillContainer", "abc123", "SIGUSR1").Return(nil)
+	api.On("InspectContainer", "abc123").Return(ci, nil)
+	api.On("RemoveContainer", "abc123", true, false).Return(nil)
+
+	client := DockerClient{api: api}
+	err := client.Stop(c, time.Second)
+
+	assert.NoError(t, err)
+	api.AssertExpectations(t)
+}
+
+func TestStop_KillContainerError(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:   "foo",
+			Id:     "abc123",
+			Config: &dockerclient.ContainerConfig{},
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("KillContainer", "abc123", "SIGTERM").Return(errors.New("oops"))
+
+	client := DockerClient{api: api}
+	err := client.Stop(c, time.Second)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "oops")
+	api.AssertExpectations(t)
+}
+
+func TestStop_RemoveContainerError(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:   "foo",
+			Id:     "abc123",
+			Config: &dockerclient.ContainerConfig{},
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("KillContainer", "abc123", "SIGTERM").Return(nil)
+	api.On("InspectContainer", "abc123").Return(&dockerclient.ContainerInfo{}, errors.New("dangit"))
+	api.On("RemoveContainer", "abc123", true, false).Return(errors.New("whoops"))
+
+	client := DockerClient{api: api}
+	err := client.Stop(c, time.Second)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "whoops")
+	api.AssertExpectations(t)
+}
+
+func TestStart_Success(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:       "foo",
+			Config:     &dockerclient.ContainerConfig{},
+			HostConfig: &dockerclient.HostConfig{},
+		},
+		imageInfo: &dockerclient.ImageInfo{
+			Config: &dockerclient.ContainerConfig{},
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("CreateContainer", mock.AnythingOfType("*dockerclient.ContainerConfig"), "foo").Return("def789", nil)
+	api.On("StartContainer", "def789", mock.AnythingOfType("*dockerclient.HostConfig")).Return(nil)
+
+	client := DockerClient{api: api}
+	err := client.Start(c)
+
+	assert.NoError(t, err)
+	api.AssertExpectations(t)
+}
+
+func TestStart_CreateContainerError(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:       "foo",
+			Config:     &dockerclient.ContainerConfig{},
+			HostConfig: &dockerclient.HostConfig{},
+		},
+		imageInfo: &dockerclient.ImageInfo{
+			Config: &dockerclient.ContainerConfig{},
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("CreateContainer", mock.Anything, "foo").Return("", errors.New("oops"))
+
+	client := DockerClient{api: api}
+	err := client.Start(c)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "oops")
+	api.AssertExpectations(t)
+}
+
+func TestStart_StartContainerError(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name:       "foo",
+			Config:     &dockerclient.ContainerConfig{},
+			HostConfig: &dockerclient.HostConfig{},
+		},
+		imageInfo: &dockerclient.ImageInfo{
+			Config: &dockerclient.ContainerConfig{},
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("CreateContainer", mock.Anything, "foo").Return("def789", nil)
+	api.On("StartContainer", "def789", mock.Anything).Return(errors.New("whoops"))
+
+	client := DockerClient{api: api}
+	err := client.Start(c)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "whoops")
+	api.AssertExpectations(t)
+}
+
+func TestRename_Success(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Id: "abc123",
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("RenameContainer", "abc123", "foo").Return(nil)
+
+	client := DockerClient{api: api}
+	err := client.Rename(c, "foo")
+
+	assert.NoError(t, err)
+	api.AssertExpectations(t)
+}
+
+func TestRename_Error(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Id: "abc123",
+		},
+	}
+
+	api := mockclient.NewMockClient()
+	api.On("RenameContainer", "abc123", "foo").Return(errors.New("oops"))
+
+	client := DockerClient{api: api}
+	err := client.Rename(c, "foo")
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "oops")
+	api.AssertExpectations(t)
+}

container/container.go

@@ -0,0 +1,108 @@
+package container
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/samalba/dockerclient"
+)
+
+type Container struct {
+	Stale bool
+
+	containerInfo *dockerclient.ContainerInfo
+	imageInfo     *dockerclient.ImageInfo
+}
+
+func (c Container) Name() string {
+	return c.containerInfo.Name
+}
+
+func (c Container) Links() []string {
+	links := []string{}
+
+	if (c.containerInfo != nil) && (c.containerInfo.HostConfig != nil) {
+		for _, link := range c.containerInfo.HostConfig.Links {
+			name := strings.Split(link, ":")[0]
+			links = append(links, name)
+		}
+	}
+
+	return links
+}
+
+func (c Container) IsWatchtower() bool {
+	val, ok := c.containerInfo.Config.Labels["com.centurylinklabs.watchtower"]
+	return ok && val == "true"
+}
+
+// Ideally, we'd just be able to take the ContainerConfig from the old container
+// and use it as the starting point for creating the new container; however,
+// the ContainerConfig that comes back from the Inspect call merges the default
+// configuration (the stuff specified in the metadata for the image itself)
+// with the overridden configuration (the stuff that you might specify as part
+// of the "docker run"). In order to avoid unintentionally overriding the
+// defaults in the new image we need to separate the override options from the
+// default options. To do this we have to compare the ContainerConfig for the
+// running container with the ContainerConfig from the image that container was
+// started from. This function returns a ContainerConfig which contains just
+// the options overridden at runtime.
+func (c Container) runtimeConfig() *dockerclient.ContainerConfig {
+	config := c.containerInfo.Config
+	imageConfig := c.imageInfo.Config
+
+	if config.WorkingDir == imageConfig.WorkingDir {
+		config.WorkingDir = ""
+	}
+
+	if config.User == imageConfig.User {
+		config.User = ""
+	}
+
+	if sliceEqual(config.Cmd, imageConfig.Cmd) {
+		config.Cmd = nil
+	}
+
+	if sliceEqual(config.Entrypoint, imageConfig.Entrypoint) {
+		config.Entrypoint = nil
+	}
+
+	config.Env = sliceSubtract(config.Env, imageConfig.Env)
+
+	config.Labels = stringMapSubtract(config.Labels, imageConfig.Labels)
+
+	config.Volumes = structMapSubtract(config.Volumes, imageConfig.Volumes)
+
+	config.ExposedPorts = structMapSubtract(config.ExposedPorts, imageConfig.ExposedPorts)
+	for p, _ := range c.containerInfo.HostConfig.PortBindings {
+		config.ExposedPorts[p] = struct{}{}
+	}
+
+	return config
+}
+
+// Any links in the HostConfig need to be re-written before they can be
+// re-submitted to the Docker create API.
+func (c Container) hostConfig() *dockerclient.HostConfig {
+	hostConfig := c.containerInfo.HostConfig
+
+	for i, link := range hostConfig.Links {
+		name := link[0:strings.Index(link, ":")]
+		alias := link[strings.LastIndex(link, "/"):]
+
+		hostConfig.Links[i] = fmt.Sprintf("%s:%s", name, alias)
+	}
+
+	return hostConfig
+}
+
+func NewTestContainer(name string, links []string) Container {
+	return Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Name: name,
+			HostConfig: &dockerclient.HostConfig{
+				Links: links,
+			},
+		},
+	}
+}

container/container_test.go

@@ -0,0 +1,68 @@
+package container
+
+import (
+	"testing"
+
+	"github.com/samalba/dockerclient"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestName(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{Name: "foo"},
+	}
+
+	name := c.Name()
+
+	assert.Equal(t, "foo", name)
+}
+
+func TestLinks(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			HostConfig: &dockerclient.HostConfig{
+				Links: []string{"foo:foo", "bar:bar"},
+			},
+		},
+	}
+
+	links := c.Links()
+
+	assert.Equal(t, []string{"foo", "bar"}, links)
+}
+
+func TestIsWatchtower_True(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Config: &dockerclient.ContainerConfig{
+				Labels: map[string]string{"com.centurylinklabs.watchtower": "true"},
+			},
+		},
+	}
+
+	assert.True(t, c.IsWatchtower())
+}
+
+func TestIsWatchtower_WrongLabelValue(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Config: &dockerclient.ContainerConfig{
+				Labels: map[string]string{"com.centurylinklabs.watchtower": "false"},
+			},
+		},
+	}
+
+	assert.False(t, c.IsWatchtower())
+}
+
+func TestIsWatchtower_NoLabel(t *testing.T) {
+	c := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Config: &dockerclient.ContainerConfig{
+				Labels: map[string]string{},
+			},
+		},
+	}
+
+	assert.False(t, c.IsWatchtower())
+}

container/sort.go

@@ -0,0 +1,98 @@
+package container
+
+import (
+	"fmt"
+	"time"
+)
+
+// Sort containers by Created date
+type ByCreated []Container
+
+func (c ByCreated) Len() int      { return len(c) }
+func (c ByCreated) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
+
+func (c ByCreated) Less(i, j int) bool {
+	t1, err := time.Parse(time.RFC3339Nano, c[i].containerInfo.Created)
+	if err != nil {
+		t1 = time.Now()
+	}
+
+	t2, _ := time.Parse(time.RFC3339Nano, c[j].containerInfo.Created)
+	if err != nil {
+		t1 = time.Now()
+	}
+
+	return t1.Before(t2)
+}
+
+func SortByDependencies(containers []Container) ([]Container, error) {
+	sorter := dependencySorter{}
+	return sorter.Sort(containers)
+}
+
+type dependencySorter struct {
+	unvisited []Container
+	marked    map[string]bool
+	sorted    []Container
+}
+
+func (ds *dependencySorter) Sort(containers []Container) ([]Container, error) {
+	ds.unvisited = containers
+	ds.marked = map[string]bool{}
+
+	for len(ds.unvisited) > 0 {
+		if err := ds.visit(ds.unvisited[0]); err != nil {
+			return nil, err
+		}
+	}
+
+	return ds.sorted, nil
+}
+
+func (ds *dependencySorter) visit(c Container) error {
+
+	if _, ok := ds.marked[c.Name()]; ok {
+		return fmt.Errorf("Circular reference to %s", c.Name())
+	}
+
+	// Mark any visited node so that circular references can be detected
+	ds.marked[c.Name()] = true
+	defer delete(ds.marked, c.Name())
+
+	// Recursively visit links
+	for _, linkName := range c.Links() {
+		if linkedContainer := ds.findUnvisited(linkName); linkedContainer != nil {
+			if err := ds.visit(*linkedContainer); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Move container from unvisited to sorted
+	ds.removeUnvisited(c)
+	ds.sorted = append(ds.sorted, c)
+
+	return nil
+}
+
+func (ds *dependencySorter) findUnvisited(name string) *Container {
+	for _, c := range ds.unvisited {
+		if c.Name() == name {
+			return &c
+		}
+	}
+
+	return nil
+}
+
+func (ds *dependencySorter) removeUnvisited(c Container) {
+	var idx int
+	for i := range ds.unvisited {
+		if ds.unvisited[i].Name() == c.Name() {
+			idx = i
+			break
+		}
+	}
+
+	ds.unvisited = append(ds.unvisited[0:idx], ds.unvisited[idx+1:]...)
+}

container/sort_test.go

@@ -0,0 +1,59 @@
+package container
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/samalba/dockerclient"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestByCreated(t *testing.T) {
+	c1 := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Created: "2015-07-01T12:00:01.000000000Z",
+		},
+	}
+	c2 := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Created: "2015-07-01T12:00:02.000000000Z",
+		},
+	}
+	c3 := Container{
+		containerInfo: &dockerclient.ContainerInfo{
+			Created: "2015-07-01T12:00:02.000000001Z",
+		},
+	}
+	cs := []Container{c3, c2, c1}
+
+	sort.Sort(ByCreated(cs))
+
+	assert.Equal(t, []Container{c1, c2, c3}, cs)
+}
+
+func TestSortByDependencies_Success(t *testing.T) {
+	c1 := NewTestContainer("1", []string{})
+	c2 := NewTestContainer("2", []string{"1:"})
+	c3 := NewTestContainer("3", []string{"2:"})
+	c4 := NewTestContainer("4", []string{"3:"})
+	c5 := NewTestContainer("5", []string{"4:"})
+	c6 := NewTestContainer("6", []string{"5:", "3:"})
+	containers := []Container{c6, c2, c4, c1, c3, c5}
+
+	result, err := SortByDependencies(containers)
+
+	assert.NoError(t, err)
+	assert.Equal(t, []Container{c1, c2, c3, c4, c5, c6}, result)
+}
+
+func TestSortByDependencies_Error(t *testing.T) {
+	c1 := NewTestContainer("1", []string{"3:"})
+	c2 := NewTestContainer("2", []string{"1:"})
+	c3 := NewTestContainer("3", []string{"2:"})
+	containers := []Container{c1, c2, c3}
+
+	_, err := SortByDependencies(containers)
+
+	assert.Error(t, err)
+	assert.EqualError(t, err, "Circular reference to 1")
+}

container/util.go

@@ -0,0 +1,64 @@
+package container
+
+func sliceEqual(s1, s2 []string) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+
+	for i := range s1 {
+		if s1[i] != s2[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+func sliceSubtract(a1, a2 []string) []string {
+	a := []string{}
+
+	for _, e1 := range a1 {
+		found := false
+
+		for _, e2 := range a2 {
+			if e1 == e2 {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			a = append(a, e1)
+		}
+	}
+
+	return a
+}
+
+func stringMapSubtract(m1, m2 map[string]string) map[string]string {
+	m := map[string]string{}
+
+	for k1, v1 := range m1 {
+		if v2, ok := m2[k1]; ok {
+			if v2 != v1 {
+				m[k1] = v1
+			}
+		} else {
+			m[k1] = v1
+		}
+	}
+
+	return m
+}
+
+func structMapSubtract(m1, m2 map[string]struct{}) map[string]struct{} {
+	m := map[string]struct{}{}
+
+	for k1, v1 := range m1 {
+		if _, ok := m2[k1]; !ok {
+			m[k1] = v1
+		}
+	}
+
+	return m
+}

container/util_test.go

@@ -0,0 +1,65 @@
+package container
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSliceEqual_True(t *testing.T) {
+	s1 := []string{"a", "b", "c"}
+	s2 := []string{"a", "b", "c"}
+
+	result := sliceEqual(s1, s2)
+
+	assert.True(t, result)
+}
+
+func TestSliceEqual_DifferentLengths(t *testing.T) {
+	s1 := []string{"a", "b", "c"}
+	s2 := []string{"a", "b", "c", "d"}
+
+	result := sliceEqual(s1, s2)
+
+	assert.False(t, result)
+}
+
+func TestSliceEqual_DifferentContents(t *testing.T) {
+	s1 := []string{"a", "b", "c"}
+	s2 := []string{"a", "b", "d"}
+
+	result := sliceEqual(s1, s2)
+
+	assert.False(t, result)
+}
+
+func TestSliceSubtract(t *testing.T) {
+	a1 := []string{"a", "b", "c"}
+	a2 := []string{"a", "c"}
+
+	result := sliceSubtract(a1, a2)
+	assert.Equal(t, []string{"b"}, result)
+	assert.Equal(t, []string{"a", "b", "c"}, a1)
+	assert.Equal(t, []string{"a", "c"}, a2)
+}
+
+func TestStringMapSubtract(t *testing.T) {
+	m1 := map[string]string{"a": "a", "b": "b", "c": "sea"}
+	m2 := map[string]string{"a": "a", "c": "c"}
+
+	result := stringMapSubtract(m1, m2)
+	assert.Equal(t, map[string]string{"b": "b", "c": "sea"}, result)
+	assert.Equal(t, map[string]string{"a": "a", "b": "b", "c": "sea"}, m1)
+	assert.Equal(t, map[string]string{"a": "a", "c": "c"}, m2)
+}
+
+func TestStructMapSubtract(t *testing.T) {
+	x := struct{}{}
+	m1 := map[string]struct{}{"a": x, "b": x, "c": x}
+	m2 := map[string]struct{}{"a": x, "c": x}
+
+	result := structMapSubtract(m1, m2)
+	assert.Equal(t, map[string]struct{}{"b": x}, result)
+	assert.Equal(t, map[string]struct{}{"a": x, "b": x, "c": x}, m1)
+	assert.Equal(t, map[string]struct{}{"a": x, "c": x}, m2)
+}