@@ -23,7 +23,7 @@

 # the case. Therefore, you don't have to disable it anymore.

 #

-docker-version 0.6.1

+docker-version	0.6.1

 from	ubuntu:12.04

 maintainer	Solomon Hykes <solomon@dotcloud.com>

@@ -33,13 +33,13 @@ run	apt-get update

 run	apt-get install -y -q curl

 run	apt-get install -y -q git

 run	apt-get install -y -q mercurial

-run apt-get install -y -q build-essential libsqlite3-dev

+run	apt-get install -y -q build-essential libsqlite3-dev

 # Install Go

 run	curl -s https://go.googlecode.com/files/go1.2rc5.src.tar.gz | tar -v -C /usr/local -xz

 env	PATH	/usr/local/go/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin

 env	GOPATH	/go:/go/src/github.com/dotcloud/docker/vendor

-run cd /usr/local/go/src && ./make.bash && go install -ldflags '-w -linkmode external -extldflags "-static -Wl,--unresolved-symbols=ignore-in-shared-libs"' -tags netgo -a std

+run	cd /usr/local/go/src && ./make.bash && go install -ldflags '-w -linkmode external -extldflags "-static -Wl,--unresolved-symbols=ignore-in-shared-libs"' -tags netgo -a std

 # Ubuntu stuff

 run	apt-get install -y -q ruby1.9.3 rubygems libffi-dev

@@ -56,11 +56,20 @@ run	apt-get install -y -q iptables

 run	apt-get install -y -q lxc

 run	apt-get install -y -q aufs-tools

+# Get lvm2 source for compiling statically

+run	git clone https://git.fedorahosted.org/git/lvm2.git /usr/local/lvm2 && cd /usr/local/lvm2 && git checkout v2_02_103

+# see https://git.fedorahosted.org/cgit/lvm2.git/refs/tags for release tags

+# note: we can't use "git clone -b" above because it requires at least git 1.7.10 to be able to use that on a tag instead of a branch and we only have 1.7.9.5

+

+# Compile and install lvm2

+run	cd /usr/local/lvm2 && ./configure --enable-static_link && make device-mapper && make install_device-mapper

+# see https://git.fedorahosted.org/cgit/lvm2.git/tree/INSTALL

+

 volume	/var/lib/docker

 workdir	/go/src/github.com/dotcloud/docker

 # Wrap all commands in the "docker-in-docker" script to allow nested containers

-entrypoint ["hack/dind"]

+entrypoint	["hack/dind"]

 # Upload docker source

-add	.       /go/src/github.com/dotcloud/docker

+add	.	/go/src/github.com/dotcloud/docker

@@ -33,15 +33,17 @@ type (

 		Debug              bool

 		Containers         int

 		Images             int

-		NFd                int    `json:",omitempty"`

-		NGoroutines        int    `json:",omitempty"`

-		MemoryLimit        bool   `json:",omitempty"`

-		SwapLimit          bool   `json:",omitempty"`

-		IPv4Forwarding     bool   `json:",omitempty"`

-		LXCVersion         string `json:",omitempty"`

-		NEventsListener    int    `json:",omitempty"`

-		KernelVersion      string `json:",omitempty"`

-		IndexServerAddress string `json:",omitempty"`

+		Driver             string      `json:",omitempty"`

+		DriverStatus       [][2]string `json:",omitempty"`

+		NFd                int         `json:",omitempty"`

+		NGoroutines        int         `json:",omitempty"`

+		MemoryLimit        bool        `json:",omitempty"`

+		SwapLimit          bool        `json:",omitempty"`

+		IPv4Forwarding     bool        `json:",omitempty"`

+		LXCVersion         string      `json:",omitempty"`

+		NEventsListener    int         `json:",omitempty"`

+		KernelVersion      string      `json:",omitempty"`

+		IndexServerAddress string      `json:",omitempty"`

 	}

 	APITop struct {

@@ -15,7 +15,15 @@ import (

 type Archive io.Reader

-type Compression uint32

+type Compression int

+

+type TarOptions struct {

+	Includes    []string

+	Excludes    []string

+	Recursive   bool

+	Compression Compression

+	CreateFiles []string

+}

 const (

 	Uncompressed Compression = iota

@@ -80,20 +88,78 @@ func (compression *Compression) Extension() string {

 // Tar creates an archive from the directory at `path`, and returns it as a

 // stream of bytes.

 func Tar(path string, compression Compression) (io.Reader, error) {

-	return TarFilter(path, compression, nil)

+	return TarFilter(path, &TarOptions{Recursive: true, Compression: compression})

+}

+

+func escapeName(name string) string {

+	escaped := make([]byte, 0)

+	for i, c := range []byte(name) {

+		if i == 0 && c == '/' {

+			continue

+		}

+		// all printable chars except "-" which is 0x2d

+		if (0x20 <= c && c <= 0x7E) && c != 0x2d {

+			escaped = append(escaped, c)

+		} else {

+			escaped = append(escaped, fmt.Sprintf("\\%03o", c)...)

+		}

+	}

+	return string(escaped)

 }

 // Tar creates an archive from the directory at `path`, only including files whose relative

 // paths are included in `filter`. If `filter` is nil, then all files are included.

-func TarFilter(path string, compression Compression, filter []string) (io.Reader, error) {

-	args := []string{"tar", "--numeric-owner", "-f", "-", "-C", path}

-	if filter == nil {

-		filter = []string{"."}

+func TarFilter(path string, options *TarOptions) (io.Reader, error) {

+	args := []string{"tar", "--numeric-owner", "-f", "-", "-C", path, "-T", "-"}

+	if options.Includes == nil {

+		options.Includes = []string{"."}

 	}

-	for _, f := range filter {

-		args = append(args, "-c"+compression.Flag(), f)

+	args = append(args, "-c"+options.Compression.Flag())

+

+	for _, exclude := range options.Excludes {

+		args = append(args, fmt.Sprintf("--exclude=%s", exclude))

+	}

+

+	if !options.Recursive {

+		args = append(args, "--no-recursion")

+	}

+

+	files := ""

+	for _, f := range options.Includes {

+		files = files + escapeName(f) + "\n"

+	}

+

+	tmpDir := ""

+

+	if options.CreateFiles != nil {

+		var err error // Can't use := here or we override the outer tmpDir

+		tmpDir, err = ioutil.TempDir("", "docker-tar")

+		if err != nil {

+			return nil, err

+		}

+

+		files = files + "-C" + tmpDir + "\n"

+		for _, f := range options.CreateFiles {

+			path := filepath.Join(tmpDir, f)

+			err := os.MkdirAll(filepath.Dir(path), 0600)

+			if err != nil {

+				return nil, err

+			}

+

+			if file, err := os.OpenFile(path, os.O_CREATE, 0600); err != nil {

+				return nil, err

+			} else {

+				file.Close()

+			}

+			files = files + escapeName(f) + "\n"

+		}

 	}

-	return CmdStream(exec.Command(args[0], args[1:]...))

+

+	return CmdStream(exec.Command(args[0], args[1:]...), &files, func() {

+		if tmpDir != "" {

+			_ = os.RemoveAll(tmpDir)

+		}

+	})

 }

 // Untar reads a stream of bytes from `archive`, parses it as a tar archive,

@@ -101,7 +167,7 @@ func TarFilter(path string, compression Compression, filter []string) (io.Reader

 // The archive may be compressed with one of the following algorithms:

 //  identity (uncompressed), gzip, bzip2, xz.

 // FIXME: specify behavior when target path exists vs. doesn't exist.

-func Untar(archive io.Reader, path string) error {

+func Untar(archive io.Reader, path string, options *TarOptions) error {

 	if archive == nil {

 		return fmt.Errorf("Empty archive")

 	}

@@ -123,8 +189,15 @@ func Untar(archive io.Reader, path string) error {

 	compression := DetectCompression(buf)

 	utils.Debugf("Archive compression detected: %s", compression.Extension())

+	args := []string{"--numeric-owner", "-f", "-", "-C", path, "-x" + compression.Flag()}

+

+	if options != nil {

+		for _, exclude := range options.Excludes {

+			args = append(args, fmt.Sprintf("--exclude=%s", exclude))

+		}

+	}

-	cmd := exec.Command("tar", "--numeric-owner", "-f", "-", "-C", path, "-x"+compression.Flag())

+	cmd := exec.Command("tar", args...)

 	cmd.Stdin = io.MultiReader(bytes.NewReader(buf), archive)

 	// Hardcode locale environment for predictable outcome regardless of host configuration.

 	//   (see https://github.com/dotcloud/docker/issues/355)

@@ -141,11 +214,11 @@ func Untar(archive io.Reader, path string) error {

 // TarUntar aborts and returns the error.

 func TarUntar(src string, filter []string, dst string) error {

 	utils.Debugf("TarUntar(%s %s %s)", src, filter, dst)

-	archive, err := TarFilter(src, Uncompressed, filter)

+	archive, err := TarFilter(src, &TarOptions{Compression: Uncompressed, Includes: filter, Recursive: true})

 	if err != nil {

 		return err

 	}

-	return Untar(archive, dst)

+	return Untar(archive, dst, nil)

 }

 // UntarPath is a convenience function which looks for an archive

@@ -153,7 +226,7 @@ func TarUntar(src string, filter []string, dst string) error {

 func UntarPath(src, dst string) error {

 	if archive, err := os.Open(src); err != nil {

 		return err

-	} else if err := Untar(archive, dst); err != nil {

+	} else if err := Untar(archive, dst, nil); err != nil {

 		return err

 	}

 	return nil

@@ -222,19 +295,39 @@ func CopyFileWithTar(src, dst string) error {

 		return err

 	}

 	tw.Close()

-	return Untar(buf, filepath.Dir(dst))

+	return Untar(buf, filepath.Dir(dst), nil)

 }

 // CmdStream executes a command, and returns its stdout as a stream.

 // If the command fails to run or doesn't complete successfully, an error

 // will be returned, including anything written on stderr.

-func CmdStream(cmd *exec.Cmd) (io.Reader, error) {

+func CmdStream(cmd *exec.Cmd, input *string, atEnd func()) (io.Reader, error) {

+	if input != nil {

+		stdin, err := cmd.StdinPipe()

+		if err != nil {

+			if atEnd != nil {

+				atEnd()

+			}

+			return nil, err

+		}

+		// Write stdin if any

+		go func() {

+			_, _ = stdin.Write([]byte(*input))

+			stdin.Close()

+		}()

+	}

 	stdout, err := cmd.StdoutPipe()

 	if err != nil {

+		if atEnd != nil {

+			atEnd()

+		}

 		return nil, err

 	}

 	stderr, err := cmd.StderrPipe()

 	if err != nil {

+		if atEnd != nil {

+			atEnd()

+		}

 		return nil, err

 	}

 	pipeR, pipeW := io.Pipe()

@@ -259,6 +352,9 @@ func CmdStream(cmd *exec.Cmd) (io.Reader, error) {

 		} else {

 			pipeW.Close()

 		}

+		if atEnd != nil {

+			atEnd()

+		}

 	}()

 	// Run the command and return the pipe

 	if err := cmd.Start(); err != nil {

@@ -14,7 +14,7 @@ import (

 func TestCmdStreamLargeStderr(t *testing.T) {

 	cmd := exec.Command("/bin/sh", "-c", "dd if=/dev/zero bs=1k count=1000 of=/dev/stderr; echo hello")

-	out, err := CmdStream(cmd)

+	out, err := CmdStream(cmd, nil, nil)

 	if err != nil {

 		t.Fatalf("Failed to start command: %s", err)

 	}

@@ -35,7 +35,7 @@ func TestCmdStreamLargeStderr(t *testing.T) {

 func TestCmdStreamBad(t *testing.T) {

 	badCmd := exec.Command("/bin/sh", "-c", "echo hello; echo >&2 error couldn\\'t reverse the phase pulser; exit 1")

-	out, err := CmdStream(badCmd)

+	out, err := CmdStream(badCmd, nil, nil)

 	if err != nil {

 		t.Fatalf("Failed to start command: %s", err)

 	}

@@ -50,7 +50,7 @@ func TestCmdStreamBad(t *testing.T) {

 func TestCmdStreamGood(t *testing.T) {

 	cmd := exec.Command("/bin/sh", "-c", "echo hello; exit 0")

-	out, err := CmdStream(cmd)

+	out, err := CmdStream(cmd, nil, nil)

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -83,7 +83,7 @@ func tarUntar(t *testing.T, origin string, compression Compression) error {

 		return err

 	}

 	defer os.RemoveAll(tmp)

-	if err := Untar(archive, tmp); err != nil {

+	if err := Untar(archive, tmp, nil); err != nil {

 		return err

 	}

 	if _, err := os.Stat(tmp); err != nil {

new file mode 100644

@@ -0,0 +1,317 @@

+package archive

+

+import (

+	"fmt"

+	"os"

+	"path/filepath"

+	"strings"

+	"syscall"

+)

+

+type ChangeType int

+

+const (

+	ChangeModify = iota

+	ChangeAdd

+	ChangeDelete

+)

+

+type Change struct {

+	Path string

+	Kind ChangeType

+}

+

+func (change *Change) String() string {

+	var kind string

+	switch change.Kind {

+	case ChangeModify:

+		kind = "C"

+	case ChangeAdd:

+		kind = "A"

+	case ChangeDelete:

+		kind = "D"

+	}

+	return fmt.Sprintf("%s %s", kind, change.Path)

+}

+

+func Changes(layers []string, rw string) ([]Change, error) {

+	var changes []Change

+	err := filepath.Walk(rw, func(path string, f os.FileInfo, err error) error {

+		if err != nil {

+			return err

+		}

+

+		// Rebase path

+		path, err = filepath.Rel(rw, path)

+		if err != nil {

+			return err

+		}

+		path = filepath.Join("/", path)

+

+		// Skip root

+		if path == "/" {

+			return nil

+		}

+

+		// Skip AUFS metadata

+		if matched, err := filepath.Match("/.wh..wh.*", path); err != nil || matched {

+			return err

+		}

+

+		change := Change{

+			Path: path,

+		}

+

+		// Find out what kind of modification happened

+		file := filepath.Base(path)

+		// If there is a whiteout, then the file was removed

+		if strings.HasPrefix(file, ".wh.") {

+			originalFile := file[len(".wh."):]

+			change.Path = filepath.Join(filepath.Dir(path), originalFile)

+			change.Kind = ChangeDelete

+		} else {

+			// Otherwise, the file was added

+			change.Kind = ChangeAdd

+

+			// ...Unless it already existed in a top layer, in which case, it's a modification

+			for _, layer := range layers {

+				stat, err := os.Stat(filepath.Join(layer, path))

+				if err != nil && !os.IsNotExist(err) {

+					return err

+				}

+				if err == nil {

+					// The file existed in the top layer, so that's a modification

+

+					// However, if it's a directory, maybe it wasn't actually modified.

+					// If you modify /foo/bar/baz, then /foo will be part of the changed files only because it's the parent of bar

+					if stat.IsDir() && f.IsDir() {

+						if f.Size() == stat.Size() && f.Mode() == stat.Mode() && f.ModTime() == stat.ModTime() {

+							// Both directories are the same, don't record the change

+							return nil

+						}

+					}

+					change.Kind = ChangeModify

+					break

+				}

+			}

+		}

+

+		// Record change

+		changes = append(changes, change)

+		return nil

+	})

+	if err != nil && !os.IsNotExist(err) {

+		return nil, err

+	}

+	return changes, nil

+}

+

+type FileInfo struct {

+	parent   *FileInfo

+	name     string

+	stat     syscall.Stat_t

+	children map[string]*FileInfo

+}

+

+func (root *FileInfo) LookUp(path string) *FileInfo {

+	parent := root

+	if path == "/" {

+		return root

+	}

+

+	pathElements := strings.Split(path, "/")

+	for _, elem := range pathElements {

+		if elem != "" {

+			child := parent.children[elem]

+			if child == nil {

+				return nil

+			}

+			parent = child

+		}

+	}

+	return parent

+}

+

+func (info *FileInfo) path() string {

+	if info.parent == nil {

+		return "/"

+	}

+	return filepath.Join(info.parent.path(), info.name)

+}

+

+func (info *FileInfo) isDir() bool {

+	return info.parent == nil || info.stat.Mode&syscall.S_IFDIR == syscall.S_IFDIR

+}

+

+func (info *FileInfo) addChanges(oldInfo *FileInfo, changes *[]Change) {

+	if oldInfo == nil {

+		// add

+		change := Change{

+			Path: info.path(),

+			Kind: ChangeAdd,

+		}

+		*changes = append(*changes, change)

+	}

+

+	// We make a copy so we can modify it to detect additions

+	// also, we only recurse on the old dir if the new info is a directory

+	// otherwise any previous delete/change is considered recursive

+	oldChildren := make(map[string]*FileInfo)

+	if oldInfo != nil && info.isDir() {

+		for k, v := range oldInfo.children {

+			oldChildren[k] = v

+		}

+	}

+

+	for name, newChild := range info.children {

+		oldChild, _ := oldChildren[name]

+		if oldChild != nil {

+			// change?

+			oldStat := &oldChild.stat

+			newStat := &newChild.stat

+			// Note: We can't compare inode or ctime or blocksize here, because these change

+			// when copying a file into a container. However, that is not generally a problem

+			// because any content change will change mtime, and any status change should

+			// be visible when actually comparing the stat fields. The only time this

+			// breaks down is if some code intentionally hides a change by setting

+			// back mtime

+			if oldStat.Mode != newStat.Mode ||

+				oldStat.Uid != newStat.Uid ||

+				oldStat.Gid != newStat.Gid ||

+				oldStat.Rdev != newStat.Rdev ||

+				// Don't look at size for dirs, its not a good measure of change

+				(oldStat.Size != newStat.Size && oldStat.Mode&syscall.S_IFDIR != syscall.S_IFDIR) ||

+				oldStat.Mtim != newStat.Mtim {

+				change := Change{

+					Path: newChild.path(),

+					Kind: ChangeModify,

+				}

+				*changes = append(*changes, change)

+			}

+

+			// Remove from copy so we can detect deletions

+			delete(oldChildren, name)

+		}

+

+		newChild.addChanges(oldChild, changes)

+	}

+	for _, oldChild := range oldChildren {

+		// delete

+		change := Change{

+			Path: oldChild.path(),

+			Kind: ChangeDelete,

+		}

+		*changes = append(*changes, change)

+	}

+

+}

+

+func (info *FileInfo) Changes(oldInfo *FileInfo) []Change {

+	var changes []Change

+

+	info.addChanges(oldInfo, &changes)

+

+	return changes

+}

+

+func newRootFileInfo() *FileInfo {

+	root := &FileInfo{

+		name:     "/",

+		children: make(map[string]*FileInfo),

+	}

+	return root

+}

+

+func collectFileInfo(sourceDir string) (*FileInfo, error) {

+	root := newRootFileInfo()

+

+	err := filepath.Walk(sourceDir, func(path string, f os.FileInfo, err error) error {

+		if err != nil {

+			return err

+		}

+

+		// Rebase path

+		relPath, err := filepath.Rel(sourceDir, path)

+		if err != nil {

+			return err

+		}

+		relPath = filepath.Join("/", relPath)

+

+		if relPath == "/" {

+			return nil

+		}

+

+		parent := root.LookUp(filepath.Dir(relPath))

+		if parent == nil {

+			return fmt.Errorf("collectFileInfo: Unexpectedly no parent for %s", relPath)

+		}

+

+		info := &FileInfo{

+			name:     filepath.Base(relPath),

+			children: make(map[string]*FileInfo),

+			parent:   parent,

+		}

+

+		if err := syscall.Lstat(path, &info.stat); err != nil {

+			return err

+		}

+

+		parent.children[info.name] = info

+

+		return nil

+	})

+	if err != nil {

+		return nil, err

+	}

+	return root, nil

+}

+

+// Compare two directories and generate an array of Change objects describing the changes

+func ChangesDirs(newDir, oldDir string) ([]Change, error) {

+	oldRoot, err := collectFileInfo(oldDir)

+	if err != nil {

+		return nil, err

+	}

+	newRoot, err := collectFileInfo(newDir)

+	if err != nil {

+		return nil, err

+	}

+

+	return newRoot.Changes(oldRoot), nil

+}

+

+func ChangesSize(newDir string, changes []Change) int64 {

+	var size int64

+	for _, change := range changes {

+		if change.Kind == ChangeModify || change.Kind == ChangeAdd {

+			file := filepath.Join(newDir, change.Path)

+			fileInfo, _ := os.Lstat(file)

+			if fileInfo != nil && !fileInfo.IsDir() {

+				size += fileInfo.Size()

+			}

+		}

+	}

+	return size

+}

+

+func ExportChanges(dir string, changes []Change) (Archive, error) {

+	files := make([]string, 0)

+	deletions := make([]string, 0)

+	for _, change := range changes {

+		if change.Kind == ChangeModify || change.Kind == ChangeAdd {

+			files = append(files, change.Path)

+		}

+		if change.Kind == ChangeDelete {

+			base := filepath.Base(change.Path)

+			dir := filepath.Dir(change.Path)

+			deletions = append(deletions, filepath.Join(dir, ".wh."+base))

+		}

+	}

+	// FIXME: Why do we create whiteout files inside Tar code ?

+	return TarFilter(dir, &TarOptions{

+		Compression: Uncompressed,

+		Includes:    files,

+		Recursive:   false,

+		CreateFiles: deletions,

+	})

+}

new file mode 100644

@@ -0,0 +1,298 @@

+package archive

+

+import (

+	"io/ioutil"

+	"os"

+	"os/exec"

+	"path"

+	"sort"

+	"testing"

+	"time"

+)

+

+func max(x, y int) int {

+	if x >= y {

+		return x

+	}

+	return y

+}

+

+func copyDir(src, dst string) error {

+	cmd := exec.Command("cp", "-a", src, dst)

+	if err := cmd.Run(); err != nil {

+		return err

+	}

+	return nil

+}

+

+// Helper to sort []Change by path

+type byPath struct{ changes []Change }

+

+func (b byPath) Less(i, j int) bool { return b.changes[i].Path < b.changes[j].Path }

+func (b byPath) Len() int           { return len(b.changes) }

+func (b byPath) Swap(i, j int)      { b.changes[i], b.changes[j] = b.changes[j], b.changes[i] }

+

+type FileType uint32

+

+const (

+	Regular FileType = iota

+	Dir

+	Symlink

+)

+

+type FileData struct {

+	filetype    FileType

+	path        string

+	contents    string

+	permissions os.FileMode

+}

+

+func createSampleDir(t *testing.T, root string) {

+	files := []FileData{

+		{Regular, "file1", "file1\n", 0600},

+		{Regular, "file2", "file2\n", 0666},

+		{Regular, "file3", "file3\n", 0404},

+		{Regular, "file4", "file4\n", 0600},

+		{Regular, "file5", "file5\n", 0600},

+		{Regular, "file6", "file6\n", 0600},

+		{Regular, "file7", "file7\n", 0600},

+		{Dir, "dir1", "", 0740},

+		{Regular, "dir1/file1-1", "file1-1\n", 01444},

+		{Regular, "dir1/file1-2", "file1-2\n", 0666},

+		{Dir, "dir2", "", 0700},

+		{Regular, "dir2/file2-1", "file2-1\n", 0666},

+		{Regular, "dir2/file2-2", "file2-2\n", 0666},

+		{Dir, "dir3", "", 0700},

+		{Regular, "dir3/file3-1", "file3-1\n", 0666},

+		{Regular, "dir3/file3-2", "file3-2\n", 0666},

+		{Dir, "dir4", "", 0700},

+		{Regular, "dir4/file3-1", "file4-1\n", 0666},

+		{Regular, "dir4/file3-2", "file4-2\n", 0666},

+		{Symlink, "symlink1", "target1", 0666},

+		{Symlink, "symlink2", "target2", 0666},

+	}

+	for _, info := range files {

+		if info.filetype == Dir {

+			if err := os.MkdirAll(path.Join(root, info.path), info.permissions); err != nil {

+				t.Fatal(err)

+			}

+		} else if info.filetype == Regular {

+			if err := ioutil.WriteFile(path.Join(root, info.path), []byte(info.contents), info.permissions); err != nil {

+				t.Fatal(err)

+			}

+		} else if info.filetype == Symlink {

+			if err := os.Symlink(info.contents, path.Join(root, info.path)); err != nil {

+				t.Fatal(err)

+			}

+		}

+	}

+}

+

+// Create an directory, copy it, make sure we report no changes between the two

+func TestChangesDirsEmpty(t *testing.T) {

+	src, err := ioutil.TempDir("", "docker-changes-test")

+	if err != nil {

+		t.Fatal(err)

+	}

+	createSampleDir(t, src)

+	dst := src + "-copy"

+	if err := copyDir(src, dst); err != nil {

+		t.Fatal(err)

+	}

+	changes, err := ChangesDirs(dst, src)

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	if len(changes) != 0 {

+		t.Fatalf("Reported changes for identical dirs: %v", changes)

+	}

+	os.RemoveAll(src)

+	os.RemoveAll(dst)

+}

+

+func mutateSampleDir(t *testing.T, root string) {

+	// Remove a regular file

+	if err := os.RemoveAll(path.Join(root, "file1")); err != nil {

+		t.Fatal(err)

+	}

+

+	// Remove a directory

+	if err := os.RemoveAll(path.Join(root, "dir1")); err != nil {

+		t.Fatal(err)

+	}

+

+	// Remove a symlink

+	if err := os.RemoveAll(path.Join(root, "symlink1")); err != nil {

+		t.Fatal(err)

+	}

+

+	// Rewrite a file

+	if err := ioutil.WriteFile(path.Join(root, "file2"), []byte("fileN\n"), 0777); err != nil {

+		t.Fatal(err)

+	}

+

+	// Replace a file

+	if err := os.RemoveAll(path.Join(root, "file3")); err != nil {

+		t.Fatal(err)

+	}

+	if err := ioutil.WriteFile(path.Join(root, "file3"), []byte("fileM\n"), 0404); err != nil {

+		t.Fatal(err)

+	}

+

+	// Touch file

+	if err := os.Chtimes(path.Join(root, "file4"), time.Now(), time.Now()); err != nil {

+		t.Fatal(err)

+	}

+

+	// Replace file with dir

+	if err := os.RemoveAll(path.Join(root, "file5")); err != nil {

+		t.Fatal(err)

+	}

+	if err := os.MkdirAll(path.Join(root, "file5"), 0666); err != nil {

+		t.Fatal(err)

+	}

+

+	// Create new file

+	if err := ioutil.WriteFile(path.Join(root, "filenew"), []byte("filenew\n"), 0777); err != nil {

+		t.Fatal(err)

+	}

+

+	// Create new dir

+	if err := os.MkdirAll(path.Join(root, "dirnew"), 0766); err != nil {

+		t.Fatal(err)

+	}

+

+	// Create a new symlink

+	if err := os.Symlink("targetnew", path.Join(root, "symlinknew")); err != nil {

+		t.Fatal(err)

+	}

+

+	// Change a symlink

+	if err := os.RemoveAll(path.Join(root, "symlink2")); err != nil {

+		t.Fatal(err)

+	}

+	if err := os.Symlink("target2change", path.Join(root, "symlink2")); err != nil {

+		t.Fatal(err)

+	}

+

+	// Replace dir with file

+	if err := os.RemoveAll(path.Join(root, "dir2")); err != nil {

+		t.Fatal(err)

+	}

+	if err := ioutil.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0777); err != nil {

+		t.Fatal(err)

+	}

+

+	// Touch dir

+	if err := os.Chtimes(path.Join(root, "dir3"), time.Now(), time.Now()); err != nil {

+		t.Fatal(err)

+	}

+}

+

+func TestChangesDirsMutated(t *testing.T) {

+	src, err := ioutil.TempDir("", "docker-changes-test")

+	if err != nil {

+		t.Fatal(err)

+	}

+	createSampleDir(t, src)

+	dst := src + "-copy"

+	if err := copyDir(src, dst); err != nil {

+		t.Fatal(err)

+	}

+	mutateSampleDir(t, dst)

+

+	changes, err := ChangesDirs(dst, src)

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	sort.Sort(byPath{changes})

+

+	expectedChanges := []Change{

+		{"/dir1", ChangeDelete},

+		{"/dir2", ChangeModify},

+		{"/dir3", ChangeModify},

+		{"/dirnew", ChangeAdd},

+		{"/file1", ChangeDelete},

+		{"/file2", ChangeModify},