From ed1884461331d7c2d6561be30b09da9df6612d39 Mon Sep 17 00:00:00 2001
From: Michael Crosby <crosby.michael@gmail.com>
Date: Fri, 8 Nov 2013 11:10:33 -0800
Subject: [PATCH] Implement changes for aufs driver

---
 aufs/aufs.go      | 45 ++++++++++++++++++++++++++------------
 aufs/aufs_test.go | 55 +++++++++++++++++++++++++++++++++++++++++++++++
 aufs/dirs.go      |  7 +++---
 3 files changed, 89 insertions(+), 18 deletions(-)

diff --git a/aufs/aufs.go b/aufs/aufs.go
index 932e415e08..7d4aea8594 100644
--- a/aufs/aufs.go
+++ b/aufs/aufs.go
@@ -119,9 +119,13 @@ func (a *AufsDriver) Create(id, parent string) error {
 			return err
 		}
 
-		fmt.Fprintln(f, parent)
+		if _, err := fmt.Fprintln(f, parent); err != nil {
+			return err
+		}
 		for _, i := range ids {
-			fmt.Fprintln(f, i)
+			if _, err := fmt.Fprintln(f, i); err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -212,7 +216,28 @@ func (a *AufsDriver) DiffSize(id string) (int64, error) {
 }
 
 func (a *AufsDriver) Changes(id string) ([]archive.Change, error) {
-	return nil, nil
+	layers, err := a.getParentLayerPaths(id)
+	if err != nil {
+		return nil, err
+	}
+	return archive.Changes(layers, path.Join(a.rootPath(), "diff", id))
+}
+
+func (a *AufsDriver) getParentLayerPaths(id string) ([]string, error) {
+	parentIds, err := getParentIds(a.rootPath(), id)
+	if err != nil {
+		return nil, err
+	}
+	if len(parentIds) == 0 {
+		return nil, fmt.Errorf("Dir %s does not have any parent layers", id)
+	}
+	layers := make([]string, len(parentIds))
+
+	// Get the diff paths for all the parent ids
+	for i, p := range parentIds {
+		layers[i] = path.Join(a.rootPath(), "diff", p)
+	}
+	return layers, nil
 }
 
 func (a *AufsDriver) mount(id string) error {
@@ -221,22 +246,14 @@ func (a *AufsDriver) mount(id string) error {
 		return err
 	}
 
-	parentIds, err := getParentIds(a.rootPath(), id)
-	if err != nil {
-		return err
-	}
-	if len(parentIds) == 0 {
-		return fmt.Errorf("Dir %s does not have any parent layers", id)
-	}
 	var (
 		target = path.Join(a.rootPath(), "mnt", id)
 		rw     = path.Join(a.rootPath(), "diff", id)
-		layers = make([]string, len(parentIds))
 	)
 
-	// Get the diff paths for all the parent ids
-	for i, p := range parentIds {
-		layers[i] = path.Join(a.rootPath(), "diff", p)
+	layers, err := a.getParentLayerPaths(id)
+	if err != nil {
+		return err
 	}
 
 	if err := a.aufsMount(layers, rw, target); err != nil {
diff --git a/aufs/aufs_test.go b/aufs/aufs_test.go
index 0afaf9b785..7f49aec921 100644
--- a/aufs/aufs_test.go
+++ b/aufs/aufs_test.go
@@ -1,6 +1,7 @@
 package aufs
 
 import (
+	"github.com/dotcloud/docker/archive"
 	"os"
 	"path"
 	"testing"
@@ -331,6 +332,60 @@ func TestGetDiff(t *testing.T) {
 	}
 }
 
+func TestChanges(t *testing.T) {
+	d := newDriver(t)
+	defer os.RemoveAll(tmp)
+
+	if err := d.Create("1", ""); err != nil {
+		t.Fatal(err)
+	}
+	if err := d.Create("2", "1"); err != nil {
+		t.Fatal(err)
+	}
+
+	defer func() {
+		if err := d.Cleanup(); err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	mntPoint, err := d.Get("2")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create a file to save in the mountpoint
+	f, err := os.Create(path.Join(mntPoint, "test.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := f.WriteString("testline"); err != nil {
+		t.Fatal(err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	changes, err := d.Changes("2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(changes) != 1 {
+		t.Fatalf("Dir 2 should have one change from parent got %d", len(changes))
+	}
+	change := changes[0]
+
+	expectedPath := "/test.txt"
+	if change.Path != expectedPath {
+		t.Fatalf("Expected path %s got %s", expectedPath, change.Path)
+	}
+
+	if change.Kind != archive.ChangeAdd {
+		t.Fatalf("Change kind should be ChangeAdd got %s", change.Kind)
+	}
+}
+
 /* FIXME: How to properly test this?
 func TestDiffSize(t *testing.T) {
 	d := newDriver(t)
diff --git a/aufs/dirs.go b/aufs/dirs.go
index dc0007b905..fb9b81edd2 100644
--- a/aufs/dirs.go
+++ b/aufs/dirs.go
@@ -38,10 +38,9 @@ func getParentIds(root, id string) ([]string, error) {
 	s := bufio.NewScanner(f)
 
 	for s.Scan() {
-		if err := s.Err(); err != nil {
-			return nil, err
+		if t := s.Text(); t != "" {
+			out = append(out, s.Text())
 		}
-		out = append(out, s.Text())
 	}
-	return out, nil
+	return out, s.Err()
 }