@@ -1,6 +1,5 @@

 .vagrant

 docker/docker

-dockerd/dockerd

 .*.swp

 a.out

 *.orig

deleted file mode 100644

@@ -1,53 +0,0 @@

-package client

-

-import (

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

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

-	"io"

-	"log"

-	"os"

-)

-

-// Run docker in "simple mode": run a single command and return.

-func SimpleMode(args []string) error {

-	var oldState *State

-	var err error

-	if IsTerminal(0) && os.Getenv("NORAW") == "" {

-		oldState, err = MakeRaw(0)

-		if err != nil {

-			return err

-		}

-		defer Restore(0, oldState)

-	}

-	// FIXME: we want to use unix sockets here, but net.UnixConn doesn't expose

-	// CloseWrite(), which we need to cleanly signal that stdin is closed without

-	// closing the connection.

-	// See http://code.google.com/p/go/issues/detail?id=3345

-	conn, err := rcli.Call("tcp", "127.0.0.1:4242", args...)

-	if err != nil {

-		return err

-	}

-	receive_stdout := future.Go(func() error {

-		_, err := io.Copy(os.Stdout, conn)

-		return err

-	})

-	send_stdin := future.Go(func() error {

-		_, err := io.Copy(conn, os.Stdin)

-		if err := conn.CloseWrite(); err != nil {

-			log.Printf("Couldn't send EOF: " + err.Error())

-		}

-		return err

-	})

-	if err := <-receive_stdout; err != nil {

-		return err

-	}

-	if oldState != nil {

-		Restore(0, oldState)

-	}

-	if !IsTerminal(0) {

-		if err := <-send_stdin; err != nil {

-			return err

-		}

-	}

-	return nil

-}

deleted file mode 100644

@@ -1,143 +0,0 @@

-package client

-

-import (

-	"syscall"

-	"unsafe"

-)

-

-type Termios struct {

-	Iflag  uintptr

-	Oflag  uintptr

-	Cflag  uintptr

-	Lflag  uintptr

-	Cc     [20]byte

-	Ispeed uintptr

-	Ospeed uintptr

-}

-

-const (

-	// Input flags

-	inpck  = 0x010

-	istrip = 0x020

-	icrnl  = 0x100

-	ixon   = 0x200

-

-	// Output flags

-	opost = 0x1

-

-	// Control flags

-	cs8 = 0x300

-

-	// Local flags

-	icanon = 0x100

-	iexten = 0x400

-)

-

-const (

-	HUPCL   = 0x4000

-	ICANON  = 0x100

-	ICRNL   = 0x100

-	IEXTEN  = 0x400

-	BRKINT  = 0x2

-	CFLUSH  = 0xf

-	CLOCAL  = 0x8000

-	CREAD   = 0x800

-	CS5     = 0x0

-	CS6     = 0x100

-	CS7     = 0x200

-	CS8     = 0x300

-	CSIZE   = 0x300

-	CSTART  = 0x11

-	CSTATUS = 0x14

-	CSTOP   = 0x13

-	CSTOPB  = 0x400

-	CSUSP   = 0x1a

-	IGNBRK  = 0x1

-	IGNCR   = 0x80

-	IGNPAR  = 0x4

-	IMAXBEL = 0x2000

-	INLCR   = 0x40

-	INPCK   = 0x10

-	ISIG    = 0x80

-	ISTRIP  = 0x20

-	IUTF8   = 0x4000

-	IXANY   = 0x800

-	IXOFF   = 0x400

-	IXON    = 0x200

-	NOFLSH  = 0x80000000

-	OCRNL   = 0x10

-	OFDEL   = 0x20000

-	OFILL   = 0x80

-	ONLCR   = 0x2

-	ONLRET  = 0x40

-	ONOCR   = 0x20

-	ONOEOT  = 0x8

-	OPOST   = 0x1

-	RENB    = 0x1000

-	PARMRK  = 0x8

-	PARODD  = 0x2000

-

-	TOSTOP   = 0x400000

-	VDISCARD = 0xf

-	VDSUSP   = 0xb

-	VEOF     = 0x0

-	VEOL     = 0x1

-	VEOL2    = 0x2

-	VERASE   = 0x3

-	VINTR    = 0x8

-	VKILL    = 0x5

-	VLNEXT   = 0xe

-	VMIN     = 0x10

-	VQUIT    = 0x9

-	VREPRINT = 0x6

-	VSTART   = 0xc

-	VSTATUS  = 0x12

-	VSTOP    = 0xd

-	VSUSP    = 0xa

-	VT0      = 0x0

-	VT1      = 0x10000

-	VTDLY    = 0x10000

-	VTIME    = 0x11

-	ECHO     = 0x00000008

-

-	PENDIN = 0x20000000

-)

-

-type State struct {

-	termios Termios

-}

-

-// IsTerminal returns true if the given file descriptor is a terminal.

-func IsTerminal(fd int) bool {

-	var termios Termios

-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&termios)), 0, 0, 0)

-	return err == 0

-}

-

-// MakeRaw put the terminal connected to the given file descriptor into raw

-// mode and returns the previous state of the terminal so that it can be

-// restored.

-func MakeRaw(fd int) (*State, error) {

-	var oldState State

-	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(getTermios), uintptr(unsafe.Pointer(&oldState.termios)), 0, 0, 0); err != 0 {

-		return nil, err

-	}

-

-	newState := oldState.termios

-	newState.Iflag &^= ISTRIP | INLCR | IGNCR | IXON | IXOFF

-	newState.Iflag |= ICRNL

-	newState.Oflag |= ONLCR

-	newState.Lflag &^= ECHO | ICANON | ISIG

-	if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 {

-		return nil, err

-	}

-

-	return &oldState, nil

-}

-

-// Restore restores the terminal connected to the given file descriptor to a

-// previous state.

-func Restore(fd int, state *State) error {

-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(setTermios), uintptr(unsafe.Pointer(&state.termios)), 0, 0, 0)

-	return err

-}

deleted file mode 100644

@@ -1,8 +0,0 @@

-package client

-

-import "syscall"

-

-const (

-	getTermios = syscall.TIOCGETA

-	setTermios = syscall.TIOCSETA

-)

deleted file mode 100644

@@ -1,8 +0,0 @@

-package client

-

-import "syscall"

-

-const (

-	getTermios = syscall.TCGETS

-	setTermios = syscall.TCSETS

-)

new file mode 100644

@@ -0,0 +1,977 @@

+package commands

+

+import (

+	"bufio"

+	"bytes"

+	"encoding/json"

+	"errors"

+	"fmt"

+	"github.com/dotcloud/docker"

+	"github.com/dotcloud/docker/fs"

+	"github.com/dotcloud/docker/future"

+	"github.com/dotcloud/docker/rcli"

+	"io"

+	"net/http"

+	"net/url"

+	"os"

+	"path"

+	"strconv"

+	"strings"

+	"sync"

+	"text/tabwriter"

+	"time"

+)

+

+const VERSION = "0.0.1"

+

+func (srv *Server) Name() string {

+	return "docker"

+}

+

+// FIXME: Stop violating DRY by repeating usage here and in Subcmd declarations

+func (srv *Server) Help() string {

+	help := "Usage: docker COMMAND [arg...]\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n"

+	for _, cmd := range [][]interface{}{

+		{"run", "Run a command in a container"},

+		{"ps", "Display a list of containers"},

+		{"import", "Create a new filesystem image from the contents of a tarball"},

+		{"attach", "Attach to a running container"},

+		{"cat", "Write the contents of a container's file to standard output"},

+		{"commit", "Create a new image from a container's changes"},

+		{"cp", "Create a copy of IMAGE and call it NAME"},

+		{"debug", "(debug only) (No documentation available)"},

+		{"diff", "Inspect changes on a container's filesystem"},

+		{"images", "List images"},

+		{"info", "Display system-wide information"},

+		{"inspect", "Return low-level information on a container"},

+		{"kill", "Kill a running container"},

+		{"layers", "(debug only) List filesystem layers"},

+		{"logs", "Fetch the logs of a container"},

+		{"ls", "List the contents of a container's directory"},

+		{"mirror", "(debug only) (No documentation available)"},

+		{"port", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT"},

+		{"ps", "List containers"},

+		{"reset", "Reset changes to a container's filesystem"},

+		{"restart", "Restart a running container"},

+		{"rm", "Remove a container"},

+		{"rmimage", "Remove an image"},

+		{"run", "Run a command in a new container"},

+		{"start", "Start a stopped container"},

+		{"stop", "Stop a running container"},

+		{"tar", "Stream the contents of a container as a tar archive"},

+		{"umount", "(debug only) Mount a container's filesystem"},

+		{"version", "Show the docker version information"},

+		{"wait", "Block until a container stops, then print its exit code"},

+		{"web", "A web UI for docker"},

+		{"write", "Write the contents of standard input to a container's file"},

+	} {

+		help += fmt.Sprintf("    %-10.10s%s\n", cmd...)

+	}

+	return help

+}

+

+// 'docker wait': block until a container stops

+func (srv *Server) CmdWait(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "wait", "[OPTIONS] NAME", "Block until a container stops, then print its exit code.")

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

+		return nil

+	}

+	if cmd.NArg() < 1 {

+		cmd.Usage()

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		if container := srv.containers.Get(name); container != nil {

+			fmt.Fprintln(stdout, container.Wait())

+		} else {

+			return errors.New("No such container: " + name)

+		}

+	}

+	return nil

+}

+

+// 'docker version': show version information

+func (srv *Server) CmdVersion(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	fmt.Fprintf(stdout, "Version:%s\n", VERSION)

+	return nil

+}

+

+// 'docker info': display system-wide information.

+func (srv *Server) CmdInfo(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	images, _ := srv.images.Images()

+	var imgcount int

+	if images == nil {

+		imgcount = 0

+	} else {

+		imgcount = len(images)

+	}

+	cmd := rcli.Subcmd(stdout, "info", "", "Display system-wide information.")

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

+		return nil

+	}

+	if cmd.NArg() > 0 {

+		cmd.Usage()

+		return nil

+	}

+	fmt.Fprintf(stdout, "containers: %d\nversion: %s\nimages: %d\n",

+		len(srv.containers.List()),

+		VERSION,

+		imgcount)

+	return nil

+}

+

+func (srv *Server) CmdStop(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "stop", "[OPTIONS] NAME", "Stop a running container")

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

+		return nil

+	}

+	if cmd.NArg() < 1 {

+		cmd.Usage()

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		if container := srv.containers.Get(name); container != nil {

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

+				return err

+			}

+			fmt.Fprintln(stdout, container.Id)

+		} else {

+			return errors.New("No such container: " + name)

+		}

+	}

+	return nil

+}

+

+func (srv *Server) CmdRestart(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "restart", "[OPTIONS] NAME", "Restart a running container")

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

+		return nil

+	}

+	if cmd.NArg() < 1 {

+		cmd.Usage()

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		if container := srv.containers.Get(name); container != nil {

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

+				return err

+			}

+			fmt.Fprintln(stdout, container.Id)

+		} else {

+			return errors.New("No such container: " + name)

+		}

+	}

+	return nil

+}

+

+func (srv *Server) CmdStart(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "start", "[OPTIONS] NAME", "Start a stopped container")

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

+		return nil

+	}

+	if cmd.NArg() < 1 {

+		cmd.Usage()

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		if container := srv.containers.Get(name); container != nil {

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

+				return err

+			}

+			fmt.Fprintln(stdout, container.Id)

+		} else {

+			return errors.New("No such container: " + name)

+		}

+	}

+	return nil

+}

+

+func (srv *Server) CmdUmount(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "umount", "[OPTIONS] NAME", "umount a container's filesystem (debug only)")

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

+		return nil

+	}

+	if cmd.NArg() < 1 {

+		cmd.Usage()

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		if container := srv.containers.Get(name); container != nil {

+			if err := container.Mountpoint.Umount(); err != nil {

+				return err

+			}

+			fmt.Fprintln(stdout, container.Id)

+		} else {

+			return errors.New("No such container: " + name)

+		}

+	}

+	return nil

+}

+

+func (srv *Server) CmdMount(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "umount", "[OPTIONS] NAME", "mount a container's filesystem (debug only)")

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

+		return nil

+	}

+	if cmd.NArg() < 1 {

+		cmd.Usage()

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		if container := srv.containers.Get(name); container != nil {

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

+				return err

+			}

+			fmt.Fprintln(stdout, container.Id)

+		} else {

+			return errors.New("No such container: " + name)

+		}

+	}

+	return nil

+}

+

+func (srv *Server) CmdCat(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "cat", "[OPTIONS] CONTAINER PATH", "write the contents of a container's file to standard output")

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

+		return nil

+	}

+	if cmd.NArg() < 2 {

+		cmd.Usage()

+		return nil

+	}

+	name, path := cmd.Arg(0), cmd.Arg(1)

+	if container := srv.containers.Get(name); container != nil {

+		if f, err := container.Mountpoint.OpenFile(path, os.O_RDONLY, 0); err != nil {

+			return err

+		} else if _, err := io.Copy(stdout, f); err != nil {

+			return err

+		}

+		return nil

+	}

+	return errors.New("No such container: " + name)

+}

+

+func (srv *Server) CmdWrite(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "write", "[OPTIONS] CONTAINER PATH", "write the contents of standard input to a container's file")

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

+		return nil

+	}

+	if cmd.NArg() < 2 {

+		cmd.Usage()

+		return nil

+	}

+	name, path := cmd.Arg(0), cmd.Arg(1)

+	if container := srv.containers.Get(name); container != nil {

+		if f, err := container.Mountpoint.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0600); err != nil {

+			return err

+		} else if _, err := io.Copy(f, stdin); err != nil {

+			return err

+		}

+		return nil

+	}

+	return errors.New("No such container: " + name)

+}

+

+func (srv *Server) CmdLs(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "ls", "[OPTIONS] CONTAINER PATH", "List the contents of a container's directory")

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

+		return nil

+	}

+	if cmd.NArg() < 2 {

+		cmd.Usage()

+		return nil

+	}

+	name, path := cmd.Arg(0), cmd.Arg(1)

+	if container := srv.containers.Get(name); container != nil {

+		if files, err := container.Mountpoint.ReadDir(path); err != nil {

+			return err

+		} else {

+			for _, f := range files {

+				fmt.Fprintln(stdout, f.Name())

+			}

+		}

+		return nil

+	}

+	return errors.New("No such container: " + name)

+}

+

+func (srv *Server) CmdInspect(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "inspect", "[OPTIONS] CONTAINER", "Return low-level information on a container")

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

+		return nil

+	}

+	if cmd.NArg() < 1 {

+		cmd.Usage()

+		return nil

+	}

+	name := cmd.Arg(0)

+	var obj interface{}

+	if container := srv.containers.Get(name); container != nil {

+		obj = container

+		//} else if image, err := srv.images.List(name); image != nil {

+		//	obj = image

+	} else {

+		return errors.New("No such container or image: " + name)

+	}

+	data, err := json.Marshal(obj)

+	if err != nil {

+		return err

+	}

+	indented := new(bytes.Buffer)

+	if err = json.Indent(indented, data, "", "    "); err != nil {

+		return err

+	}

+	if _, err := io.Copy(stdout, indented); err != nil {

+		return err

+	}

+	return nil

+}

+

+func (srv *Server) CmdPort(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "port", "[OPTIONS] CONTAINER PRIVATE_PORT", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT")

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

+		return nil

+	}

+	if cmd.NArg() != 2 {

+		cmd.Usage()

+		return nil

+	}

+	name := cmd.Arg(0)

+	privatePort := cmd.Arg(1)

+	if container := srv.containers.Get(name); container == nil {

+		return errors.New("No such container: " + name)

+	} else {

+		if frontend, exists := container.NetworkSettings.PortMapping[privatePort]; !exists {

+			return fmt.Errorf("No private port '%s' allocated on %s", privatePort, name)

+		} else {

+			fmt.Fprintln(stdout, frontend)

+		}

+	}

+	return nil

+}

+

+// 'docker rmi NAME' removes all images with the name NAME

+// func (srv *Server) CmdRmi(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+// 	cmd := rcli.Subcmd(stdout, "rmimage", "[OPTIONS] IMAGE", "Remove an image")

+// 	fl_regexp := cmd.Bool("r", false, "Use IMAGE as a regular expression instead of an exact name")

+// 	if err := cmd.Parse(args); err != nil {

+// 		cmd.Usage()

+// 		return nil

+// 	}

+// 	if cmd.NArg() < 1 {

+// 		cmd.Usage()

+// 		return nil

+// 	}

+// 	for _, name := range cmd.Args() {

+// 		var err error

+// 		if *fl_regexp {

+// 			err = srv.images.DeleteMatch(name)

+// 		} else {

+// 			image := srv.images.Find(name)

+// 			if image == nil {

+// 				return errors.New("No such image: " + name)

+// 			}

+// 			err = srv.images.Delete(name)

+// 		}

+// 		if err != nil {

+// 			return err

+// 		}

+// 	}

+// 	return nil

+// }

+

+func (srv *Server) CmdRm(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "rm", "[OPTIONS] CONTAINER", "Remove a container")

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

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		container := srv.containers.Get(name)

+		if container == nil {

+			return errors.New("No such container: " + name)

+		}

+		if err := srv.containers.Destroy(container); err != nil {

+			fmt.Fprintln(stdout, "Error destroying container "+name+": "+err.Error())

+		}

+	}

+	return nil

+}

+

+// 'docker kill NAME' kills a running container

+func (srv *Server) CmdKill(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "kill", "[OPTIONS] CONTAINER [CONTAINER...]", "Kill a running container")

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

+		return nil

+	}

+	for _, name := range cmd.Args() {

+		container := srv.containers.Get(name)

+		if container == nil {

+			return errors.New("No such container: " + name)

+		}

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

+			fmt.Fprintln(stdout, "Error killing container "+name+": "+err.Error())

+		}

+	}

+	return nil

+}

+

+func (srv *Server) CmdImport(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "import", "[OPTIONS] NAME", "Create a new filesystem image from the contents of a tarball")

+	fl_stdin := cmd.Bool("stdin", false, "Read tarball from stdin")

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

+		return nil

+	}

+	var archive io.Reader

+	name := cmd.Arg(0)

+	if name == "" {

+		return errors.New("Not enough arguments")

+	}

+	if *fl_stdin {

+		archive = stdin

+	} else {

+		u, err := url.Parse(name)

+		if err != nil {

+			return err

+		}

+		if u.Scheme == "" {

+			u.Scheme = "http"

+		}

+		// FIXME: hardcode a mirror URL that does not depend on a single provider.

+		if u.Host == "" {

+			u.Host = "s3.amazonaws.com"

+			u.Path = path.Join("/docker.io/images", u.Path)

+		}

+		fmt.Fprintf(stdout, "Downloading from %s\n", u.String())

+		// Download with curl (pretty progress bar)

+		// If curl is not available, fallback to http.Get()

+		archive, err = future.Curl(u.String(), stdout)

+		if err != nil {

+			if resp, err := http.Get(u.String()); err != nil {

+				return err

+			} else {

+				archive = resp.Body

+			}

+		}

+	}

+	fmt.Fprintf(stdout, "Unpacking to %s\n", name)

+	img, err := srv.images.Create(archive, nil, name, "")

+	if err != nil {

+		return err

+	}

+	fmt.Fprintln(stdout, img.Id)

+	return nil

+}

+

+func (srv *Server) CmdImages(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout, "images", "[OPTIONS] [NAME]", "List images")

+	limit := cmd.Int("l", 0, "Only show the N most recent versions of each image")

+	quiet := cmd.Bool("q", false, "only show numeric IDs")

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

+		return nil

+	}

+	if cmd.NArg() > 1 {

+		cmd.Usage()

+		return nil

+	}

+	var nameFilter string

+	if cmd.NArg() == 1 {

+		nameFilter = cmd.Arg(0)

+	}

+	w := tabwriter.NewWriter(stdout, 20, 1, 3, ' ', 0)

+	if !*quiet {

+		fmt.Fprintf(w, "NAME\tID\tCREATED\tPARENT\n")

+	}

+	paths, err := srv.images.Paths()

+	if err != nil {

+		return err

+	}

+	for _, name := range paths {

+		if nameFilter != "" && nameFilter != name {

+			continue

+		}

+		ids, err := srv.images.List(name)

+		if err != nil {

+			return err

+		}

+		for idx, img := range ids {

+			if *limit > 0 && idx >= *limit {

+				break

+			}

+			if !*quiet {

+				for idx, field := range []string{

+					/* NAME */ name,

+					/* ID */ img.Id,

+					/* CREATED */ future.HumanDuration(time.Now().Sub(time.Unix(img.Created, 0))) + " ago",

+					/* PARENT */ img.Parent,

+				} {

+					if idx == 0 {

+						w.Write([]byte(field))

+					} else {

+						w.Write([]byte("\t" + field))

+					}

+				}

+				w.Write([]byte{'\n'})

+			} else {

+				stdout.Write([]byte(img.Id + "\n"))

+			}

+		}

+	}

+	if !*quiet {

+		w.Flush()

+	}

+	return nil

+

+}

+

+func (srv *Server) CmdPs(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout,

+		"ps", "[OPTIONS]", "List containers")

+	quiet := cmd.Bool("q", false, "Only display numeric IDs")

+	fl_all := cmd.Bool("a", false, "Show all containers. Only running containers are shown by default.")

+	fl_full := cmd.Bool("notrunc", false, "Don't truncate output")

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

+		return nil

+	}

+	w := tabwriter.NewWriter(stdout, 12, 1, 3, ' ', 0)

+	if !*quiet {

+		fmt.Fprintf(w, "ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tCOMMENT\n")

+	}

+	for _, container := range srv.containers.List() {

+		comment := container.GetUserData("comment")

+		if !container.State.Running && !*fl_all {

+			continue

+		}

+		if !*quiet {

+			command := fmt.Sprintf("%s %s", container.Path, strings.Join(container.Args, " "))

+			if !*fl_full {

+				command = docker.Trunc(command, 20)

+			}

+			for idx, field := range []string{

+				/* ID */ container.Id,

+				/* IMAGE */ container.GetUserData("image"),

+				/* COMMAND */ command,

+				/* CREATED */ future.HumanDuration(time.Now().Sub(container.Created)) + " ago",

+				/* STATUS */ container.State.String(),

+				/* COMMENT */ comment,

+			} {

+				if idx == 0 {

+					w.Write([]byte(field))

+				} else {

+					w.Write([]byte("\t" + field))

+				}

+			}

+			w.Write([]byte{'\n'})

+		} else {

+			stdout.Write([]byte(container.Id + "\n"))

+		}

+	}

+	if !*quiet {

+		w.Flush()

+	}

+	return nil

+}

+

+func (srv *Server) CmdLayers(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout,

+		"layers", "[OPTIONS]",

+		"List filesystem layers (debug only)")

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

+		return nil

+	}

+	for _, layer := range srv.images.Layers() {

+		fmt.Fprintln(stdout, layer)

+	}

+	return nil

+}

+

+func (srv *Server) CmdCp(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout,

+		"cp", "[OPTIONS] IMAGE NAME",

+		"Create a copy of IMAGE and call it NAME")

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

+		return nil

+	}

+	if image, err := srv.images.Get(cmd.Arg(0)); err != nil {

+		return err

+	} else if image == nil {

+		return errors.New("Image " + cmd.Arg(0) + " does not exist")

+	} else {

+		if img, err := image.Copy(cmd.Arg(1)); err != nil {

+			return err

+		} else {

+			fmt.Fprintln(stdout, img.Id)

+		}

+	}

+	return nil

+}

+

+func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout,

+		"commit", "[OPTIONS] CONTAINER [DEST]",

+		"Create a new image from a container's changes")

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

+		return nil

+	}

+	containerName, imgName := cmd.Arg(0), cmd.Arg(1)

+	if containerName == "" || imgName == "" {

+		cmd.Usage()

+		return nil

+	}

+	if container := srv.containers.Get(containerName); container != nil {

+		// FIXME: freeze the container before copying it to avoid data corruption?

+		rwTar, err := fs.Tar(container.Mountpoint.Rw, fs.Uncompressed)

+		if err != nil {

+			return err

+		}

+		// Create a new image from the container's base layers + a new layer from container changes

+		parentImg, err := srv.images.Get(container.Image)

+		if err != nil {

+			return err

+		}

+

+		img, err := srv.images.Create(rwTar, parentImg, imgName, "")

+		if err != nil {

+			return err

+		}

+

+		fmt.Fprintln(stdout, img.Id)

+		return nil

+	}

+	return errors.New("No such container: " + containerName)

+}

+

+func (srv *Server) CmdTar(stdin io.ReadCloser, stdout io.Writer, args ...string) error {

+	cmd := rcli.Subcmd(stdout,