package docker import ( "bytes" "encoding/json" "flag" "fmt" "github.com/dotcloud/docker/auth" "github.com/dotcloud/docker/term" "github.com/dotcloud/docker/utils" "io" "io/ioutil" "mime/multipart" "net" "net/http" "net/http/httputil" "net/url" "os" "os/signal" "path" "path/filepath" "reflect" "strconv" "strings" "syscall" "text/tabwriter" "time" "unicode" ) const VERSION = "0.4.0" var ( GITCOMMIT string ) func (cli *DockerCli) getMethod(name string) (reflect.Method, bool) { methodName := "Cmd" + strings.ToUpper(name[:1]) + strings.ToLower(name[1:]) return reflect.TypeOf(cli).MethodByName(methodName) } func ParseCommands(addr string, port int, args ...string) error { cli := NewDockerCli(addr, port) if len(args) > 0 { method, exists := cli.getMethod(args[0]) if !exists { fmt.Println("Error: Command not found:", args[0]) return cli.CmdHelp(args[1:]...) } ret := method.Func.CallSlice([]reflect.Value{ reflect.ValueOf(cli), reflect.ValueOf(args[1:]), })[0].Interface() if ret == nil { return nil } return ret.(error) } return cli.CmdHelp(args...) } func (cli *DockerCli) CmdHelp(args ...string) error { if len(args) > 0 { method, exists := cli.getMethod(args[0]) if !exists { fmt.Println("Error: Command not found:", args[0]) } else { method.Func.CallSlice([]reflect.Value{ reflect.ValueOf(cli), reflect.ValueOf([]string{"--help"}), })[0].Interface() return nil } } help := fmt.Sprintf("Usage: docker [OPTIONS] COMMAND [arg...]\n -H=\"%s:%d\": Host:port to bind/connect to\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n", cli.host, cli.port) for _, command := range [][2]string{ {"attach", "Attach to a running container"}, {"build", "Build a container from a Dockerfile"}, {"commit", "Create a new image from a container's changes"}, {"diff", "Inspect changes on a container's filesystem"}, {"export", "Stream the contents of a container as a tar archive"}, {"history", "Show the history of an image"}, {"images", "List images"}, {"import", "Create a new filesystem image from the contents of a tarball"}, {"info", "Display system-wide information"}, {"insert", "Insert a file in an image"}, {"inspect", "Return low-level information on a container"}, {"kill", "Kill a running container"}, {"login", "Register or Login to the docker registry server"}, {"logs", "Fetch the logs of a container"}, {"port", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT"}, {"ps", "List containers"}, {"pull", "Pull an image or a repository from the docker registry server"}, {"push", "Push an image or a repository to the docker registry server"}, {"restart", "Restart a running container"}, {"rm", "Remove a container"}, {"rmi", "Remove an image"}, {"run", "Run a command in a new container"}, {"search", "Search for an image in the docker index"}, {"start", "Start a stopped container"}, {"stop", "Stop a running container"}, {"tag", "Tag an image into a repository"}, {"version", "Show the docker version information"}, {"wait", "Block until a container stops, then print its exit code"}, } { help += fmt.Sprintf(" %-10.10s%s\n", command[0], command[1]) } fmt.Println(help) return nil } func (cli *DockerCli) CmdInsert(args ...string) error { cmd := Subcmd("insert", "IMAGE URL PATH", "Insert a file from URL in the IMAGE at PATH") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 3 { cmd.Usage() return nil } v := url.Values{} v.Set("url", cmd.Arg(1)) v.Set("path", cmd.Arg(2)) if err := cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, os.Stdout); err != nil { return err } return nil } func (cli *DockerCli) CmdBuild(args ...string) error { cmd := Subcmd("build", "[OPTIONS] PATH | -", "Build a new container image from the source code at PATH") tag := cmd.String("t", "", "Tag to be applied to the resulting image in case of success") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } var ( multipartBody io.Reader file io.ReadCloser contextPath string ) // Init the needed component for the Multipart buff := bytes.NewBuffer([]byte{}) multipartBody = buff w := multipart.NewWriter(buff) boundary := strings.NewReader("\r\n--" + w.Boundary() + "--\r\n") compression := Bzip2 if cmd.Arg(0) == "-" { file = os.Stdin } else { // Send Dockerfile from arg/Dockerfile (deprecate later) f, err := os.Open(path.Join(cmd.Arg(0), "Dockerfile")) if err != nil { return err } file = f // Send context from arg // Create a FormFile multipart for the context if needed // FIXME: Use NewTempArchive in order to have the size and avoid too much memory usage? context, err := Tar(cmd.Arg(0), compression) if err != nil { return err } // NOTE: Do this in case '.' or '..' is input absPath, err := filepath.Abs(cmd.Arg(0)) if err != nil { return err } wField, err := w.CreateFormFile("Context", filepath.Base(absPath)+"."+compression.Extension()) if err != nil { return err } // FIXME: Find a way to have a progressbar for the upload too sf := utils.NewStreamFormatter(false) io.Copy(wField, utils.ProgressReader(ioutil.NopCloser(context), -1, os.Stdout, sf.FormatProgress("Caching Context", "%v/%v (%v)"), sf)) multipartBody = io.MultiReader(multipartBody, boundary) } // Create a FormFile multipart for the Dockerfile wField, err := w.CreateFormFile("Dockerfile", "Dockerfile") if err != nil { return err } io.Copy(wField, file) multipartBody = io.MultiReader(multipartBody, boundary) v := &url.Values{} v.Set("t", *tag) // Send the multipart request with correct content-type req, err := http.NewRequest("POST", fmt.Sprintf("http://%s:%d%s?%s", cli.host, cli.port, "/build", v.Encode()), multipartBody) if err != nil { return err } req.Header.Set("Content-Type", w.FormDataContentType()) if contextPath != "" { req.Header.Set("X-Docker-Context-Compression", compression.Flag()) fmt.Println("Uploading Context...") } resp, err := http.DefaultClient.Do(req) if err != nil { return err } defer resp.Body.Close() // Check for errors if resp.StatusCode < 200 || resp.StatusCode >= 400 { body, err := ioutil.ReadAll(resp.Body) if err != nil { return err } return fmt.Errorf("error: %s", body) } // Output the result if _, err := io.Copy(os.Stdout, resp.Body); err != nil { return err } return nil } // 'docker login': login / register a user to registry service. func (cli *DockerCli) CmdLogin(args ...string) error { var readStringOnRawTerminal = func(stdin io.Reader, stdout io.Writer, echo bool) string { char := make([]byte, 1) buffer := make([]byte, 64) var i = 0 for i < len(buffer) { n, err := stdin.Read(char) if n > 0 { if char[0] == '\r' || char[0] == '\n' { stdout.Write([]byte{'\r', '\n'}) break } else if char[0] == 127 || char[0] == '\b' { if i > 0 { if echo { stdout.Write([]byte{'\b', ' ', '\b'}) } i-- } } else if !unicode.IsSpace(rune(char[0])) && !unicode.IsControl(rune(char[0])) { if echo { stdout.Write(char) } buffer[i] = char[0] i++ } } if err != nil { if err != io.EOF { fmt.Fprintf(stdout, "Read error: %v\r\n", err) } break } } return string(buffer[:i]) } var readAndEchoString = func(stdin io.Reader, stdout io.Writer) string { return readStringOnRawTerminal(stdin, stdout, true) } var readString = func(stdin io.Reader, stdout io.Writer) string { return readStringOnRawTerminal(stdin, stdout, false) } oldState, err := term.SetRawTerminal() if err != nil { return err } defer term.RestoreTerminal(oldState) cmd := Subcmd("login", "", "Register or Login to the docker registry server") if err := cmd.Parse(args); err != nil { return nil } body, _, err := cli.call("GET", "/auth", nil) if err != nil { return err } var out auth.AuthConfig err = json.Unmarshal(body, &out) if err != nil { return err } var username string var password string var email string fmt.Print("Username (", out.Username, "): ") username = readAndEchoString(os.Stdin, os.Stdout) if username == "" { username = out.Username } if username != out.Username { fmt.Print("Password: ") password = readString(os.Stdin, os.Stdout) if password == "" { return fmt.Errorf("Error : Password Required") } fmt.Print("Email (", out.Email, "): ") email = readAndEchoString(os.Stdin, os.Stdout) if email == "" { email = out.Email } } else { email = out.Email } out.Username = username out.Password = password out.Email = email body, _, err = cli.call("POST", "/auth", out) if err != nil { return err } var out2 APIAuth err = json.Unmarshal(body, &out2) if err != nil { return err } if out2.Status != "" { term.RestoreTerminal(oldState) fmt.Print(out2.Status) } return nil } // 'docker wait': block until a container stops func (cli *DockerCli) CmdWait(args ...string) error { cmd := Subcmd("wait", "CONTAINER [CONTAINER...]", "Block until a container stops, then print its exit code.") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } for _, name := range cmd.Args() { body, _, err := cli.call("POST", "/containers/"+name+"/wait", nil) if err != nil { fmt.Printf("%s", err) } else { var out APIWait err = json.Unmarshal(body, &out) if err != nil { return err } fmt.Println(out.StatusCode) } } return nil } // 'docker version': show version information func (cli *DockerCli) CmdVersion(args ...string) error { cmd := Subcmd("version", "", "Show the docker version information.") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() > 0 { cmd.Usage() return nil } body, _, err := cli.call("GET", "/version", nil) if err != nil { return err } var out APIVersion err = json.Unmarshal(body, &out) if err != nil { utils.Debugf("Error unmarshal: body: %s, err: %s\n", body, err) return err } fmt.Println("Client version:", VERSION) fmt.Println("Server version:", out.Version) if out.GitCommit != "" { fmt.Println("Git commit:", out.GitCommit) } if out.GoVersion != "" { fmt.Println("Go version:", out.GoVersion) } return nil } // 'docker info': display system-wide information. func (cli *DockerCli) CmdInfo(args ...string) error { cmd := Subcmd("info", "", "Display system-wide information") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() > 0 { cmd.Usage() return nil } body, _, err := cli.call("GET", "/info", nil) if err != nil { return err } var out APIInfo if err := json.Unmarshal(body, &out); err != nil { return err } fmt.Printf("Containers: %d\n", out.Containers) fmt.Printf("Images: %d\n", out.Images) if out.Debug || os.Getenv("DEBUG") != "" { fmt.Printf("Debug mode (server): %v\n", out.Debug) fmt.Printf("Debug mode (client): %v\n", os.Getenv("DEBUG") != "") fmt.Printf("Fds: %d\n", out.NFd) fmt.Printf("Goroutines: %d\n", out.NGoroutines) } if !out.MemoryLimit { fmt.Println("WARNING: No memory limit support") } if !out.SwapLimit { fmt.Println("WARNING: No swap limit support") } return nil } func (cli *DockerCli) CmdStop(args ...string) error { cmd := Subcmd("stop", "[OPTIONS] CONTAINER [CONTAINER...]", "Stop a running container") nSeconds := cmd.Int("t", 10, "wait t seconds before killing the container") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } v := url.Values{} v.Set("t", strconv.Itoa(*nSeconds)) for _, name := range cmd.Args() { _, _, err := cli.call("POST", "/containers/"+name+"/stop?"+v.Encode(), nil) if err != nil { fmt.Printf("%s", err) } else { fmt.Println(name) } } return nil } func (cli *DockerCli) CmdRestart(args ...string) error { cmd := Subcmd("restart", "[OPTIONS] CONTAINER [CONTAINER...]", "Restart a running container") nSeconds := cmd.Int("t", 10, "wait t seconds before killing the container") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } v := url.Values{} v.Set("t", strconv.Itoa(*nSeconds)) for _, name := range cmd.Args() { _, _, err := cli.call("POST", "/containers/"+name+"/restart?"+v.Encode(), nil) if err != nil { fmt.Printf("%s", err) } else { fmt.Println(name) } } return nil } func (cli *DockerCli) CmdStart(args ...string) error { cmd := Subcmd("start", "CONTAINER [CONTAINER...]", "Restart a stopped container") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } for _, name := range args { _, _, err := cli.call("POST", "/containers/"+name+"/start", nil) if err != nil { fmt.Printf("%s", err) } else { fmt.Println(name) } } return nil } func (cli *DockerCli) CmdInspect(args ...string) error { cmd := Subcmd("inspect", "CONTAINER|IMAGE", "Return low-level information on a container/image") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } obj, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil) if err != nil { obj, _, err = cli.call("GET", "/images/"+cmd.Arg(0)+"/json", nil) if err != nil { return err } } indented := new(bytes.Buffer) if err = json.Indent(indented, obj, "", " "); err != nil { return err } if _, err := io.Copy(os.Stdout, indented); err != nil { return err } return nil } func (cli *DockerCli) CmdPort(args ...string) error { cmd := Subcmd("port", "CONTAINER PRIVATE_PORT", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 2 { cmd.Usage() return nil } body, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil) if err != nil { return err } var out Container err = json.Unmarshal(body, &out) if err != nil { return err } if frontend, exists := out.NetworkSettings.PortMapping[cmd.Arg(1)]; exists { fmt.Println(frontend) } else { return fmt.Errorf("error: No private port '%s' allocated on %s", cmd.Arg(1), cmd.Arg(0)) } return nil } // 'docker rmi IMAGE' removes all images with the name IMAGE func (cli *DockerCli) CmdRmi(args ...string) error { cmd := Subcmd("rmi", "IMAGE [IMAGE...]", "Remove an image") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } for _, name := range cmd.Args() { _, _, err := cli.call("DELETE", "/images/"+name, nil) if err != nil { fmt.Printf("%s", err) } else { fmt.Println(name) } } return nil } func (cli *DockerCli) CmdHistory(args ...string) error { cmd := Subcmd("history", "IMAGE", "Show the history of an image") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } body, _, err := cli.call("GET", "/images/"+cmd.Arg(0)+"/history", nil) if err != nil { return err } var outs []APIHistory err = json.Unmarshal(body, &outs) if err != nil { return err } w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) fmt.Fprintln(w, "ID\tCREATED\tCREATED BY") for _, out := range outs { fmt.Fprintf(w, "%s\t%s ago\t%s\n", out.ID, utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.CreatedBy) } w.Flush() return nil } func (cli *DockerCli) CmdRm(args ...string) error { cmd := Subcmd("rm", "[OPTIONS] CONTAINER [CONTAINER...]", "Remove a container") v := cmd.Bool("v", false, "Remove the volumes associated to the container") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } val := url.Values{} if *v { val.Set("v", "1") } for _, name := range cmd.Args() { _, _, err := cli.call("DELETE", "/containers/"+name+"?"+val.Encode(), nil) if err != nil { fmt.Printf("%s", err) } else { fmt.Println(name) } } return nil } // 'docker kill NAME' kills a running container func (cli *DockerCli) CmdKill(args ...string) error { cmd := Subcmd("kill", "CONTAINER [CONTAINER...]", "Kill a running container") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } for _, name := range args { _, _, err := cli.call("POST", "/containers/"+name+"/kill", nil) if err != nil { fmt.Printf("%s", err) } else { fmt.Println(name) } } return nil } func (cli *DockerCli) CmdImport(args ...string) error { cmd := Subcmd("import", "URL|- [REPOSITORY [TAG]]", "Create a new filesystem image from the contents of a tarball") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() < 1 { cmd.Usage() return nil } src, repository, tag := cmd.Arg(0), cmd.Arg(1), cmd.Arg(2) v := url.Values{} v.Set("repo", repository) v.Set("tag", tag) v.Set("fromSrc", src) err := cli.stream("POST", "/images/create?"+v.Encode(), os.Stdin, os.Stdout) if err != nil { return err } return nil } func (cli *DockerCli) CmdPush(args ...string) error { cmd := Subcmd("push", "[OPTION] NAME", "Push an image or a repository to the registry") registry := cmd.String("registry", "", "Registry host to push the image to") if err := cmd.Parse(args); err != nil { return nil } name := cmd.Arg(0) if name == "" { cmd.Usage() return nil } username, err := cli.checkIfLogged(*registry == "", "push") if err != nil { return err } if len(strings.SplitN(name, "/", 2)) == 1 { return fmt.Errorf("Impossible to push a \"root\" repository. Please rename your repository in / (ex: %s/%s)", username, name) } v := url.Values{} v.Set("registry", *registry) if err := cli.stream("POST", "/images/"+name+"/push?"+v.Encode(), nil, os.Stdout); err != nil { return err } return nil } func (cli *DockerCli) CmdPull(args ...string) error { cmd := Subcmd("pull", "NAME", "Pull an image or a repository from the registry") tag := cmd.String("t", "", "Download tagged image in repository") registry := cmd.String("registry", "", "Registry to download from. Necessary if image is pulled by ID") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } remote := cmd.Arg(0) if strings.Contains(remote, ":") { remoteParts := strings.Split(remote, ":") tag = &remoteParts[1] remote = remoteParts[0] } v := url.Values{} v.Set("fromImage", remote) v.Set("tag", *tag) v.Set("registry", *registry) if err := cli.stream("POST", "/images/create?"+v.Encode(), nil, os.Stdout); err != nil { return err } return nil } func (cli *DockerCli) CmdImages(args ...string) error { cmd := Subcmd("images", "[OPTIONS] [NAME]", "List images") quiet := cmd.Bool("q", false, "only show numeric IDs") all := cmd.Bool("a", false, "show all images") noTrunc := cmd.Bool("notrunc", false, "Don't truncate output") flViz := cmd.Bool("viz", false, "output graph in graphviz format") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() > 1 { cmd.Usage() return nil } if *flViz { body, _, err := cli.call("GET", "/images/viz", false) if err != nil { return err } fmt.Printf("%s", body) } else { v := url.Values{} if cmd.NArg() == 1 { v.Set("filter", cmd.Arg(0)) } if *all { v.Set("all", "1") } body, _, err := cli.call("GET", "/images/json?"+v.Encode(), nil) if err != nil { return err } var outs []APIImages err = json.Unmarshal(body, &outs) if err != nil { return err } w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) if !*quiet { fmt.Fprintln(w, "REPOSITORY\tTAG\tID\tCREATED") } for _, out := range outs { if out.Repository == "" { out.Repository = "" } if out.Tag == "" { out.Tag = "" } if !*quiet { fmt.Fprintf(w, "%s\t%s\t", out.Repository, out.Tag) if *noTrunc { fmt.Fprintf(w, "%s\t", out.ID) } else { fmt.Fprintf(w, "%s\t", utils.TruncateID(out.ID)) } fmt.Fprintf(w, "%s ago\n", utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0)))) } else { if *noTrunc { fmt.Fprintln(w, out.ID) } else { fmt.Fprintln(w, utils.TruncateID(out.ID)) } } } if !*quiet { w.Flush() } } return nil } func (cli *DockerCli) CmdPs(args ...string) error { cmd := Subcmd("ps", "[OPTIONS]", "List containers") quiet := cmd.Bool("q", false, "Only display numeric IDs") all := cmd.Bool("a", false, "Show all containers. Only running containers are shown by default.") noTrunc := cmd.Bool("notrunc", false, "Don't truncate output") nLatest := cmd.Bool("l", false, "Show only the latest created container, include non-running ones.") since := cmd.String("sinceId", "", "Show only containers created since Id, include non-running ones.") before := cmd.String("beforeId", "", "Show only container created before Id, include non-running ones.") last := cmd.Int("n", -1, "Show n last created containers, include non-running ones.") if err := cmd.Parse(args); err != nil { return nil } v := url.Values{} if *last == -1 && *nLatest { *last = 1 } if *all { v.Set("all", "1") } if *last != -1 { v.Set("limit", strconv.Itoa(*last)) } if *since != "" { v.Set("since", *since) } if *before != "" { v.Set("before", *before) } body, _, err := cli.call("GET", "/containers/json?"+v.Encode(), nil) if err != nil { return err } var outs []APIContainers err = json.Unmarshal(body, &outs) if err != nil { return err } w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) if !*quiet { fmt.Fprintln(w, "ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tPORTS") } for _, out := range outs { if !*quiet { if *noTrunc { fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\t%s\n", out.ID, out.Image, out.Command, utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.Status, out.Ports) } else { fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\t%s\n", utils.TruncateID(out.ID), out.Image, utils.Trunc(out.Command, 20), utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.Status, out.Ports) } } else { if *noTrunc { fmt.Fprintln(w, out.ID) } else { fmt.Fprintln(w, utils.TruncateID(out.ID)) } } } if !*quiet { w.Flush() } return nil } func (cli *DockerCli) CmdCommit(args ...string) error { cmd := Subcmd("commit", "[OPTIONS] CONTAINER [REPOSITORY [TAG]]", "Create a new image from a container's changes") flComment := cmd.String("m", "", "Commit message") flAuthor := cmd.String("author", "", "Author (eg. \"John Hannibal Smith \"") flConfig := cmd.String("run", "", "Config automatically applied when the image is run. "+`(ex: {"Cmd": ["cat", "/world"], "PortSpecs": ["22"]}')`) if err := cmd.Parse(args); err != nil { return nil } name, repository, tag := cmd.Arg(0), cmd.Arg(1), cmd.Arg(2) if name == "" { cmd.Usage() return nil } v := url.Values{} v.Set("container", name) v.Set("repo", repository) v.Set("tag", tag) v.Set("comment", *flComment) v.Set("author", *flAuthor) var config *Config if *flConfig != "" { config = &Config{} if err := json.Unmarshal([]byte(*flConfig), config); err != nil { return err } } body, _, err := cli.call("POST", "/commit?"+v.Encode(), config) if err != nil { return err } apiID := &APIID{} err = json.Unmarshal(body, apiID) if err != nil { return err } fmt.Println(apiID.ID) return nil } func (cli *DockerCli) CmdExport(args ...string) error { cmd := Subcmd("export", "CONTAINER", "Export the contents of a filesystem as a tar archive") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } if err := cli.stream("GET", "/containers/"+cmd.Arg(0)+"/export", nil, os.Stdout); err != nil { return err } return nil } func (cli *DockerCli) CmdDiff(args ...string) error { cmd := Subcmd("diff", "CONTAINER", "Inspect changes on a container's filesystem") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } body, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/changes", nil) if err != nil { return err } changes := []Change{} err = json.Unmarshal(body, &changes) if err != nil { return err } for _, change := range changes { fmt.Println(change.String()) } return nil } func (cli *DockerCli) CmdLogs(args ...string) error { cmd := Subcmd("logs", "CONTAINER", "Fetch the logs of a container") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } if err := cli.stream("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stdout=1", nil, os.Stdout); err != nil { return err } if err := cli.stream("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stderr=1", nil, os.Stderr); err != nil { return err } return nil } func (cli *DockerCli) CmdAttach(args ...string) error { cmd := Subcmd("attach", "CONTAINER", "Attach to a running container") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } body, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil) if err != nil { return err } container := &Container{} err = json.Unmarshal(body, container) if err != nil { return err } splitStderr := container.Config.Tty connections := 1 if splitStderr { connections += 1 } chErrors := make(chan error, connections) cli.monitorTtySize(cmd.Arg(0)) if splitStderr { go func() { chErrors <- cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?stream=1&stderr=1", false, nil, os.Stderr) }() } v := url.Values{} v.Set("stream", "1") v.Set("stdin", "1") v.Set("stdout", "1") if !splitStderr { v.Set("stderr", "1") } go func() { chErrors <- cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), container.Config.Tty, os.Stdin, os.Stdout) }() for connections > 0 { err := <-chErrors if err != nil { return err } connections -= 1 } return nil } func (cli *DockerCli) CmdSearch(args ...string) error { cmd := Subcmd("search", "NAME", "Search the docker index for images") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 1 { cmd.Usage() return nil } v := url.Values{} v.Set("term", cmd.Arg(0)) body, _, err := cli.call("GET", "/images/search?"+v.Encode(), nil) if err != nil { return err } outs := []APISearch{} err = json.Unmarshal(body, &outs) if err != nil { return err } fmt.Printf("Found %d results matching your query (\"%s\")\n", len(outs), cmd.Arg(0)) w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) fmt.Fprintf(w, "NAME\tDESCRIPTION\n") for _, out := range outs { fmt.Fprintf(w, "%s\t%s\n", out.Name, out.Description) } w.Flush() return nil } // Ports type - Used to parse multiple -p flags type ports []int // ListOpts type type ListOpts []string func (opts *ListOpts) String() string { return fmt.Sprint(*opts) } func (opts *ListOpts) Set(value string) error { *opts = append(*opts, value) return nil } // AttachOpts stores arguments to 'docker run -a', eg. which streams to attach to type AttachOpts map[string]bool func NewAttachOpts() AttachOpts { return make(AttachOpts) } func (opts AttachOpts) String() string { // Cast to underlying map type to avoid infinite recursion return fmt.Sprintf("%v", map[string]bool(opts)) } func (opts AttachOpts) Set(val string) error { if val != "stdin" && val != "stdout" && val != "stderr" { return fmt.Errorf("Unsupported stream name: %s", val) } opts[val] = true return nil } func (opts AttachOpts) Get(val string) bool { if res, exists := opts[val]; exists { return res } return false } // PathOpts stores a unique set of absolute paths type PathOpts map[string]struct{} func NewPathOpts() PathOpts { return make(PathOpts) } func (opts PathOpts) String() string { return fmt.Sprintf("%v", map[string]struct{}(opts)) } func (opts PathOpts) Set(val string) error { if !filepath.IsAbs(val) { return fmt.Errorf("%s is not an absolute path", val) } opts[filepath.Clean(val)] = struct{}{} return nil } func (cli *DockerCli) CmdTag(args ...string) error { cmd := Subcmd("tag", "[OPTIONS] IMAGE REPOSITORY [TAG]", "Tag an image into a repository") force := cmd.Bool("f", false, "Force") if err := cmd.Parse(args); err != nil { return nil } if cmd.NArg() != 2 && cmd.NArg() != 3 { cmd.Usage() return nil } v := url.Values{} v.Set("repo", cmd.Arg(1)) if cmd.NArg() == 3 { v.Set("tag", cmd.Arg(2)) } if *force { v.Set("force", "1") } if _, _, err := cli.call("POST", "/images/"+cmd.Arg(0)+"/tag?"+v.Encode(), nil); err != nil { return err } return nil } func (cli *DockerCli) CmdRun(args ...string) error { config, cmd, err := ParseRun(args, nil) if err != nil { return err } if config.Image == "" { cmd.Usage() return nil } //create the container body, statusCode, err := cli.call("POST", "/containers/create", config) //if image not found try to pull it if statusCode == 404 { v := url.Values{} v.Set("fromImage", config.Image) err = cli.stream("POST", "/images/create?"+v.Encode(), nil, os.Stderr) if err != nil { return err } body, _, err = cli.call("POST", "/containers/create", config) if err != nil { return err } } if err != nil { return err } out := &APIRun{} err = json.Unmarshal(body, out) if err != nil { return err } for _, warning := range out.Warnings { fmt.Fprintln(os.Stderr, "WARNING: ", warning) } splitStderr := !config.Tty connections := 0 if config.AttachStdin || config.AttachStdout || (!splitStderr && config.AttachStderr) { connections += 1 } if splitStderr && config.AttachStderr { connections += 1 } //start the container _, _, err = cli.call("POST", "/containers/"+out.ID+"/start", nil) if err != nil { return err } if !config.AttachStdout && !config.AttachStderr { fmt.Println(out.ID) } if connections > 0 { chErrors := make(chan error, connections) cli.monitorTtySize(out.ID) if splitStderr && config.AttachStderr { go func() { chErrors <- cli.hijack("POST", "/containers/"+out.ID+"/attach?logs=1&stream=1&stderr=1", config.Tty, nil, os.Stderr) }() } v := url.Values{} v.Set("logs", "1") v.Set("stream", "1") if config.AttachStdin { v.Set("stdin", "1") } if config.AttachStdout { v.Set("stdout", "1") } if !splitStderr && config.AttachStderr { v.Set("stderr", "1") } go func() { chErrors <- cli.hijack("POST", "/containers/"+out.ID+"/attach?"+v.Encode(), config.Tty, os.Stdin, os.Stdout) }() for connections > 0 { err := <-chErrors if err != nil { return err } connections -= 1 } } return nil } func (cli *DockerCli) checkIfLogged(condition bool, action string) (string, error) { body, _, err := cli.call("GET", "/auth", nil) if err != nil { return "", err } var out auth.AuthConfig err = json.Unmarshal(body, &out) if err != nil { return "", err } // If condition AND the login failed if condition && out.Username == "" { if err := cli.CmdLogin(""); err != nil { return "", err } body, _, err = cli.call("GET", "/auth", nil) if err != nil { return "", err } err = json.Unmarshal(body, &out) if err != nil { return "", err } if out.Username == "" { return "", fmt.Errorf("Please login prior to %s. ('docker login')", action) } } return out.Username, nil } func (cli *DockerCli) call(method, path string, data interface{}) ([]byte, int, error) { var params io.Reader if data != nil { buf, err := json.Marshal(data) if err != nil { return nil, -1, err } params = bytes.NewBuffer(buf) } req, err := http.NewRequest(method, fmt.Sprintf("http://%s:%d/v%g%s", cli.host, cli.port, APIVERSION, path), params) if err != nil { return nil, -1, err } req.Header.Set("User-Agent", "Docker-Client/"+VERSION) if data != nil { req.Header.Set("Content-Type", "application/json") } else if method == "POST" { req.Header.Set("Content-Type", "plain/text") } resp, err := http.DefaultClient.Do(req) if err != nil { if strings.Contains(err.Error(), "connection refused") { return nil, -1, fmt.Errorf("Can't connect to docker daemon. Is 'docker -d' running on this host?") } return nil, -1, err } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { return nil, -1, err } if resp.StatusCode < 200 || resp.StatusCode >= 400 { return nil, resp.StatusCode, fmt.Errorf("error: %s", body) } return body, resp.StatusCode, nil } func (cli *DockerCli) stream(method, path string, in io.Reader, out io.Writer) error { if (method == "POST" || method == "PUT") && in == nil { in = bytes.NewReader([]byte{}) } req, err := http.NewRequest(method, fmt.Sprintf("http://%s:%d/v%g%s", cli.host, cli.port, APIVERSION, path), in) if err != nil { return err } req.Header.Set("User-Agent", "Docker-Client/"+VERSION) if method == "POST" { req.Header.Set("Content-Type", "plain/text") } resp, err := http.DefaultClient.Do(req) if err != nil { if strings.Contains(err.Error(), "connection refused") { return fmt.Errorf("Can't connect to docker daemon. Is 'docker -d' running on this host?") } return err } defer resp.Body.Close() if resp.StatusCode < 200 || resp.StatusCode >= 400 { body, err := ioutil.ReadAll(resp.Body) if err != nil { return err } return fmt.Errorf("error: %s", body) } if resp.Header.Get("Content-Type") == "application/json" { dec := json.NewDecoder(resp.Body) for { var m utils.JSONMessage if err := dec.Decode(&m); err == io.EOF { break } else if err != nil { return err } if m.Progress != "" { fmt.Fprintf(out, "%s %s\r", m.Status, m.Progress) } else if m.Error != "" { return fmt.Errorf(m.Error) } else { fmt.Fprintf(out, "%s\n", m.Status) } } } else { if _, err := io.Copy(out, resp.Body); err != nil { return err } } return nil } func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in *os.File, out io.Writer) error { req, err := http.NewRequest(method, fmt.Sprintf("/v%g%s", APIVERSION, path), nil) if err != nil { return err } req.Header.Set("Content-Type", "plain/text") dial, err := net.Dial("tcp", fmt.Sprintf("%s:%d", cli.host, cli.port)) if err != nil { return err } clientconn := httputil.NewClientConn(dial, nil) clientconn.Do(req) defer clientconn.Close() rwc, br := clientconn.Hijack() defer rwc.Close() receiveStdout := utils.Go(func() error { _, err := io.Copy(out, br) return err }) if in != nil && setRawTerminal && term.IsTerminal(in.Fd()) && os.Getenv("NORAW") == "" { oldState, err := term.SetRawTerminal() if err != nil { return err } defer term.RestoreTerminal(oldState) } sendStdin := utils.Go(func() error { _, err := io.Copy(rwc, in) if err := rwc.(*net.TCPConn).CloseWrite(); err != nil { fmt.Fprintf(os.Stderr, "Couldn't send EOF: %s\n", err) } return err }) if err := <-receiveStdout; err != nil { return err } if !term.IsTerminal(os.Stdin.Fd()) { if err := <-sendStdin; err != nil { return err } } return nil } func (cli *DockerCli) resizeTty(id string) { ws, err := term.GetWinsize(os.Stdin.Fd()) if err != nil { utils.Debugf("Error getting size: %s", err) } v := url.Values{} v.Set("h", strconv.Itoa(int(ws.Height))) v.Set("w", strconv.Itoa(int(ws.Width))) if _, _, err := cli.call("POST", "/containers/"+id+"/resize?"+v.Encode(), nil); err != nil { utils.Debugf("Error resize: %s", err) } } func (cli *DockerCli) monitorTtySize(id string) { cli.resizeTty(id) c := make(chan os.Signal, 1) signal.Notify(c, syscall.SIGWINCH) go func() { for sig := range c { if sig == syscall.SIGWINCH { cli.resizeTty(id) } } }() } func Subcmd(name, signature, description string) *flag.FlagSet { flags := flag.NewFlagSet(name, flag.ContinueOnError) flags.Usage = func() { fmt.Printf("\nUsage: docker %s %s\n\n%s\n\n", name, signature, description) flags.PrintDefaults() } return flags } func NewDockerCli(addr string, port int) *DockerCli { return &DockerCli{addr, port} } type DockerCli struct { host string port int }