Merge branch 'master' of github.com:dotcloud/docker

docker/docker.go

@@ -2,44 +2,196 @@ package main
 
 import (
 	"io"
+	"encoding/json"
 	"log"
 	"os"
-	"net/http"
-	"net/url"
+	"net"
+	"fmt"
+	"syscall"
+"unsafe"
 )
 
 
-// Use this key to encode an RPC call into an URL,
-// eg. domain.tld/path/to/method?q=get_user&q=gordon
-const ARG_URL_KEY = "q"
-
-func CallToURL(host string, cmd string, args []string) *url.URL {
-    qValues := make(url.Values)
-    for _, v := range args {
-        qValues.Add(ARG_URL_KEY, v)
-    }
-    return &url.URL{
-	Scheme:     "http",
-	Host:       host,
-        Path:       "/" + cmd,
-        RawQuery:   qValues.Encode(),
-    }
+type Termios struct {
+	Iflag  uintptr
+	Oflag  uintptr
+	Cflag  uintptr
+	Lflag  uintptr
+	Cc     [20]byte
+	Ispeed uintptr
+	Ospeed uintptr
+}
+
+const (
+	getTermios = syscall.TIOCGETA
+	setTermios = syscall.TIOCSETA
+)
+
+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 | ICRNL | IGNCR | IXON | IXOFF
+        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
+}
+
+var oldState *State
+
+func Fatal(err error) {
+	if oldState != nil {
+		Restore(0, oldState)
+	}
+	log.Fatal(err)
 }
 
 
 func main() {
-	var cmd string
-	var args []string
-	if len(os.Args) >= 2 {
-		cmd = os.Args[1]
+	var err error
+	if IsTerminal(0) {
+		oldState, err = MakeRaw(0)
+		if err != nil {
+			panic(err)
+		}
+		defer Restore(0, oldState)
 	}
-	if len(os.Args) >= 3 {
-		args = os.Args[2:]
+	cmd, err := json.Marshal(os.Args[1:])
+	if err != nil {
+		Fatal(err)
 	}
-	u := CallToURL(os.Getenv("DOCKER"), cmd, args)
-	resp, err := http.Get(u.String())
+	conn, err := net.Dial("tcp", os.Getenv("DOCKER"))
 	if err != nil {
-		log.Fatal(err)
+		Fatal(err)
+	}
+	if _, err := fmt.Fprintln(conn, string(cmd)); err != nil {
+		Fatal(err)
+	}
+	go func() {
+		if _, err := io.Copy(os.Stdout, conn); err != nil {
+			Fatal(err)
+		}
+		Restore(0, oldState)
+		os.Exit(0)
+	}()
+	if _, err := io.Copy(conn, os.Stdin); err != nil {
+		Fatal(err)
 	}
-	io.Copy(os.Stdout, resp.Body)
+	Restore(0, oldState)
 }

dockerd/dockerd.go

@@ -1,12 +1,14 @@
 package main
 
 import (
+	"bufio"
 	"errors"
 	"log"
 	"io"
 	"io/ioutil"
-	"net/http"
+	"net"
 	"net/url"
+	"net/http"
 	"os/exec"
 	"flag"
 	"reflect"
@@ -22,6 +24,7 @@ import (
 	"sort"
 	"os"
 	"archive/tar"
+	"encoding/json"
 )
 
 func (docker *Docker) CmdHelp(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
@@ -29,16 +32,15 @@ func (docker *Docker) CmdHelp(stdin io.ReadCloser, stdout io.Writer, args ...str
 		fmt.Fprintf(stdout, "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"},
-			{"clone", "Duplicate a container"},
 			{"list", "Display a list of containers"},
-			{"layers", "Display a list of layers"},
-			{"get", "Download a layer from a remote location"},
-			{"rm", "Remove layers"},
+			{"get", "Download a tarball and create a container from it"},
+			{"put", "Upload a tarball and create a container from it"},
+			{"rm", "Remove containers"},
 			{"wait", "Wait for the state of a container to change"},
 			{"stop", "Stop a running container"},
 			{"logs", "Fetch the logs of a container"},
 			{"diff", "Inspect changes on a container's filesystem"},
-			{"snapshot", "Create a new layer from a container's filesystem"},
+			{"fork", "Duplicate a container"},
 			{"attach", "Attach to the standard inputs and outputs of a running container"},
 			{"info", "Display system-wide information"},
 			{"web", "Generate a web UI"},
@@ -55,10 +57,10 @@ func (docker *Docker) CmdHelp(stdin io.ReadCloser, stdout io.Writer, args ...str
 	return nil
 }
 
-func (docker *Docker) CmdLayers(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
-	flags := Subcmd(stdout, "layers", "[OPTIONS] [NAME]", "Show available filesystem layers")
-	quiet := flags.Bool("q", false, "Quiet mode")
-	limit := flags.Int("l", 0, "Only show the N most recent versions of each layer")
+func (docker *Docker) CmdList(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
+	flags := Subcmd(stdout, "list", "[OPTIONS] [NAME]", "List containers")
+	limit := flags.Int("l", 0, "Only show the N most recent versions of each name")
+	quiet := flags.Bool("q", false, "only show numeric IDs")
 	flags.Parse(args)
 	if flags.NArg() > 1 {
 		flags.Usage()
@@ -69,26 +71,42 @@ func (docker *Docker) CmdLayers(stdin io.ReadCloser, stdout io.Writer, args ...s
 		nameFilter = flags.Arg(0)
 	}
 	var names []string
-	for name := range docker.layersByName {
+	for name := range docker.containersByName {
 		names = append(names, name)
 	}
 	sort.Strings(names)
 	w := tabwriter.NewWriter(stdout, 20, 1, 3, ' ', 0)
 	if (!*quiet) {
-		fmt.Fprintf(w, "ID\tNAME\tSIZE\tADDED\tSOURCE\n")
+		fmt.Fprintf(w, "NAME\tID\tCREATED\tSOURCE\tSIZE\tCHANGES\tRUNNING\tCOMMAND\n")
 	}
 	for _, name := range names {
 		if nameFilter != "" && nameFilter != name {
 			continue
 		}
-		for idx, layer := range *docker.layersByName[name] {
+		for idx, container := range *docker.containersByName[name] {
 			if *limit > 0 && idx >= *limit {
 				break
 			}
 			if !*quiet {
-				fmt.Fprintf(w, "%s\t%s\t%.1fM\t%s ago\t%s\n", layer.Id, layer.Name, float32(layer.Size) / 1024 / 1024, humanDuration(time.Now().Sub(layer.Added)), layer.Source)
+				for idx, field := range []string{
+					/* NAME */	container.Name,
+					/* ID */	container.Id,
+					/* CREATED */	humanDuration(time.Now().Sub(container.Created)) + " ago",
+					/* SOURCE */	container.Source,
+					/* SIZE */	fmt.Sprintf("%.1fM", float32(container.Size) / 1024 / 1024),
+					/* CHANGES */	fmt.Sprintf("%.1fM", float32(container.BytesChanged) / 1024 / 1024),
+					/* RUNNING */	fmt.Sprintf("%v", container.Running),
+					/* COMMAND */	container.CmdString(),
+				} {
+					if idx == 0 {
+						w.Write([]byte(field))
+					} else {
+						w.Write([]byte("\t" + field))
+					}
+				}
+				w.Write([]byte{'\n'})
 			} else {
-				stdout.Write([]byte(layer.Id + "\n"))
+				stdout.Write([]byte(container.Id + "\n"))
 			}
 		}
 	}
@@ -98,37 +116,26 @@ func (docker *Docker) CmdLayers(stdin io.ReadCloser, stdout io.Writer, args ...s
 	return nil
 }
 
-func (docker *Docker) findLayer(name string) (*Layer, bool) {
-	// 1: look for layer by ID
-	if layer, exists := docker.layers[name]; exists {
-		return layer, true
+func (docker *Docker) findContainer(name string) (*Container, bool) {
+	// 1: look for container by ID
+	if container, exists := docker.containers[name]; exists {
+		return container, true
 	}
-	// 2: look for a layer by name (and pick the most recent)
-	if layers, exists := docker.layersByName[name]; exists {
-		return (*layers)[0], true
+	// 2: look for a container by name (and pick the most recent)
+	if containers, exists := docker.containersByName[name]; exists {
+		return (*containers)[0], true
 	}
 	return nil, false
 }
 
-func (docker *Docker) usingLayer(layer *Layer) []*Container {
-	var containers []*Container
-	for _, container := range docker.containers {
-		for _, l := range container.Layers {
-			if l.Id == layer.Id {
-				containers = append(containers, &container)
-			}
-		}
-	}
-	return containers
-}
 
 func (docker *Docker) CmdRm(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
-	flags := Subcmd(stdout, "rm", "[OPTIONS LAYER", "Remove a layer")
+	flags := Subcmd(stdout, "rm", "[OPTIONS] CONTAINER", "Remove a container")
 	if err := flags.Parse(args); err != nil {
 		return nil
 	}
 	for _, name := range flags.Args() {
-		if _, err := docker.rmLayer(name); err != nil {
+		if _, err := docker.rm(name); err != nil {
 			fmt.Fprintln(stdout, "Error: " + err.Error())
 		}
 	}
@@ -140,7 +147,7 @@ func (docker *Docker) CmdGet(stdin io.ReadCloser, stdout io.Writer, args ...stri
 		return errors.New("Not enough arguments")
 	}
 	time.Sleep(2 * time.Second)
-	layer := docker.addLayer(args[0], "download", 0)
+	layer := docker.addContainer(args[0], "download", 0)
 	fmt.Fprintln(stdout, layer.Id)
 	return nil
 }
@@ -150,46 +157,48 @@ func (docker *Docker) CmdPut(stdin io.ReadCloser, stdout io.Writer, args ...stri
 		return errors.New("Not enough arguments")
 	}
 	time.Sleep(1 * time.Second)
-	layer := docker.addLayer(args[0], "upload", 0)
+	layer := docker.addContainer(args[0], "upload", 0)
 	fmt.Fprintln(stdout, layer.Id)
 	return nil
 }
 
-func (docker *Docker) CmdSnapshot(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
+func (docker *Docker) CmdFork(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
 	flags := Subcmd(stdout,
-		"snapshot", "[OPTIONS] CONTAINER IMAGE",
-		"Crete a new layer from a container's filesystem")
+		"fork", "[OPTIONS] CONTAINER [DEST]",
+		"Duplicate a container")
+	// FIXME "-r" to reset changes in the new container
 	if err := flags.Parse(args); err != nil {
 		return nil
 	}
-	if flags.NArg() != 2 {
+	srcName, dstName := flags.Arg(0), flags.Arg(1)
+	if srcName == "" {
 		flags.Usage()
 		return nil
 	}
-	containerName, layerName := flags.Arg(0), flags.Arg(1)
-	if container, exists := docker.containers[containerName]; exists {
-		layer := docker.addLayer(layerName, "snapshot:" + container.Id, container.BytesChanged)
-		fmt.Fprintln(stdout, layer.Id)
+	if dstName == "" {
+		dstName = srcName
+	}
+	if src, exists := docker.findContainer(srcName); exists {
+		dst := docker.addContainer(dstName, "snapshot:" + src.Id, src.Size)
+		fmt.Fprintln(stdout, dst.Id)
 		return nil
 	}
-	return errors.New("No such container: " + flags.Arg(0))
+	return errors.New("No such container: " + srcName)
 }
 
 func (docker *Docker) CmdTar(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
 	flags := Subcmd(stdout,
-		"tar", "CONTAINER|LAYER [OPTIONS]",
-		"Stream the contents of a container or a layer as a tar archive")
+		"tar", "CONTAINER",
+		"Stream the contents of a container as a tar archive")
 	if err := flags.Parse(args); err != nil {
 		return nil
 	}
 	name := flags.Arg(0)
-	if _, exists := docker.containers[name]; exists {
+	if _, exists := docker.findContainer(name); exists {
 		// Stream the entire contents of the container (basically a volatile snapshot)
 		return WriteFakeTar(stdout)
-	} else if _, exists := docker.findLayer(name); exists {
-		return WriteFakeTar(stdout)
 	}
-	return errors.New("No such layer or container: " + name)
+	return errors.New("No such container: " + name)
 }
 
 func (docker *Docker) CmdDiff(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
@@ -205,7 +214,7 @@ func (docker *Docker) CmdDiff(stdin io.ReadCloser, stdout io.Writer, args ...str
 	if flags.NArg() < 1 {
 		return errors.New("Not enough arguments")
 	}
-	if container, exists := docker.containers[flags.Arg(0)]; !exists {
+	if container, exists := docker.findContainer(flags.Arg(0)); !exists {
 		return errors.New("No such container")
 	} else if *fl_bytes {
 		fmt.Fprintf(stdout, "%d\n", container.BytesChanged)
@@ -248,76 +257,77 @@ index 2dae694..e43caca 100644
 
 // ByDate wraps an array of layers so they can be sorted by date (most recent first)
 
-type ByDate []*Layer
+type ByDate []*Container
 
-func (l *ByDate) Len() int {
-	return len(*l)
+func (c *ByDate) Len() int {
+	return len(*c)
 }
 
-func (l *ByDate) Less(i, j int) bool {
-	layers := *l
-	return layers[j].Added.Before(layers[i].Added)
+func (c *ByDate) Less(i, j int) bool {
+	containers := *c
+	return containers[j].Created.Before(containers[i].Created)
 }
 
-func (l *ByDate) Swap(i, j int) {
-	layers := *l
-	tmp := layers[i]
-	layers[i] = layers[j]
-	layers[j] = tmp
+func (c *ByDate) Swap(i, j int) {
+	containers := *c
+	tmp := containers[i]
+	containers[i] = containers[j]
+	containers[j] = tmp
 }
 
-func (l *ByDate) Add(layer *Layer) {
-	*l = append(*l, layer)
-	sort.Sort(l)
+func (c *ByDate) Add(container *Container) {
+	*c = append(*c, container)
+	sort.Sort(c)
 }
 
-func (l *ByDate) Del(id string) {
-	for idx, layer := range *l {
-		if layer.Id == id {
-			*l = append((*l)[:idx], (*l)[idx + 1:]...)
+func (c *ByDate) Del(id string) {
+	for idx, container := range *c {
+		if container.Id == id {
+			*c = append((*c)[:idx], (*c)[idx + 1:]...)
 		}
 	}
 }
 
 
-func (docker *Docker) addLayer(name string, source string, size uint) *Layer {
+func (docker *Docker) addContainer(name string, source string, size uint) *Container {
+	// Generate a fake random size
 	if size == 0 {
 		size = uint(rand.Int31n(142 * 1024 * 1024))
 	}
-	layer := &Layer{Id: randomId(), Name: name, Source: source, Added: time.Now(), Size: size}
-	docker.layers[layer.Id] = layer
-	if _, exists := docker.layersByName[layer.Name]; !exists {
-		docker.layersByName[layer.Name] = new(ByDate)
+	c := &Container{
+		Id:		randomId(),
+		Name:		name,
+		Created:	time.Now(),
+		Source:		source,
+		Size:		size,
+		stdinLog: new(bytes.Buffer),
+		stdoutLog: new(bytes.Buffer),
+	}
+	docker.containers[c.Id] = c
+	if _, exists := docker.containersByName[c.Name]; !exists {
+		docker.containersByName[c.Name] = new(ByDate)
 	}
-	docker.layersByName[layer.Name].Add(layer)
-	return layer
+	docker.containersByName[c.Name].Add(c)
+	return c
+
 }
 
-func (docker *Docker) rmLayer(id string) (*Layer, error) {
-	if layer, exists := docker.layers[id]; exists {
-		if containers := docker.usingLayer(layer); len(containers) > 0 {
-			return nil, errors.New(fmt.Sprintf("Layer is in use: %s", id))
+
+func (docker *Docker) rm(id string) (*Container, error) {
+	if container, exists := docker.containers[id]; exists {
+		if container.Running {
+			return nil, errors.New("Container is running: " + id)
 		} else {
 			// Remove from name lookup
-			docker.layersByName[layer.Name].Del(layer.Id)
+			docker.containersByName[container.Name].Del(container.Id)
 			// Remove from id lookup
-			delete(docker.layers, layer.Id)
-			return layer, nil
+			delete(docker.containers, container.Id)
+			return container, nil
 		}
 	}
-	return nil, errors.New(fmt.Sprintf("No such layer: %s", id))
+	return nil, errors.New(fmt.Sprintf("No such container: %s", id))
 }
 
-type ArgList []string
-
-func (l *ArgList) Set(value string) error {
-	*l = append(*l, value)
-	return nil
-}
-
-func (l *ArgList) String() string {
-	return strings.Join(*l, ",")
-}
 
 func (docker *Docker) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
 	flags := Subcmd(stdout, "logs", "[OPTIONS] CONTAINER", "Fetch the logs of a container")
@@ -328,80 +338,40 @@ func (docker *Docker) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...str
 		flags.Usage()
 		return nil
 	}
-	if container, exists := docker.containers[flags.Arg(0)]; exists {
+	name := flags.Arg(0)
+	if container, exists := docker.findContainer(name); exists {
 		if _, err := io.Copy(stdout, container.StdoutLog()); err != nil {
 			return err
 		}
+		return nil
 	}
 	return errors.New("No such container: " + flags.Arg(0))
 }
 
 func (docker *Docker) CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
-	flags := Subcmd(stdout, "run", "-l LAYER [-l LAYER...] COMMAND {ARG...]", "Run a command in a container")
-	fl_layers := new(ArgList)
-	flags.Var(fl_layers, "l", "Add a layer to the filesystem. Multiple layers are added in the order they are defined")
+	flags := Subcmd(stdout, "run", "[OPTIONS] CONTAINER COMMAND [ARG...]", "Run a command in a container")
 	fl_attach := flags.Bool("a", false, "Attach stdin and stdout")
 	if err := flags.Parse(args); err != nil {
 		return nil
 	}
-	if len(*fl_layers) < 1 {
-		return errors.New("Please specify at least one layer")
-	}
-	if flags.NArg() < 1 {
-		return errors.New("No command specified")
-	}
-	cmd := flags.Arg(0)
-	var cmd_args []string
-	if flags.NArg() > 1 {
-		cmd_args = flags.Args()[1:]
-	}
-	container := Container{
-		Id:	randomId(),
-		Cmd:	cmd,
-		Args:	cmd_args,
-		Created: time.Now(),
-		FilesChanged: uint(rand.Int31n(42)),
-		BytesChanged: uint(rand.Int31n(24 * 1024 * 1024)),
-		stdinLog: new(bytes.Buffer),
-		stdoutLog: new(bytes.Buffer),
-	}
-	for _, name := range *fl_layers {
-		if layer, exists := docker.findLayer(name); exists {
-			container.Layers = append(container.Layers, layer)
-		} else if srcContainer, exists := docker.containers[name]; exists {
-			for _, layer := range srcContainer.Layers {
-				container.Layers = append(container.Layers, layer)
-			}
-		} else {
-			return errors.New("No such layer or container: " + name)
-		}
-	}
-	docker.containers[container.Id] = container
-	if *fl_attach {
-		return container.Run(stdin, stdout)
-	} else {
-		go container.Run(ioutil.NopCloser(new(bytes.Buffer)), ioutil.Discard)
-		fmt.Fprintln(stdout, container.Id)
-	}
-	return nil
-}
-
-func (docker *Docker) CmdClone(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
-	flags := Subcmd(stdout, "Clone", "[OPTIONS] CONTAINER_ID", "Duplicate a container")
-	reset := flags.Bool("r", true, "Reset: don't keep filesystem changes from the source container")
-	flags.Parse(args)
-	if !*reset {
-		return errors.New("Only reset mode is available for now. Please use -r")
-	}
-	if flags.NArg() != 1 {
+	if flags.NArg() < 2 {
 		flags.Usage()
 		return nil
 	}
-	container, exists := docker.containers[flags.Arg(0)];
-	if !exists {
-		return errors.New("No such container: " + flags.Arg(0))
+	name, cmd := flags.Arg(0), flags.Args()[1:]
+	if container, exists := docker.findContainer(name); exists {
+		if container.Running {
+			return errors.New("Already running: " + name)
+		}
+		if *fl_attach {
+			return container.Run(cmd[0], cmd[1:], stdin, stdout)
+		} else {
+			go container.Run(cmd[0], cmd[1:], ioutil.NopCloser(new(bytes.Buffer)), ioutil.Discard)
+			fmt.Fprintln(stdout, container.Id)
+			return nil
+		}
 	}
-	return docker.CmdRun(stdin, stdout, append([]string{"-l", container.Id, "--", container.Cmd}, container.Args...)...)
+	return errors.New("No such container: " + name)
 }
 
 func startCommand(cmd *exec.Cmd, interactive bool) (io.WriteCloser, io.ReadCloser, error) {
@@ -426,56 +396,64 @@ func startCommand(cmd *exec.Cmd, interactive bool) (io.WriteCloser, io.ReadClose
 	return stdin, stdout, nil
 }
 
-func (docker *Docker) CmdList(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
-	flags := Subcmd(stdout, "list", "[OPTIONS]", "Show all containers")
-	numeric := flags.Bool("n", false, "Display absolute layer IDs instead of names")
-	flags.Parse(args)
-	var longestCol int
-	for _, container := range docker.containers {
-		if l := len(container.CmdString()); l > longestCol {
-			longestCol = l
-		}
+func (docker *Docker) ListenAndServeTCP(addr string) error {
+	listener, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
 	}
-	if longestCol > 50 {
-		longestCol = 50
-	} else if longestCol < 5 {
-		longestCol = 8
-	}
-	tpl := "%-16s   %-*.*s   %-6s   %-25s   %10s   %-s\n"
-	fmt.Fprintf(stdout, tpl, "ID", longestCol, longestCol, "CMD", "RUNNING", "CREATED", "CHANGES", "LAYERS")
-	for _, container := range docker.containers {
-		var layers []string
-		for _, layer := range container.Layers {
-			if *numeric {
-				layers = append(layers, layer.Id)
-			} else {
-				layers = append(layers, layer.Name)
-			}
+	defer listener.Close()
+	for {
+		if conn, err := listener.Accept(); err != nil {
+			return err
+		} else {
+			go func() {
+				if err := docker.serve(conn); err != nil {
+					log.Printf("Error: " + err.Error() + "\n")
+					fmt.Fprintf(conn, "Error: " + err.Error() + "\n")
+				}
+				conn.Close()
+			}()
 		}
-		fmt.Fprintf(stdout, tpl,
-			/* ID */	container.Id,
-			/* CMD */	longestCol, longestCol, container.CmdString(),
-			/* RUNNING */	fmt.Sprintf("%v", container.Running),
-			/* CREATED */	humanDuration(time.Now().Sub(container.Created)) + " ago",
-			/* CHANGES */	fmt.Sprintf("%.1fM", float32(container.BytesChanged) / 1024 / 1024),
-			/* LAYERS */	strings.Join(layers, ","))
 	}
 	return nil
 }
 
+func (docker *Docker) ListenAndServeHTTP(addr string) error {
+	return http.ListenAndServe(addr, docker)
+}
+
+
 func main() {
 	rand.Seed(time.Now().UTC().UnixNano())
 	flag.Parse()
-	if err := http.ListenAndServe(":4242", New()); err != nil {
+	docker := New()
+	go func() {
+		if err := docker.ListenAndServeHTTP(":8080"); err != nil {
+			log.Fatal(err)
+		}
+	}()
+	if err := docker.ListenAndServeTCP(":4242"); err != nil {
 		log.Fatal(err)
 	}
 }
 
+func (docker *Docker) serve(conn net.Conn) error {
+	r := bufio.NewReader(conn)
+	var args []string
+	if line, err := r.ReadString('\n'); err != nil {
+		return err
+	} else if err := json.Unmarshal([]byte(line), &args); err != nil {
+		return err
+	} else {
+		return docker.Call(ioutil.NopCloser(r), conn, args...)
+	}
+	return nil
+}
+
 func New() *Docker {
 	return &Docker{
-		layers: make(map[string]*Layer),
-		layersByName: make(map[string]*ByDate),
-		containers: make(map[string]Container),
+		containersByName: make(map[string]*ByDate),
+		containers: make(map[string]*Container),
 	}
 }
 
@@ -492,30 +470,50 @@ func (w *AutoFlush) Write(data []byte) (int, error) {
 }
 
 func (docker *Docker) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	stdout := &AutoFlush{w}
-	stdin := r.Body
+	cmd, args := URLToCall(r.URL)
+	if err := docker.Call(r.Body, &AutoFlush{w}, append([]string{cmd}, args...)...); err != nil {
+		fmt.Fprintf(w, "Error: " + err.Error() + "\n")
+	}
+}
+
+func (docker *Docker) Call(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
 	flags := flag.NewFlagSet("docker", flag.ContinueOnError)
 	flags.SetOutput(stdout)
 	flags.Usage = func() { docker.CmdHelp(stdin, stdout) }
-	cmd, args := URLToCall(r.URL)
-	if err := flags.Parse(append([]string{cmd}, args...)); err != nil {
-		return
+	if err := flags.Parse(args); err != nil {
+		return err
 	}
-	log.Printf("%s\n", strings.Join(append(append([]string{"docker"}, cmd), args...), " "))
+	cmd := flags.Arg(0)
+	log.Printf("%s\n", strings.Join(append(append([]string{"docker"}, cmd), args[1:]...), " "))
 	if cmd == "" {
 		cmd = "help"
-	} else if cmd == "web" {
-		w.Header().Set("content-type", "text/html")
 	}
 	method := docker.getMethod(cmd)
-	if method == nil {
-		fmt.Fprintf(stdout, "Error: no such command: %s\n", cmd)
-	} else {
-		err := method(stdin, stdout, args...)
-		if err != nil {
-			fmt.Fprintf(stdout, "Error: %s\n", err)
+	if method != nil {
+		return method(stdin, stdout, args[1:]...)
+	}
+	return errors.New("No such command: " + cmd)
+}
+
+func (docker *Docker) CmdMirror(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
+	_, err := io.Copy(stdout, stdin)
+	return err
+}
+
+func (docker *Docker) CmdDebug(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
+	for {
+		if line, err := bufio.NewReader(stdin).ReadString('\n'); err == nil {
+			fmt.Printf("--- %s", line)
+		} else if err == io.EOF {
+			if len(line) > 0 {
+				fmt.Printf("--- %s\n", line)
+			}
+			break
+		} else {
+			return err
 		}
 	}
+	return nil
 }
 
 func (docker *Docker) CmdWeb(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
@@ -565,41 +563,41 @@ func Go(f func() error) chan error {
 }
 
 type Docker struct {
-	layers		map[string]*Layer
-	layersByName	map[string]*ByDate
-	containers	map[string]Container
-}
-
-type Layer struct {
-	Id	string
-	Name	string
-	Added	time.Time
-	Size	uint
-	Source	string
+	containers		map[string]*Container
+	containersByName	map[string]*ByDate
 }
 
 type Container struct {
 	Id	string
-	Cmd	string
-	Args	[]string
-	Layers	[]*Layer
+	Name	string
 	Created	time.Time
+	Source	string
+	Size	uint
 	FilesChanged uint
 	BytesChanged uint
 	Running	bool
+	Cmd	string
+	Args	[]string
 	stdoutLog *bytes.Buffer
 	stdinLog *bytes.Buffer
 }
 
-func (c *Container) Run(stdin io.ReadCloser, stdout io.Writer) error {
+func (c *Container) Run(command string, args []string, stdin io.ReadCloser, stdout io.Writer) error {
 	// Not thread-safe
 	if c.Running {
 		return errors.New("Already running")
 	}
+	c.Cmd = command
+	c.Args = args
+	// Reset logs
+	c.stdoutLog.Reset()
+	c.stdinLog.Reset()
 	c.Running = true
-	defer func() { c.Running = false }()
 	cmd := exec.Command(c.Cmd, c.Args...)
-	cmd_stdin, cmd_stdout, err := startCommand(cmd, false)
+	cmd_stdin, cmd_stdout, err := startCommand(cmd, true)
+	// ADD FAKE RANDOM CHANGES
+	c.FilesChanged = uint(rand.Int31n(42))
+	c.BytesChanged = uint(rand.Int31n(24 * 1024 * 1024))
 	if err != nil {
 		return err
 	}
@@ -607,20 +605,27 @@ func (c *Container) Run(stdin io.ReadCloser, stdout io.Writer) error {
 		_, err := io.Copy(io.MultiWriter(stdout, c.stdoutLog), cmd_stdout)
 		return err
 	})
-	copy_in := Go(func() error {
-		//_, err := io.Copy(io.MultiWriter(cmd_stdin, c.stdinLog), stdin)
+	Go(func() error {
+		_, err := io.Copy(io.MultiWriter(cmd_stdin, c.stdinLog), stdin)
 		cmd_stdin.Close()
 		stdin.Close()
-		//return err
-		return nil
-	})
-	if err := cmd.Wait(); err != nil {
 		return err
-	}
-	if err := <-copy_in; err != nil {
+	})
+	wait := Go(func() error {
+		err := cmd.Wait()
+		c.Running = false
 		return err
-	}
+	})
 	if err := <-copy_out; err != nil {
+		if c.Running {
+			return err
+		}
+	}
+	if err := <-wait; err != nil {
+		if status, ok := err.(*exec.ExitError); ok {
+			fmt.Fprintln(stdout, status)
+			return nil
+		}
 		return err
 	}
 	return nil

dockerd/dockerweb.html

@@ -188,7 +188,7 @@ b)}catch(f){i(f,"onCommandChange");throw f;}t()},commands:x});O.append(b);l.enab
 		if (command !== '') {
 		    console.log(command);
 		    try {
-			var url = "http://localhost:4242/" + command.split(" ")[0] + "?" + $.param(command.split(" ").slice(1).map(function(e) { return {name: "q", value: e} }))
+			var url = "http://localhost:8080/" + command.split(" ")[0] + "?" + $.param(command.split(" ").slice(1).map(function(e) { return {name: "q", value: e} }))
 			console.log(url);
 		    	$.ajax(url).done(function(data) {
 				term.echo(new String(data));