diff --git a/components/engine/client/client.go b/components/engine/client/client.go new file mode 100644 index 0000000000..6c5e6c4c99 --- /dev/null +++ b/components/engine/client/client.go @@ -0,0 +1,123 @@ +package client + +import ( + "github.com/dotcloud/docker/rcli" + "github.com/dotcloud/docker/future" + "io" + "io/ioutil" + "log" + "os" + "os/exec" + "path" + "path/filepath" +) + +// 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 +} + +// Run docker in "interactive mode": run a bash-compatible shell capable of running docker commands. +func InteractiveMode(scripts ...string) error { + // Determine path of current docker binary + dockerPath, err := exec.LookPath(os.Args[0]) + if err != nil { + return err + } + dockerPath, err = filepath.Abs(dockerPath) + if err != nil { + return err + } + + // Create a temp directory + tmp, err := ioutil.TempDir("", "docker-shell") + if err != nil { + return err + } + defer os.RemoveAll(tmp) + + // For each command, create an alias in temp directory + // FIXME: generate this list dynamically with introspection of some sort + // It might make sense to merge docker and dockerd to keep that introspection + // within a single binary. + for _, cmd := range []string{ + "help", + "run", + "ps", + "pull", + "put", + "rm", + "kill", + "wait", + "stop", + "logs", + "diff", + "commit", + "attach", + "info", + "tar", + "web", + "images", + "docker", + } { + if err := os.Symlink(dockerPath, path.Join(tmp, cmd)); err != nil { + return err + } + } + + // Run $SHELL with PATH set to temp directory + rcfile, err := ioutil.TempFile("", "docker-shell-rc") + if err != nil { + return err + } + io.WriteString(rcfile, "enable -n help\n") + os.Setenv("PATH", tmp) + os.Setenv("PS1", "\\h docker> ") + shell := exec.Command("/bin/bash", append([]string{"--rcfile", rcfile.Name()}, scripts...)...) + shell.Stdin = os.Stdin + shell.Stdout = os.Stdout + shell.Stderr = os.Stderr + if err := shell.Run(); err != nil { + return err + } + return nil +} diff --git a/components/engine/client/term.go b/components/engine/client/term.go new file mode 100644 index 0000000000..8b58611cd9 --- /dev/null +++ b/components/engine/client/term.go @@ -0,0 +1,145 @@ +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 | 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 +} + + diff --git a/components/engine/docker/termios_darwin.go b/components/engine/client/termios_darwin.go similarity index 85% rename from components/engine/docker/termios_darwin.go rename to components/engine/client/termios_darwin.go index ba3aac0f4a..185687920c 100644 --- a/components/engine/docker/termios_darwin.go +++ b/components/engine/client/termios_darwin.go @@ -1,4 +1,4 @@ -package main +package client import "syscall" diff --git a/components/engine/docker/termios_linux.go b/components/engine/client/termios_linux.go similarity index 85% rename from components/engine/docker/termios_linux.go rename to components/engine/client/termios_linux.go index 882dee1276..36957c44a1 100644 --- a/components/engine/docker/termios_linux.go +++ b/components/engine/client/termios_linux.go @@ -1,4 +1,4 @@ -package main +package client import "syscall" diff --git a/components/engine/docker/docker.go b/components/engine/docker/docker.go index 973c2623ea..efc93620a4 100644 --- a/components/engine/docker/docker.go +++ b/components/engine/docker/docker.go @@ -1,288 +1,30 @@ package main import ( - "github.com/dotcloud/docker/rcli" - "github.com/dotcloud/docker/future" - "io" - "io/ioutil" + "flag" "log" "os" - "os/exec" - "syscall" - "unsafe" "path" - "path/filepath" - "flag" + "github.com/dotcloud/docker/client" ) - -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 | 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() { if cmd := path.Base(os.Args[0]); cmd == "docker" { fl_shell := flag.Bool("i", false, "Interactive mode") flag.Parse() if *fl_shell { - if err := InteractiveMode(flag.Args()...); err != nil { + if err := client.InteractiveMode(flag.Args()...); err != nil { log.Fatal(err) } } else { - SimpleMode(os.Args[1:]) + if err := client.SimpleMode(os.Args[1:]); err != nil { + log.Fatal(err) + } } } else { - SimpleMode(append([]string{cmd}, os.Args[1:]...)) - } -} - -// Run docker in "simple mode": run a single command and return. -func SimpleMode(args []string) { - var err error - if IsTerminal(0) && os.Getenv("NORAW") == "" { - oldState, err = MakeRaw(0) - if err != nil { - panic(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 { - Fatal(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 { - Fatal(err) - } - if oldState != nil { - Restore(0, oldState) - } - if !IsTerminal(0) { - if err := <-send_stdin; err != nil { - Fatal(err) + if err := client.SimpleMode(append([]string{cmd}, os.Args[1:]...)); err != nil { + log.Fatal(err) } } } -// Run docker in "interactive mode": run a bash-compatible shell capable of running docker commands. -func InteractiveMode(scripts ...string) error { - // Determine path of current docker binary - dockerPath, err := exec.LookPath(os.Args[0]) - if err != nil { - return err - } - dockerPath, err = filepath.Abs(dockerPath) - if err != nil { - return err - } - - // Create a temp directory - tmp, err := ioutil.TempDir("", "docker-shell") - if err != nil { - return err - } - defer os.RemoveAll(tmp) - - // For each command, create an alias in temp directory - // FIXME: generate this list dynamically with introspection of some sort - // It might make sense to merge docker and dockerd to keep that introspection - // within a single binary. - for _, cmd := range []string{ - "help", - "run", - "ps", - "pull", - "put", - "rm", - "kill", - "wait", - "stop", - "logs", - "diff", - "commit", - "attach", - "info", - "tar", - "web", - "images", - "docker", - } { - if err := os.Symlink(dockerPath, path.Join(tmp, cmd)); err != nil { - return err - } - } - - // Run $SHELL with PATH set to temp directory - rcfile, err := ioutil.TempFile("", "docker-shell-rc") - if err != nil { - return err - } - io.WriteString(rcfile, "enable -n help\n") - os.Setenv("PATH", tmp) - os.Setenv("PS1", "\\h docker> ") - shell := exec.Command("/bin/bash", append([]string{"--rcfile", rcfile.Name()}, scripts...)...) - shell.Stdin = os.Stdin - shell.Stdout = os.Stdout - shell.Stderr = os.Stderr - if err := shell.Run(); err != nil { - return err - } - return nil -} diff --git a/components/engine/dockerd/dockerd.go b/components/engine/dockerd/dockerd.go index 41a81f19d5..744964cf73 100644 --- a/components/engine/dockerd/dockerd.go +++ b/components/engine/dockerd/dockerd.go @@ -1,851 +1,24 @@ package main import ( - "bufio" - "bytes" - "encoding/json" - "errors" - "flag" - "fmt" - "github.com/dotcloud/docker" - "github.com/dotcloud/docker/future" - "github.com/dotcloud/docker/image" - "github.com/dotcloud/docker/rcli" - "io" "log" - "net/http" - "net/url" - "os" - "path" - "strings" - "sync" - "text/tabwriter" - "time" + "flag" + "github.com/dotcloud/docker/server" + "github.com/dotcloud/docker" ) -const VERSION = "0.0.1" - -func (srv *Server) Name() string { - return "docker" -} - -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"}, - {"pull", "Download a tarball and create a container from it"}, - {"put", "Upload a tarball and create a container from it"}, - {"rm", "Remove containers"}, - {"kill", "Kill a running container"}, - {"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"}, - {"commit", "Save the state of a container"}, - {"attach", "Attach to the standard inputs and outputs of a running container"}, - {"info", "Display system-wide information"}, - {"tar", "Stream the contents of a container as a tar archive"}, - {"web", "Generate a web UI"}, - {"images", "List images"}, - } { - help += fmt.Sprintf(" %-10.10s%s\n", cmd...) - } - return help -} - -// 'docker info': display system-wide information. -func (srv *Server) CmdInfo(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - fmt.Fprintf(stdout, "containers: %d\nversion: %s\nimages: %d\n", - len(srv.containers.List()), - VERSION, - len(srv.images.ById)) - 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 { - cmd.Usage() - 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) 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 { - cmd.Usage() - 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.Filesystem.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 { - cmd.Usage() - 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.Filesystem.Mount(); 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 { - cmd.Usage() - 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.Filesystem.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 { - cmd.Usage() - 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.Filesystem.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 { - cmd.Usage() - 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.Filesystem.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 { - cmd.Usage() - 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 := srv.images.Find(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 -} - -// '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") - if err := cmd.Parse(args); err != nil { - cmd.Usage() - return nil - } - if cmd.NArg() < 1 { - cmd.Usage() - return nil - } - for _, name := range cmd.Args() { - image := srv.images.Find(name) - if image == nil { - return errors.New("No such image: " + name) - } - if err := srv.images.Delete(name); 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) CmdPull(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, "pull", "[OPTIONS] NAME", "Download a new image from a remote location") - fl_bzip2 := cmd.Bool("j", false, "Bzip2 compression") - fl_gzip := cmd.Bool("z", false, "Gzip compression") - if err := cmd.Parse(args); err != nil { - return nil - } - var compression image.Compression - if *fl_bzip2 { - compression = image.Bzip2 - } else if *fl_gzip { - compression = image.Gzip - } - name := cmd.Arg(0) - if name == "" { - return errors.New("Not enough arguments") - } - 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 %s from %s...\n", name, u.String()) - resp, err := http.Get(u.String()) - if err != nil { - return err - } - img, err := srv.images.Import(name, resp.Body, stdout, nil, compression) - if err != nil { - return err - } - fmt.Fprintln(stdout, img.Id) - return nil -} - -func (srv *Server) CmdPut(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, "put", "[OPTIONS] NAME", "Import a new image from a local archive.") - fl_bzip2 := cmd.Bool("j", false, "Bzip2 compression") - fl_gzip := cmd.Bool("z", false, "Gzip compression") - if err := cmd.Parse(args); err != nil { - return nil - } - var compression image.Compression - if *fl_bzip2 { - compression = image.Bzip2 - } else if *fl_gzip { - compression = image.Gzip - } - name := cmd.Arg(0) - if name == "" { - return errors.New("Not enough arguments") - } - img, err := srv.images.Import(name, stdin, stdout, nil, compression) - 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") - cmd.Parse(args) - 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") - } - for _, name := range srv.images.Names() { - if nameFilter != "" && nameFilter != name { - continue - } - for idx, img := range *srv.images.ByName[name] { - if *limit > 0 && idx >= *limit { - break - } - if !*quiet { - id := img.Id - if !img.IdIsFinal() { - id += "..." - } - for idx, field := range []string{ - /* NAME */ name, - /* ID */ id, - /* CREATED */ future.HumanDuration(time.Now().Sub(img.Created)) + " 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.List() { - 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 newImage, err := srv.images.Copy(cmd.Arg(0), cmd.Arg(1)); err != nil { - return err - } else { - fmt.Fprintln(stdout, newImage.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 := docker.Tar(container.Filesystem.RWPath) - if err != nil { - return err - } - // Create a new image from the container's base layers + a new layer from container changes - parentImg := srv.images.Find(container.GetUserData("image")) - img, err := srv.images.Import(imgName, rwTar, stdout, parentImg, image.Uncompressed) - 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, - "tar", "CONTAINER", - "Stream the contents of a container as a tar archive") - fl_sparse := cmd.Bool("s", false, "Generate a sparse tar stream (top layer + reference to bottom layers)") - if err := cmd.Parse(args); err != nil { - return nil - } - if *fl_sparse { - return errors.New("Sparse mode not yet implemented") // FIXME - } - name := cmd.Arg(0) - if container := srv.containers.Get(name); container != nil { - data, err := container.Filesystem.Tar() - if err != nil { - return err - } - // Stream the entire contents of the container (basically a volatile snapshot) - if _, err := io.Copy(stdout, data); err != nil { - return err - } - return nil - } - return errors.New("No such container: " + name) -} - -func (srv *Server) CmdDiff(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, - "diff", "CONTAINER [OPTIONS]", - "Inspect changes on a container's filesystem") - if err := cmd.Parse(args); err != nil { - return nil - } - if cmd.NArg() < 1 { - return errors.New("Not enough arguments") - } - if container := srv.containers.Get(cmd.Arg(0)); container == nil { - return errors.New("No such container") - } else { - changes, err := container.Filesystem.Changes() - if err != nil { - return err - } - for _, change := range changes { - fmt.Fprintln(stdout, change.String()) - } - } - return nil -} - -func (srv *Server) CmdReset(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, - "reset", "CONTAINER [OPTIONS]", - "Reset changes to a container's filesystem") - if err := cmd.Parse(args); err != nil { - return nil - } - if cmd.NArg() < 1 { - return errors.New("Not enough arguments") - } - for _, name := range cmd.Args() { - if container := srv.containers.Get(name); container != nil { - if err := container.Filesystem.Reset(); err != nil { - return errors.New("Reset " + container.Id + ": " + err.Error()) - } - } - } - return nil -} - -func (srv *Server) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, "logs", "[OPTIONS] CONTAINER", "Fetch the logs of a container") - if err := cmd.Parse(args); err != nil { - return nil - } - if cmd.NArg() != 1 { - cmd.Usage() - return nil - } - name := cmd.Arg(0) - if container := srv.containers.Get(name); container != nil { - if _, err := io.Copy(stdout, container.StdoutLog()); err != nil { - return err - } - if _, err := io.Copy(stdout, container.StderrLog()); err != nil { - return err - } - return nil - } - return errors.New("No such container: " + cmd.Arg(0)) -} - -func (srv *Server) CreateContainer(img *image.Image, tty bool, openStdin bool, comment string, cmd string, args ...string) (*docker.Container, error) { - id := future.RandomId()[:8] - container, err := srv.containers.Create(id, cmd, args, img.Layers, - &docker.Config{Hostname: id, Tty: tty, OpenStdin: openStdin}) - if err != nil { - return nil, err - } - if err := container.SetUserData("image", img.Id); err != nil { - srv.containers.Destroy(container) - return nil, errors.New("Error setting container userdata: " + err.Error()) - } - if err := container.SetUserData("comment", comment); err != nil { - srv.containers.Destroy(container) - return nil, errors.New("Error setting container userdata: " + err.Error()) - } - return container, nil -} - -func (srv *Server) CmdAttach(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, "attach", "[OPTIONS]", "Attach to a running container") - fl_i := cmd.Bool("i", false, "Attach to stdin") - fl_o := cmd.Bool("o", true, "Attach to stdout") - fl_e := cmd.Bool("e", true, "Attach to stderr") - if err := cmd.Parse(args); err != nil { - return nil - } - if cmd.NArg() != 1 { - cmd.Usage() - return nil - } - name := cmd.Arg(0) - container := srv.containers.Get(name) - if container == nil { - return errors.New("No such container: " + name) - } - var wg sync.WaitGroup - if *fl_i { - c_stdin, err := container.StdinPipe() - if err != nil { - return err - } - wg.Add(1) - go func() { io.Copy(c_stdin, stdin); wg.Add(-1) }() - } - if *fl_o { - c_stdout, err := container.StdoutPipe() - if err != nil { - return err - } - wg.Add(1) - go func() { io.Copy(stdout, c_stdout); wg.Add(-1) }() - } - if *fl_e { - c_stderr, err := container.StderrPipe() - if err != nil { - return err - } - wg.Add(1) - go func() { io.Copy(stdout, c_stderr); wg.Add(-1) }() - } - wg.Wait() - return nil -} - -func (srv *Server) CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, "run", "[OPTIONS] IMAGE COMMAND [ARG...]", "Run a command in a new container") - fl_attach := cmd.Bool("a", false, "Attach stdin and stdout") - fl_stdin := cmd.Bool("i", false, "Keep stdin open even if not attached") - fl_tty := cmd.Bool("t", false, "Allocate a pseudo-tty") - fl_comment := cmd.String("c", "", "Comment") - if err := cmd.Parse(args); err != nil { - return nil - } - name := cmd.Arg(0) - var cmdline []string - if len(cmd.Args()) >= 2 { - cmdline = cmd.Args()[1:] - } - // Choose a default image if needed - if name == "" { - name = "base" - } - // Choose a default command if needed - if len(cmdline) == 0 { - *fl_stdin = true - *fl_tty = true - *fl_attach = true - cmdline = []string{"/bin/bash", "-i"} - } - // Find the image - img := srv.images.Find(name) - if img == nil { - return errors.New("No such image: " + name) - } - // Create new container - container, err := srv.CreateContainer(img, *fl_tty, *fl_stdin, *fl_comment, cmdline[0], cmdline[1:]...) - if err != nil { - return errors.New("Error creating container: " + err.Error()) - } - if *fl_stdin { - cmd_stdin, err := container.StdinPipe() - if err != nil { - return err - } - if *fl_attach { - future.Go(func() error { - log.Printf("CmdRun(): start receiving stdin\n") - _, err := io.Copy(cmd_stdin, stdin) - log.Printf("CmdRun(): done receiving stdin\n") - cmd_stdin.Close() - return err - }) - } - } - // Run the container - if *fl_attach { - cmd_stderr, err := container.StderrPipe() - if err != nil { - return err - } - cmd_stdout, err := container.StdoutPipe() - if err != nil { - return err - } - if err := container.Start(); err != nil { - return err - } - sending_stdout := future.Go(func() error { - _, err := io.Copy(stdout, cmd_stdout) - return err - }) - sending_stderr := future.Go(func() error { - _, err := io.Copy(stdout, cmd_stderr) - return err - }) - err_sending_stdout := <-sending_stdout - err_sending_stderr := <-sending_stderr - if err_sending_stdout != nil { - return err_sending_stdout - } - if err_sending_stderr != nil { - return err_sending_stderr - } - container.Wait() - } else { - if err := container.Start(); err != nil { - return err - } - fmt.Fprintln(stdout, container.Id) - } - return nil -} - func main() { if docker.SelfPath() == "/sbin/init" { // Running in init mode docker.SysInit() return } - future.Seed() flag.Parse() - d, err := New() + d, err := server.New() if err != nil { log.Fatal(err) } - go func() { - if err := rcli.ListenAndServeHTTP("127.0.0.1:8080", d); err != nil { - log.Fatal(err) - } - }() - // 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 - if err := rcli.ListenAndServe("tcp", "127.0.0.1:4242", d); err != nil { + if err := d.ListenAndServe(); err != nil { log.Fatal(err) } } - -func New() (*Server, error) { - images, err := image.New("/var/lib/docker/images") - if err != nil { - return nil, err - } - containers, err := docker.New() - if err != nil { - return nil, err - } - srv := &Server{ - images: images, - containers: containers, - } - return srv, nil -} - -func (srv *Server) CmdMirror(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - _, err := io.Copy(stdout, stdin) - return err -} - -func (srv *Server) 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 (srv *Server) CmdWeb(stdin io.ReadCloser, stdout io.Writer, args ...string) error { - cmd := rcli.Subcmd(stdout, "web", "[OPTIONS]", "A web UI for docker") - showurl := cmd.Bool("u", false, "Return the URL of the web UI") - if err := cmd.Parse(args); err != nil { - return nil - } - if *showurl { - fmt.Fprintln(stdout, "http://localhost:4242/web") - } else { - if file, err := os.Open("dockerweb.html"); err != nil { - return err - } else if _, err := io.Copy(stdout, file); err != nil { - return err - } - } - return nil -} - -type Server struct { - containers *docker.Docker - images *image.Store -} diff --git a/components/engine/filesystem.go b/components/engine/filesystem.go index f73fe38d26..c775fa0c18 100644 --- a/components/engine/filesystem.go +++ b/components/engine/filesystem.go @@ -44,7 +44,7 @@ func (fs *Filesystem) Mount() error { roBranches += fmt.Sprintf("%v=ro:", layer) } branches := fmt.Sprintf("br:%v:%v", rwBranch, roBranches) - if err := syscall.Mount("none", fs.RootFS, "aufs", 0, branches); err != nil { + if err := mount("none", fs.RootFS, "aufs", 0, branches); err != nil { return err } if !fs.IsMounted() { diff --git a/components/engine/mount_darwin.go b/components/engine/mount_darwin.go new file mode 100644 index 0000000000..aeac78cda5 --- /dev/null +++ b/components/engine/mount_darwin.go @@ -0,0 +1,7 @@ +package docker + +import "errors" + +func mount(source string, target string, fstype string, flags uintptr, data string) (err error) { + return errors.New("mount is not implemented on darwin") +} diff --git a/components/engine/mount_linux.go b/components/engine/mount_linux.go new file mode 100644 index 0000000000..a5a24e8480 --- /dev/null +++ b/components/engine/mount_linux.go @@ -0,0 +1,8 @@ +package docker + +import "syscall" + + +func mount(source string, target string, fstype string, flags uintptr, data string) (err error) { + return syscall.Mount(source, target, fstype, flags, data) +} diff --git a/components/engine/server/server.go b/components/engine/server/server.go new file mode 100644 index 0000000000..e5dcac0ab5 --- /dev/null +++ b/components/engine/server/server.go @@ -0,0 +1,841 @@ +package server + +import ( + "github.com/dotcloud/docker" + "github.com/dotcloud/docker/rcli" + "github.com/dotcloud/docker/image" + "github.com/dotcloud/docker/future" + "bufio" + "errors" + "log" + "io" + "fmt" + "strings" + "text/tabwriter" + "os" + "time" + "net/http" + "encoding/json" + "bytes" + "sync" + "net/url" + "path" +) + +const VERSION = "0.0.1" + +func (srv *Server) ListenAndServe() error { + go rcli.ListenAndServeHTTP("127.0.0.1:8080", srv) + // 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 + return rcli.ListenAndServe("tcp", "127.0.0.1:4242", srv) +} + +func (srv *Server) Name() string { + return "docker" +} + +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"}, + {"pull", "Download a tarball and create a container from it"}, + {"put", "Upload a tarball and create a container from it"}, + {"rm", "Remove containers"}, + {"kill", "Kill a running container"}, + {"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"}, + {"commit", "Save the state of a container"}, + {"attach", "Attach to the standard inputs and outputs of a running container"}, + {"info", "Display system-wide information"}, + {"tar", "Stream the contents of a container as a tar archive"}, + {"web", "Generate a web UI"}, + {"images", "List images"}, + } { + help += fmt.Sprintf(" %-10.10s%s\n", cmd...) + } + return help +} + +// 'docker info': display system-wide information. +func (srv *Server) CmdInfo(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + fmt.Fprintf(stdout, "containers: %d\nversion: %s\nimages: %d\n", + len(srv.containers.List()), + VERSION, + len(srv.images.ById)) + 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 { + cmd.Usage() + 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) 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 { + cmd.Usage() + 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.Filesystem.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 { + cmd.Usage() + 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.Filesystem.Mount(); 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 { + cmd.Usage() + 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.Filesystem.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 { + cmd.Usage() + 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.Filesystem.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 { + cmd.Usage() + 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.Filesystem.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 { + cmd.Usage() + 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 := srv.images.Find(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 +} + +// '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") + if err := cmd.Parse(args); err != nil { + cmd.Usage() + return nil + } + if cmd.NArg() < 1 { + cmd.Usage() + return nil + } + for _, name := range cmd.Args() { + image := srv.images.Find(name) + if image == nil { + return errors.New("No such image: " + name) + } + if err := srv.images.Delete(name); 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) CmdPull(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, "pull", "[OPTIONS] NAME", "Download a new image from a remote location") + fl_bzip2 := cmd.Bool("j", false, "Bzip2 compression") + fl_gzip := cmd.Bool("z", false, "Gzip compression") + if err := cmd.Parse(args); err != nil { + return nil + } + var compression image.Compression + if *fl_bzip2 { + compression = image.Bzip2 + } else if *fl_gzip { + compression = image.Gzip + } + name := cmd.Arg(0) + if name == "" { + return errors.New("Not enough arguments") + } + 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 %s from %s...\n", name, u.String()) + resp, err := http.Get(u.String()) + if err != nil { + return err + } + img, err := srv.images.Import(name, resp.Body, stdout, nil, compression) + if err != nil { + return err + } + fmt.Fprintln(stdout, img.Id) + return nil +} + +func (srv *Server) CmdPut(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, "put", "[OPTIONS] NAME", "Import a new image from a local archive.") + fl_bzip2 := cmd.Bool("j", false, "Bzip2 compression") + fl_gzip := cmd.Bool("z", false, "Gzip compression") + if err := cmd.Parse(args); err != nil { + return nil + } + var compression image.Compression + if *fl_bzip2 { + compression = image.Bzip2 + } else if *fl_gzip { + compression = image.Gzip + } + name := cmd.Arg(0) + if name == "" { + return errors.New("Not enough arguments") + } + img, err := srv.images.Import(name, stdin, stdout, nil, compression) + 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") + cmd.Parse(args) + 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") + } + for _, name := range srv.images.Names() { + if nameFilter != "" && nameFilter != name { + continue + } + for idx, img := range *srv.images.ByName[name] { + if *limit > 0 && idx >= *limit { + break + } + if !*quiet { + id := img.Id + if !img.IdIsFinal() { + id += "..." + } + for idx, field := range []string{ + /* NAME */ name, + /* ID */ id, + /* CREATED */ future.HumanDuration(time.Now().Sub(img.Created)) + " 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.List() { + 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 newImage, err := srv.images.Copy(cmd.Arg(0), cmd.Arg(1)); err != nil { + return err + } else { + fmt.Fprintln(stdout, newImage.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 := docker.Tar(container.Filesystem.RWPath) + if err != nil { + return err + } + // Create a new image from the container's base layers + a new layer from container changes + parentImg := srv.images.Find(container.GetUserData("image")) + img, err := srv.images.Import(imgName, rwTar, stdout, parentImg, image.Uncompressed) + 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, + "tar", "CONTAINER", + "Stream the contents of a container as a tar archive") + fl_sparse := cmd.Bool("s", false, "Generate a sparse tar stream (top layer + reference to bottom layers)") + if err := cmd.Parse(args); err != nil { + return nil + } + if *fl_sparse { + return errors.New("Sparse mode not yet implemented") // FIXME + } + name := cmd.Arg(0) + if container := srv.containers.Get(name); container != nil { + data, err := container.Filesystem.Tar() + if err != nil { + return err + } + // Stream the entire contents of the container (basically a volatile snapshot) + if _, err := io.Copy(stdout, data); err != nil { + return err + } + return nil + } + return errors.New("No such container: " + name) +} + +func (srv *Server) CmdDiff(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, + "diff", "CONTAINER [OPTIONS]", + "Inspect changes on a container's filesystem") + if err := cmd.Parse(args); err != nil { + return nil + } + if cmd.NArg() < 1 { + return errors.New("Not enough arguments") + } + if container := srv.containers.Get(cmd.Arg(0)); container == nil { + return errors.New("No such container") + } else { + changes, err := container.Filesystem.Changes() + if err != nil { + return err + } + for _, change := range changes { + fmt.Fprintln(stdout, change.String()) + } + } + return nil +} + +func (srv *Server) CmdReset(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, + "reset", "CONTAINER [OPTIONS]", + "Reset changes to a container's filesystem") + if err := cmd.Parse(args); err != nil { + return nil + } + if cmd.NArg() < 1 { + return errors.New("Not enough arguments") + } + for _, name := range cmd.Args() { + if container := srv.containers.Get(name); container != nil { + if err := container.Filesystem.Reset(); err != nil { + return errors.New("Reset " + container.Id + ": " + err.Error()) + } + } + } + return nil +} + + +func (srv *Server) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, "logs", "[OPTIONS] CONTAINER", "Fetch the logs of a container") + if err := cmd.Parse(args); err != nil { + return nil + } + if cmd.NArg() != 1 { + cmd.Usage() + return nil + } + name := cmd.Arg(0) + if container := srv.containers.Get(name); container != nil { + if _, err := io.Copy(stdout, container.StdoutLog()); err != nil { + return err + } + if _, err := io.Copy(stdout, container.StderrLog()); err != nil { + return err + } + return nil + } + return errors.New("No such container: " + cmd.Arg(0)) +} + + +func (srv *Server) CreateContainer(img *image.Image, tty bool, openStdin bool, comment string, cmd string, args ...string) (*docker.Container, error) { + id := future.RandomId()[:8] + container, err := srv.containers.Create(id, cmd, args, img.Layers, + &docker.Config{Hostname: id, Tty: tty, OpenStdin: openStdin}) + if err != nil { + return nil, err + } + if err := container.SetUserData("image", img.Id); err != nil { + srv.containers.Destroy(container) + return nil, errors.New("Error setting container userdata: " + err.Error()) + } + if err := container.SetUserData("comment", comment); err != nil { + srv.containers.Destroy(container) + return nil, errors.New("Error setting container userdata: " + err.Error()) + } + return container, nil +} + +func (srv *Server) CmdAttach(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, "attach", "[OPTIONS]", "Attach to a running container") + fl_i := cmd.Bool("i", false, "Attach to stdin") + fl_o := cmd.Bool("o", true, "Attach to stdout") + fl_e := cmd.Bool("e", true, "Attach to stderr") + if err := cmd.Parse(args); err != nil { + return nil + } + if cmd.NArg() != 1 { + cmd.Usage() + return nil + } + name := cmd.Arg(0) + container := srv.containers.Get(name) + if container == nil { + return errors.New("No such container: " + name) + } + var wg sync.WaitGroup + if *fl_i { + c_stdin, err := container.StdinPipe() + if err != nil { + return err + } + wg.Add(1) + go func() { io.Copy(c_stdin, stdin); wg.Add(-1); }() + } + if *fl_o { + c_stdout, err := container.StdoutPipe() + if err != nil { + return err + } + wg.Add(1) + go func() { io.Copy(stdout, c_stdout); wg.Add(-1); }() + } + if *fl_e { + c_stderr, err := container.StderrPipe() + if err != nil { + return err + } + wg.Add(1) + go func() { io.Copy(stdout, c_stderr); wg.Add(-1); }() + } + wg.Wait() + return nil +} + +func (srv *Server) CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, "run", "[OPTIONS] IMAGE COMMAND [ARG...]", "Run a command in a new container") + fl_attach := cmd.Bool("a", false, "Attach stdin and stdout") + fl_stdin := cmd.Bool("i", false, "Keep stdin open even if not attached") + fl_tty := cmd.Bool("t", false, "Allocate a pseudo-tty") + fl_comment := cmd.String("c", "", "Comment") + if err := cmd.Parse(args); err != nil { + return nil + } + name := cmd.Arg(0) + var cmdline[]string + if len(cmd.Args()) >= 2 { + cmdline = cmd.Args()[1:] + } + // Choose a default image if needed + if name == "" { + name = "base" + } + // Choose a default command if needed + if len(cmdline) == 0 { + *fl_stdin = true + *fl_tty = true + *fl_attach = true + cmdline = []string{"/bin/bash", "-i"} + } + // Find the image + img := srv.images.Find(name) + if img == nil { + return errors.New("No such image: " + name) + } + // Create new container + container, err := srv.CreateContainer(img, *fl_tty, *fl_stdin, *fl_comment, cmdline[0], cmdline[1:]...) + if err != nil { + return errors.New("Error creating container: " + err.Error()) + } + if *fl_stdin { + cmd_stdin, err := container.StdinPipe() + if err != nil { + return err + } + if *fl_attach { + future.Go(func() error { + log.Printf("CmdRun(): start receiving stdin\n") + _, err := io.Copy(cmd_stdin, stdin); + log.Printf("CmdRun(): done receiving stdin\n") + cmd_stdin.Close() + return err + }) + } + } + // Run the container + if *fl_attach { + cmd_stderr, err := container.StderrPipe() + if err != nil { + return err + } + cmd_stdout, err := container.StdoutPipe() + if err != nil { + return err + } + if err := container.Start(); err != nil { + return err + } + sending_stdout := future.Go(func() error { + _, err := io.Copy(stdout, cmd_stdout); + return err + }) + sending_stderr := future.Go(func() error { + _, err := io.Copy(stdout, cmd_stderr); + return err + }) + err_sending_stdout := <-sending_stdout + err_sending_stderr := <-sending_stderr + if err_sending_stdout != nil { + return err_sending_stdout + } + if err_sending_stderr != nil { + return err_sending_stderr + } + container.Wait() + } else { + if err := container.Start(); err != nil { + return err + } + fmt.Fprintln(stdout, container.Id) + } + return nil +} + +func New() (*Server, error) { + future.Seed() + images, err := image.New("/var/lib/docker/images") + if err != nil { + return nil, err + } + containers, err := docker.New() + if err != nil { + return nil, err + } + srv := &Server{ + images: images, + containers: containers, + } + return srv, nil +} + +func (srv *Server) CmdMirror(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + _, err := io.Copy(stdout, stdin) + return err +} + +func (srv *Server) 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 (srv *Server) CmdWeb(stdin io.ReadCloser, stdout io.Writer, args ...string) error { + cmd := rcli.Subcmd(stdout, "web", "[OPTIONS]", "A web UI for docker") + showurl := cmd.Bool("u", false, "Return the URL of the web UI") + if err := cmd.Parse(args); err != nil { + return nil + } + if *showurl { + fmt.Fprintln(stdout, "http://localhost:4242/web") + } else { + if file, err := os.Open("dockerweb.html"); err != nil { + return err + } else if _, err := io.Copy(stdout, file); err != nil { + return err + } + } + return nil +} + + +type Server struct { + containers *docker.Docker + images *image.Store +} +