diff --git a/docker/docker.go b/docker/docker.go index fed1211a67..73caf65123 100644 --- a/docker/docker.go +++ b/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" +type Termios struct { + Iflag uintptr + Oflag uintptr + Cflag uintptr + Lflag uintptr + Cc [20]byte + Ispeed uintptr + Ospeed uintptr +} -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(), - } +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:] - } - u := CallToURL(os.Getenv("DOCKER"), cmd, args) - resp, err := http.Get(u.String()) + cmd, err := json.Marshal(os.Args[1:]) if err != nil { - log.Fatal(err) + Fatal(err) } - io.Copy(os.Stdout, resp.Body) + conn, err := net.Dial("tcp", os.Getenv("DOCKER")) + if err != nil { + 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) + } + Restore(0, oldState) } diff --git a/dockerd/dockerd.go b/dockerd/dockerd.go index 414df9153d..c330dc4b8f 100644 --- a/dockerd/dockerd.go +++ b/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.layersByName[layer.Name].Add(layer) - return layer + docker.containers[c.Id] = c + if _, exists := docker.containersByName[c.Name]; !exists { + docker.containersByName[c.Name] = new(ByDate) + } + 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 + return err }) - if err := cmd.Wait(); err != nil { + wait := Go(func() error { + err := cmd.Wait() + c.Running = false return err - } - if err := <-copy_in; err != nil { - 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 diff --git a/dockerd/dockerweb.html b/dockerd/dockerweb.html index e0df9393c5..67cafa4e00 100644 --- a/dockerd/dockerweb.html +++ b/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));