new file mode 100644

@@ -0,0 +1,75 @@

+package docker

+

+import (

+	"errors"

+	"io"

+	"io/ioutil"

+	"os/exec"

+)

+

+type Archive io.Reader

+

+type Compression uint32

+

+const (

+	Uncompressed Compression = iota

+	Bzip2

+	Gzip

+)

+

+func (compression *Compression) Flag() string {

+	switch *compression {

+	case Bzip2:

+		return "j"

+	case Gzip:

+		return "z"

+	}

+	return ""

+}

+

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

+	cmd := exec.Command("bsdtar", "-f", "-", "-C", path, "-c"+compression.Flag(), ".")

+	return CmdStream(cmd)

+}

+

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

+	cmd := exec.Command("bsdtar", "-f", "-", "-C", path, "-x")

+	cmd.Stdin = archive

+	output, err := cmd.CombinedOutput()

+	if err != nil {

+		return errors.New(err.Error() + ": " + string(output))

+	}

+	return nil

+}

+

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

+	stdout, err := cmd.StdoutPipe()

+	if err != nil {

+		return nil, err

+	}

+	stderr, err := cmd.StderrPipe()

+	if err != nil {

+		return nil, err

+	}

+	pipeR, pipeW := io.Pipe()

+	go func() {

+		_, err := io.Copy(pipeW, stdout)

+		if err != nil {

+			pipeW.CloseWithError(err)

+		}

+		errText, e := ioutil.ReadAll(stderr)

+		if e != nil {

+			errText = []byte("(...couldn't fetch stderr: " + e.Error() + ")")

+		}

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

+			// FIXME: can this block if stderr outputs more than the size of StderrPipe()'s buffer?

+			pipeW.CloseWithError(errors.New(err.Error() + ": " + string(errText)))

+		} else {

+			pipeW.Close()

+		}

+	}()

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

+		return nil, err

+	}

+	return pipeR, nil

+}

new file mode 100644

@@ -0,0 +1,54 @@

+package docker

+

+import (

+	"io/ioutil"

+	"os"

+	"os/exec"

+	"testing"

+)

+

+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)

+	if err != nil {

+		t.Fatalf("Failed to start command: " + err.Error())

+	}

+	if output, err := ioutil.ReadAll(out); err == nil {

+		t.Fatalf("Command should have failed")

+	} else if err.Error() != "exit status 1: error couldn't reverse the phase pulser\n" {

+		t.Fatalf("Wrong error value (%s)", err.Error())

+	} else if s := string(output); s != "hello\n" {

+		t.Fatalf("Command output should be '%s', not '%s'", "hello\\n", output)

+	}

+}

+

+func TestCmdStreamGood(t *testing.T) {

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

+	out, err := CmdStream(cmd)

+	if err != nil {

+		t.Fatal(err)

+	}

+	if output, err := ioutil.ReadAll(out); err != nil {

+		t.Fatalf("Command should not have failed (err=%s)", err)

+	} else if s := string(output); s != "hello\n" {

+		t.Fatalf("Command output should be '%s', not '%s'", "hello\\n", output)

+	}

+}

+

+func TestTarUntar(t *testing.T) {

+	archive, err := Tar(".", Uncompressed)

+	if err != nil {

+		t.Fatal(err)

+	}

+	tmp, err := ioutil.TempDir("", "docker-test-untar")

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer os.RemoveAll(tmp)

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

+		t.Fatal(err)

+	}

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

+		t.Fatalf("Error stating %s: %s", tmp, err.Error())

+	}

+}

new file mode 100644

@@ -0,0 +1,106 @@

+package docker

+

+import (

+	"fmt"

+	"os"

+	"path/filepath"

+	"strings"

+)

+

+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 := strings.TrimLeft(file, ".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 {

+		return nil, err

+	}

+	return changes, nil

+}

@@ -803,7 +803,7 @@ func NewServer() (*Server, error) {

 	// if err != nil {

 	// 	return nil, err

 	// }

-	runtime, err := New()

+	runtime, err := NewRuntime()

 	if err != nil {

 		return nil, err

 	}

@@ -4,7 +4,6 @@ import (

 	"encoding/json"

 	"errors"

 	"fmt"

-	"github.com/dotcloud/docker/graph"

 	"github.com/kr/pty"

 	"io"

 	"io/ioutil"

@@ -63,11 +62,6 @@ type NetworkSettings struct {

 	PortMapping map[string]string

 }

-func GenerateId() string {

-	return graph.GenerateId() // Re-use the same code to generate container and image IDs

-	// (this might change when image Ids become content-based)

-}

-

 func (container *Container) Cmd() *exec.Cmd {

 	return container.cmd

 }

@@ -376,15 +370,15 @@ func (container *Container) Wait() int {

 	return container.State.ExitCode

 }

-func (container *Container) ExportRw() (graph.Archive, error) {

-	return graph.Tar(container.rwPath(), graph.Uncompressed)

+func (container *Container) ExportRw() (Archive, error) {

+	return Tar(container.rwPath(), Uncompressed)

 }

-func (container *Container) Export() (graph.Archive, error) {

+func (container *Container) Export() (Archive, error) {

 	if err := container.EnsureMounted(); err != nil {

 		return nil, err

 	}

-	return graph.Tar(container.RootfsPath(), graph.Uncompressed)

+	return Tar(container.RootfsPath(), Uncompressed)

 }

 func (container *Container) WaitTimeout(timeout time.Duration) error {

@@ -420,7 +414,7 @@ func (container *Container) Mount() error {

 	return image.Mount(container.RootfsPath(), container.rwPath())

 }

-func (container *Container) Changes() ([]graph.Change, error) {

+func (container *Container) Changes() ([]Change, error) {

 	image, err := container.GetImage()

 	if err != nil {

 		return nil, err

@@ -428,7 +422,7 @@ func (container *Container) Changes() ([]graph.Change, error) {

 	return image.Changes(container.rwPath())

 }

-func (container *Container) GetImage() (*graph.Image, error) {

+func (container *Container) GetImage() (*Image, error) {

 	if container.runtime == nil {

 		return nil, fmt.Errorf("Can't get image of unregistered container")

 	}

@@ -436,11 +430,11 @@ func (container *Container) GetImage() (*graph.Image, error) {

 }

 func (container *Container) Mounted() (bool, error) {

-	return graph.Mounted(container.RootfsPath())

+	return Mounted(container.RootfsPath())

 }

 func (container *Container) Unmount() error {

-	return graph.Unmount(container.RootfsPath())

+	return Unmount(container.RootfsPath())

 }

 func (container *Container) logPath(name string) string {

new file mode 100644

@@ -0,0 +1,157 @@

+package docker

+

+import (

+	"fmt"

+	"io/ioutil"

+	"os"

+	"path"

+	"path/filepath"

+	"time"

+)

+

+type Graph struct {

+	Root string

+}

+

+func NewGraph(root string) (*Graph, error) {

+	abspath, err := filepath.Abs(root)

+	if err != nil {

+		return nil, err

+	}

+	// Create the root directory if it doesn't exists

+	if err := os.Mkdir(root, 0700); err != nil && !os.IsExist(err) {

+		return nil, err

+	}

+	return &Graph{

+		Root: abspath,

+	}, nil

+}

+

+func (graph *Graph) Exists(id string) bool {

+	if _, err := graph.Get(id); err != nil {

+		return false

+	}

+	return true

+}

+

+func (graph *Graph) Get(id string) (*Image, error) {

+	img, err := LoadImage(graph.imageRoot(id))

+	if err != nil {

+		return nil, err

+	}

+	if img.Id != id {

+		return nil, fmt.Errorf("Image stored at '%s' has wrong id '%s'", id, img.Id)

+	}

+	img.graph = graph

+	return img, nil

+}

+

+func (graph *Graph) Create(layerData Archive, parent, comment string) (*Image, error) {

+	img := &Image{

+		Id:      GenerateId(),

+		Parent:  parent,

+		Comment: comment,

+		Created: time.Now(),

+	}

+	if err := graph.Register(layerData, img); err != nil {

+		return nil, err

+	}

+	return img, nil

+}

+

+func (graph *Graph) Register(layerData Archive, img *Image) error {

+	if err := ValidateId(img.Id); err != nil {

+		return err

+	}

+	// (This is a convenience to save time. Race conditions are taken care of by os.Rename)

+	if graph.Exists(img.Id) {

+		return fmt.Errorf("Image %s already exists", img.Id)

+	}

+	tmp, err := graph.Mktemp(img.Id)

+	defer os.RemoveAll(tmp)

+	if err != nil {

+		return fmt.Errorf("Mktemp failed: %s", err)

+	}

+	if err := StoreImage(img, layerData, tmp); err != nil {

+		return err

+	}

+	// Commit

+	if err := os.Rename(tmp, graph.imageRoot(img.Id)); err != nil {

+		return err

+	}

+	img.graph = graph

+	return nil

+}

+

+func (graph *Graph) Mktemp(id string) (string, error) {

+	tmp, err := NewGraph(path.Join(graph.Root, ":tmp:"))

+	if err != nil {

+		return "", fmt.Errorf("Couldn't create temp: %s", err)

+	}

+	if tmp.Exists(id) {

+		return "", fmt.Errorf("Image %d already exists", id)

+	}

+	return tmp.imageRoot(id), nil

+}

+

+func (graph *Graph) Garbage() (*Graph, error) {

+	return NewGraph(path.Join(graph.Root, ":garbage:"))

+}

+

+func (graph *Graph) Delete(id string) error {

+	garbage, err := graph.Garbage()

+	if err != nil {

+		return err

+	}

+	return os.Rename(graph.imageRoot(id), garbage.imageRoot(id))

+}

+

+func (graph *Graph) Undelete(id string) error {

+	garbage, err := graph.Garbage()

+	if err != nil {

+		return err

+	}

+	return os.Rename(garbage.imageRoot(id), graph.imageRoot(id))

+}

+

+func (graph *Graph) GarbageCollect() error {

+	garbage, err := graph.Garbage()

+	if err != nil {

+		return err

+	}

+	return os.RemoveAll(garbage.Root)

+}

+

+func (graph *Graph) Map() (map[string]*Image, error) {

+	// FIXME: this should replace All()

+	all, err := graph.All()

+	if err != nil {

+		return nil, err

+	}

+	images := make(map[string]*Image, len(all))

+	for _, image := range all {

+		images[image.Id] = image

+	}

+	return images, nil

+}

+

+func (graph *Graph) All() ([]*Image, error) {

+	files, err := ioutil.ReadDir(graph.Root)

+	if err != nil {

+		return nil, err

+	}

+	var images []*Image

+	for _, st := range files {

+		if img, err := graph.Get(st.Name()); err != nil {

+			// Skip image

+			continue

+		} else {

+			images = append(images, img)

+		}

+	}

+	return images, nil

+}

+

+func (graph *Graph) imageRoot(id string) string {

+	return path.Join(graph.Root, id)

+}

deleted file mode 100644

@@ -1,75 +0,0 @@

-package graph

-

-import (

-	"errors"

-	"io"

-	"io/ioutil"

-	"os/exec"

-)

-

-type Archive io.Reader

-

-type Compression uint32

-

-const (

-	Uncompressed Compression = iota

-	Bzip2

-	Gzip

-)

-

-func (compression *Compression) Flag() string {

-	switch *compression {

-	case Bzip2:

-		return "j"

-	case Gzip:

-		return "z"

-	}

-	return ""

-}

-

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

-	cmd := exec.Command("bsdtar", "-f", "-", "-C", path, "-c"+compression.Flag(), ".")

-	return CmdStream(cmd)

-}

-

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

-	cmd := exec.Command("bsdtar", "-f", "-", "-C", path, "-x")

-	cmd.Stdin = archive

-	output, err := cmd.CombinedOutput()

-	if err != nil {

-		return errors.New(err.Error() + ": " + string(output))

-	}

-	return nil

-}

-

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

-	stdout, err := cmd.StdoutPipe()

-	if err != nil {

-		return nil, err

-	}

-	stderr, err := cmd.StderrPipe()

-	if err != nil {

-		return nil, err

-	}

-	pipeR, pipeW := io.Pipe()

-	go func() {

-		_, err := io.Copy(pipeW, stdout)

-		if err != nil {

-			pipeW.CloseWithError(err)

-		}

-		errText, e := ioutil.ReadAll(stderr)

-		if e != nil {

-			errText = []byte("(...couldn't fetch stderr: " + e.Error() + ")")

-		}

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

-			// FIXME: can this block if stderr outputs more than the size of StderrPipe()'s buffer?

-			pipeW.CloseWithError(errors.New(err.Error() + ": " + string(errText)))

-		} else {

-			pipeW.Close()

-		}

-	}()

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

-		return nil, err

-	}

-	return pipeR, nil

-}

deleted file mode 100644

@@ -1,54 +0,0 @@

-package graph

-

-import (

-	"io/ioutil"

-	"os"

-	"os/exec"

-	"testing"

-)

-

-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)

-	if err != nil {

-		t.Fatalf("Failed to start command: " + err.Error())

-	}

-	if output, err := ioutil.ReadAll(out); err == nil {

-		t.Fatalf("Command should have failed")

-	} else if err.Error() != "exit status 1: error couldn't reverse the phase pulser\n" {

-		t.Fatalf("Wrong error value (%s)", err.Error())

-	} else if s := string(output); s != "hello\n" {

-		t.Fatalf("Command output should be '%s', not '%s'", "hello\\n", output)

-	}

-}

-

-func TestCmdStreamGood(t *testing.T) {

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

-	out, err := CmdStream(cmd)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if output, err := ioutil.ReadAll(out); err != nil {

-		t.Fatalf("Command should not have failed (err=%s)", err)

-	} else if s := string(output); s != "hello\n" {

-		t.Fatalf("Command output should be '%s', not '%s'", "hello\\n", output)

-	}

-}

-

-func TestTarUntar(t *testing.T) {

-	archive, err := Tar(".", Uncompressed)

-	if err != nil {

-		t.Fatal(err)

-	}

-	tmp, err := ioutil.TempDir("", "docker-test-untar")

-	if err != nil {

-		t.Fatal(err)

-	}

-	defer os.RemoveAll(tmp)

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

-		t.Fatal(err)

-	}

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

-		t.Fatalf("Error stating %s: %s", tmp, err.Error())

-	}

-}

deleted file mode 100644

@@ -1,106 +0,0 @@

-package graph

-

-import (

-	"fmt"

-	"os"

-	"path/filepath"

-	"strings"

-)

-

-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 := strings.TrimLeft(file, ".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 {

-		return nil, err

-	}

-	return changes, nil

-}

deleted file mode 100644

@@ -1,157 +0,0 @@

-package graph

-

-import (

-	"fmt"

-	"io/ioutil"

-	"os"

-	"path"

-	"path/filepath"

-	"time"

-)

-

-type Graph struct {

-	Root string

-}

-

-func New(root string) (*Graph, error) {

-	abspath, err := filepath.Abs(root)

-	if err != nil {

-		return nil, err

-	}

-	// Create the root directory if it doesn't exists

-	if err := os.Mkdir(root, 0700); err != nil && !os.IsExist(err) {

-		return nil, err

-	}

-	return &Graph{

-		Root: abspath,

-	}, nil

-}

-

-func (graph *Graph) Exists(id string) bool {

-	if _, err := graph.Get(id); err != nil {

-		return false

-	}

-	return true

-}

-

-func (graph *Graph) Get(id string) (*Image, error) {

-	img, err := LoadImage(graph.imageRoot(id))

-	if err != nil {

-		return nil, err

-	}

-	if img.Id != id {

-		return nil, fmt.Errorf("Image stored at '%s' has wrong id '%s'", id, img.Id)

-	}

-	img.graph = graph

-	return img, nil

-}

-

-func (graph *Graph) Create(layerData Archive, parent, comment string) (*Image, error) {

-	img := &Image{

-		Id:      GenerateId(),

-		Parent:  parent,

-		Comment: comment,

-		Created: time.Now(),

-	}

-	if err := graph.Register(layerData, img); err != nil {

-		return nil, err

-	}

-	return img, nil

-}

-

-func (graph *Graph) Register(layerData Archive, img *Image) error {

-	if err := ValidateId(img.Id); err != nil {

-		return err

-	}

-	// (This is a convenience to save time. Race conditions are taken care of by os.Rename)

-	if graph.Exists(img.Id) {

-		return fmt.Errorf("Image %s already exists", img.Id)

-	}

-	tmp, err := graph.Mktemp(img.Id)

-	defer os.RemoveAll(tmp)

-	if err != nil {

-		return fmt.Errorf("Mktemp failed: %s", err)

-	}

-	if err := StoreImage(img, layerData, tmp); err != nil {

-		return err

-	}

-	// Commit

-	if err := os.Rename(tmp, graph.imageRoot(img.Id)); err != nil {

-		return err

-	}

-	img.graph = graph

-	return nil

-}

-

-func (graph *Graph) Mktemp(id string) (string, error) {

-	tmp, err := New(path.Join(graph.Root, ":tmp:"))

-	if err != nil {

-		return "", fmt.Errorf("Couldn't create temp: %s", err)

-	}

-	if tmp.Exists(id) {

-		return "", fmt.Errorf("Image %d already exists", id)

-	}

-	return tmp.imageRoot(id), nil

-}

-

-func (graph *Graph) Garbage() (*Graph, error) {

-	return New(path.Join(graph.Root, ":garbage:"))

-}

-

-func (graph *Graph) Delete(id string) error {

-	garbage, err := graph.Garbage()

-	if err != nil {

-		return err

-	}

-	return os.Rename(graph.imageRoot(id), garbage.imageRoot(id))

-}

-

-func (graph *Graph) Undelete(id string) error {

-	garbage, err := graph.Garbage()

-	if err != nil {

-		return err

-	}

-	return os.Rename(garbage.imageRoot(id), graph.imageRoot(id))

-}

-

-func (graph *Graph) GarbageCollect() error {

-	garbage, err := graph.Garbage()

-	if err != nil {

-		return err

-	}

-	return os.RemoveAll(garbage.Root)

-}

-

-func (graph *Graph) Map() (map[string]*Image, error) {

-	// FIXME: this should replace All()

-	all, err := graph.All()

-	if err != nil {

-		return nil, err

-	}

-	images := make(map[string]*Image, len(all))

-	for _, image := range all {

-		images[image.Id] = image

-	}

-	return images, nil

-}

-

-func (graph *Graph) All() ([]*Image, error) {

-	files, err := ioutil.ReadDir(graph.Root)

-	if err != nil {

-		return nil, err