package api

import (

"bufio"

"bytes"

"encoding/base64"

"encoding/json"

"errors"

"fmt"

"github.com/dotcloud/docker/archive"

"github.com/dotcloud/docker/auth"

"github.com/dotcloud/docker/dockerversion"

"github.com/dotcloud/docker/engine"

"github.com/dotcloud/docker/nat"

flag "github.com/dotcloud/docker/pkg/mflag"

"github.com/dotcloud/docker/pkg/signal"

"github.com/dotcloud/docker/pkg/term"

"github.com/dotcloud/docker/registry"

"github.com/dotcloud/docker/runconfig"

"github.com/dotcloud/docker/utils"

"io"

"io/ioutil"

"net"

"net/http"

"net/http/httputil"

"net/url"

"os"

gosignal "os/signal"

"path"

"reflect"

"regexp"

goruntime "runtime"

"strconv"

"strings"

"syscall"

"text/tabwriter"

"text/template"

"time"

)

var funcMap = template.FuncMap{

"json": func(v interface{}) string {

a, _ := json.Marshal(v)

return string(a)

},

}

var (

ErrConnectionRefused = errors.New("Cannot connect to the Docker daemon. Is 'docker -d' running on this host?")

)

func (cli *DockerCli) getMethod(name string) (func(...string) error, bool) {

methodName := "Cmd" + strings.ToUpper(name[:1]) + strings.ToLower(name[1:])

method := reflect.ValueOf(cli).MethodByName(methodName)

if !method.IsValid() {

return nil, false

}

return method.Interface().(func(...string) error), true

}

func ParseCommands(proto, addr string, args ...string) error {

cli := NewDockerCli(os.Stdin, os.Stdout, os.Stderr, proto, addr)

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:]...)

}

return method(args[1:]...)

}

return cli.CmdHelp(args...)

}

func (cli *DockerCli) CmdHelp(args ...string) error {

if len(args) > 0 {

method, exists := cli.getMethod(args[0])

if !exists {

fmt.Fprintf(cli.err, "Error: Command not found: %s\n", args[0])

} else {

method("--help")

return nil

}

}

help := fmt.Sprintf("Usage: docker [OPTIONS] COMMAND [arg...]\n -H=[unix://%s]: tcp://host:port to bind/connect to or unix://path/to/socket to use\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n", DEFAULTUNIXSOCKET)

for _, command := range [][]string{

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

{"build", "Build a container from a Dockerfile"},

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

{"cp", "Copy files/folders from the containers filesystem to the host path"},

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

{"events", "Get real time events from the server"},

{"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"},

{"load", "Load an image from a tar archive"},

{"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 one or more containers"},

{"rmi", "Remove one or more images"},

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

{"save", "Save an image to a tar archive"},

{"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"},

{"top", "Lookup the running processes of a container"},

{"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.Fprintf(cli.err, "%s\n", help)

return nil

}

func (cli *DockerCli) CmdInsert(args ...string) error {

cmd := cli.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))

return cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, cli.out, nil)

}

func (cli *DockerCli) CmdBuild(args ...string) error {

cmd := cli.Subcmd("build", "[OPTIONS] PATH | URL | -", "Build a new container image from the source code at PATH")

tag := cmd.String([]string{"t", "-tag"}, "", "Repository name (and optionally a tag) to be applied to the resulting image in case of success")

suppressOutput := cmd.Bool([]string{"q", "-quiet"}, false, "Suppress the verbose output generated by the containers")

noCache := cmd.Bool([]string{"#no-cache", "-no-cache"}, false, "Do not use cache when building the image")

rm := cmd.Bool([]string{"#rm", "-rm"}, true, "Remove intermediate containers after a successful build")

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

return nil

}

if cmd.NArg() != 1 {

cmd.Usage()

return nil

}

var (

context archive.Archive

isRemote bool

err error

)

if cmd.Arg(0) == "-" {

// As a special case, 'docker build -' will build from an empty context with the

// contents of stdin as a Dockerfile

dockerfile, err := ioutil.ReadAll(cli.in)

if err != nil {

return err

}

context, err = archive.Generate("Dockerfile", string(dockerfile))

} else if utils.IsURL(cmd.Arg(0)) || utils.IsGIT(cmd.Arg(0)) {

isRemote = true

} else {

if _, err := os.Stat(cmd.Arg(0)); err != nil {

return err

}

filename := path.Join(cmd.Arg(0), "Dockerfile")

if _, err = os.Stat(filename); os.IsNotExist(err) {

return fmt.Errorf("no Dockerfile found in %s", cmd.Arg(0))

}

context, err = archive.Tar(cmd.Arg(0), archive.Uncompressed)

}

var body io.Reader

// Setup an upload progress bar

// FIXME: ProgressReader shouldn't be this annoying to use

if context != nil {

sf := utils.NewStreamFormatter(false)

body = utils.ProgressReader(context, 0, cli.err, sf, true, "", "Uploading context")

}

// Upload the build context

v := &url.Values{}

v.Set("t", *tag)

if *suppressOutput {

v.Set("q", "1")

}

if isRemote {

v.Set("remote", cmd.Arg(0))

}

if *noCache {

v.Set("nocache", "1")

}

if *rm {

v.Set("rm", "1")

}

cli.LoadConfigFile()

headers := http.Header(make(map[string][]string))

buf, err := json.Marshal(cli.configFile)

if err != nil {

return err

}

headers.Add("X-Registry-Config", base64.URLEncoding.EncodeToString(buf))

if context != nil {

headers.Set("Content-Type", "application/tar")

}

err = cli.stream("POST", fmt.Sprintf("/build?%s", v.Encode()), body, cli.out, headers)

if jerr, ok := err.(*utils.JSONError); ok {

// If no error code is set, default to 1

if jerr.Code == 0 {

jerr.Code = 1

}

return &utils.StatusError{Status: jerr.Message, StatusCode: jerr.Code}

}

return err

}

// 'docker login': login / register a user to registry service.

func (cli *DockerCli) CmdLogin(args ...string) error {

cmd := cli.Subcmd("login", "[OPTIONS] [SERVER]", "Register or Login to a docker registry server, if no server is specified \""+auth.IndexServerAddress()+"\" is the default.")

var username, password, email string

cmd.StringVar(&username, []string{"u", "-username"}, "", "Username")

cmd.StringVar(&password, []string{"p", "-password"}, "", "Password")

cmd.StringVar(&email, []string{"e", "-email"}, "", "Email")

err := cmd.Parse(args)

if err != nil {

return nil

}

serverAddress := auth.IndexServerAddress()

if len(cmd.Args()) > 0 {

serverAddress = cmd.Arg(0)

}

promptDefault := func(prompt string, configDefault string) {

if configDefault == "" {

fmt.Fprintf(cli.out, "%s: ", prompt)

} else {

fmt.Fprintf(cli.out, "%s (%s): ", prompt, configDefault)

}

}

readInput := func(in io.Reader, out io.Writer) string {

reader := bufio.NewReader(in)

line, _, err := reader.ReadLine()

if err != nil {

fmt.Fprintln(out, err.Error())

os.Exit(1)

}

return string(line)

}

cli.LoadConfigFile()

authconfig, ok := cli.configFile.Configs[serverAddress]

if !ok {

authconfig = auth.AuthConfig{}

}

if username == "" {

promptDefault("Username", authconfig.Username)

username = readInput(cli.in, cli.out)

if username == "" {

username = authconfig.Username

}

}

if username != authconfig.Username {

if password == "" {

oldState, _ := term.SaveState(cli.terminalFd)

fmt.Fprintf(cli.out, "Password: ")

term.DisableEcho(cli.terminalFd, oldState)

password = readInput(cli.in, cli.out)

fmt.Fprint(cli.out, "\n")

term.RestoreTerminal(cli.terminalFd, oldState)

if password == "" {

return fmt.Errorf("Error : Password Required")

}

}

if email == "" {

promptDefault("Email", authconfig.Email)

email = readInput(cli.in, cli.out)

if email == "" {

email = authconfig.Email

}

}

} else {

password = authconfig.Password

email = authconfig.Email

}

authconfig.Username = username

authconfig.Password = password

authconfig.Email = email

authconfig.ServerAddress = serverAddress

cli.configFile.Configs[serverAddress] = authconfig

stream, statusCode, err := cli.call("POST", "/auth", cli.configFile.Configs[serverAddress], false)

if statusCode == 401 {

delete(cli.configFile.Configs, serverAddress)

auth.SaveConfig(cli.configFile)

return err

}

if err != nil {

return err

}

var out2 engine.Env

err = out2.Decode(stream)

if err != nil {

cli.configFile, _ = auth.LoadConfig(os.Getenv("HOME"))

return err

}

auth.SaveConfig(cli.configFile)

if out2.Get("Status") != "" {

fmt.Fprintf(cli.out, "%s\n", out2.Get("Status"))

}

return nil

}

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

func (cli *DockerCli) CmdWait(args ...string) error {

cmd := cli.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

}

var encounteredError error

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

status, err := waitForExit(cli, name)

if err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to wait one or more containers")

} else {

fmt.Fprintf(cli.out, "%d\n", status)

}

}

return encounteredError

}

// 'docker version': show version information

func (cli *DockerCli) CmdVersion(args ...string) error {

cmd := cli.Subcmd("version", "", "Show the docker version information.")

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

return nil

}

if cmd.NArg() > 0 {

cmd.Usage()

return nil

}

if dockerversion.VERSION != "" {

fmt.Fprintf(cli.out, "Client version: %s\n", dockerversion.VERSION)

}

fmt.Fprintf(cli.out, "Go version (client): %s\n", goruntime.Version())

if dockerversion.GITCOMMIT != "" {

fmt.Fprintf(cli.out, "Git commit (client): %s\n", dockerversion.GITCOMMIT)

}

body, _, err := readBody(cli.call("GET", "/version", nil, false))

if err != nil {

return err

}

out := engine.NewOutput()

remoteVersion, err := out.AddEnv()

if err != nil {

utils.Errorf("Error reading remote version: %s\n", err)

return err

}

if _, err := out.Write(body); err != nil {

utils.Errorf("Error reading remote version: %s\n", err)

return err

}

out.Close()

fmt.Fprintf(cli.out, "Server version: %s\n", remoteVersion.Get("Version"))

fmt.Fprintf(cli.out, "Git commit (server): %s\n", remoteVersion.Get("GitCommit"))

fmt.Fprintf(cli.out, "Go version (server): %s\n", remoteVersion.Get("GoVersion"))

release := utils.GetReleaseVersion()

if release != "" {

fmt.Fprintf(cli.out, "Last stable version: %s", release)

if (dockerversion.VERSION != "" || remoteVersion.Exists("Version")) && (strings.Trim(dockerversion.VERSION, "-dev") != release || strings.Trim(remoteVersion.Get("Version"), "-dev") != release) {

fmt.Fprintf(cli.out, ", please update docker")

}

fmt.Fprintf(cli.out, "\n")

}

return nil

}

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

func (cli *DockerCli) CmdInfo(args ...string) error {

cmd := cli.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 := readBody(cli.call("GET", "/info", nil, false))

if err != nil {

return err

}

out := engine.NewOutput()

remoteInfo, err := out.AddEnv()

if err != nil {

return err

}

if _, err := out.Write(body); err != nil {

utils.Errorf("Error reading remote info: %s\n", err)

return err

}

out.Close()

fmt.Fprintf(cli.out, "Containers: %d\n", remoteInfo.GetInt("Containers"))

fmt.Fprintf(cli.out, "Images: %d\n", remoteInfo.GetInt("Images"))

fmt.Fprintf(cli.out, "Storage Driver: %s\n", remoteInfo.Get("Driver"))

var driverStatus [][2]string

if err := remoteInfo.GetJson("DriverStatus", &driverStatus); err != nil {

return err

}

for _, pair := range driverStatus {

fmt.Fprintf(cli.out, " %s: %s\n", pair[0], pair[1])

}

fmt.Fprintf(cli.out, "Execution Driver: %s\n", remoteInfo.Get("ExecutionDriver"))

fmt.Fprintf(cli.out, "Kernel Version: %s\n", remoteInfo.Get("KernelVersion"))

if remoteInfo.GetBool("Debug") || os.Getenv("DEBUG") != "" {

fmt.Fprintf(cli.out, "Debug mode (server): %v\n", remoteInfo.GetBool("Debug"))

fmt.Fprintf(cli.out, "Debug mode (client): %v\n", os.Getenv("DEBUG") != "")

fmt.Fprintf(cli.out, "Fds: %d\n", remoteInfo.GetInt("NFd"))

fmt.Fprintf(cli.out, "Goroutines: %d\n", remoteInfo.GetInt("NGoroutines"))

fmt.Fprintf(cli.out, "EventsListeners: %d\n", remoteInfo.GetInt("NEventsListener"))

if initSha1 := remoteInfo.Get("InitSha1"); initSha1 != "" {

fmt.Fprintf(cli.out, "Init SHA1: %s\n", initSha1)

}

if initPath := remoteInfo.Get("InitPath"); initPath != "" {

fmt.Fprintf(cli.out, "Init Path: %s\n", initPath)

}

}

if len(remoteInfo.GetList("IndexServerAddress")) != 0 {

cli.LoadConfigFile()

u := cli.configFile.Configs[remoteInfo.Get("IndexServerAddress")].Username

if len(u) > 0 {

fmt.Fprintf(cli.out, "Username: %v\n", u)

fmt.Fprintf(cli.out, "Registry: %v\n", remoteInfo.GetList("IndexServerAddress"))

}

}

if !remoteInfo.GetBool("MemoryLimit") {

fmt.Fprintf(cli.err, "WARNING: No memory limit support\n")

}

if !remoteInfo.GetBool("SwapLimit") {

fmt.Fprintf(cli.err, "WARNING: No swap limit support\n")

}

if !remoteInfo.GetBool("IPv4Forwarding") {

fmt.Fprintf(cli.err, "WARNING: IPv4 forwarding is disabled.\n")

}

return nil

}

func (cli *DockerCli) CmdStop(args ...string) error {

cmd := cli.Subcmd("stop", "[OPTIONS] CONTAINER [CONTAINER...]", "Stop a running container (Send SIGTERM, and then SIGKILL after grace period)")

nSeconds := cmd.Int([]string{"t", "-time"}, 10, "Number of seconds to wait for the container to stop before killing it.")

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))

var encounteredError error

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

_, _, err := readBody(cli.call("POST", "/containers/"+name+"/stop?"+v.Encode(), nil, false))

if err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to stop one or more containers")

} else {

fmt.Fprintf(cli.out, "%s\n", name)

}

}

return encounteredError

}

func (cli *DockerCli) CmdRestart(args ...string) error {

cmd := cli.Subcmd("restart", "[OPTIONS] CONTAINER [CONTAINER...]", "Restart a running container")

nSeconds := cmd.Int([]string{"t", "-time"}, 10, "Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default=10")

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))

var encounteredError error

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

_, _, err := readBody(cli.call("POST", "/containers/"+name+"/restart?"+v.Encode(), nil, false))

if err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to restart one or more containers")

} else {

fmt.Fprintf(cli.out, "%s\n", name)

}

}

return encounteredError

}

func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {

sigc := make(chan os.Signal, 1)

signal.CatchAll(sigc)

go func() {

for s := range sigc {

if s == syscall.SIGCHLD {

continue

}

var sig string

for sigStr, sigN := range signal.SignalMap {

if sigN == s {

sig = sigStr

break

}

}

if sig == "" {

utils.Errorf("Unsupported signal: %d. Discarding.", s)

}

if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%s", cid, sig), nil, false)); err != nil {

utils.Debugf("Error sending signal: %s", err)

}

}

}()

return sigc

}

func (cli *DockerCli) CmdStart(args ...string) error {

cmd := cli.Subcmd("start", "CONTAINER [CONTAINER...]", "Restart a stopped container")

attach := cmd.Bool([]string{"a", "-attach"}, false, "Attach container's stdout/stderr and forward all signals to the process")

openStdin := cmd.Bool([]string{"i", "-interactive"}, false, "Attach container's stdin")

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

return nil

}

if cmd.NArg() < 1 {

cmd.Usage()

return nil

}

var cErr chan error

var tty bool

if *attach || *openStdin {

if cmd.NArg() > 1 {

return fmt.Errorf("You cannot start and attach multiple containers at once.")

}

body, _, err := readBody(cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil, false))

if err != nil {

return err

}

container := &Container{}

err = json.Unmarshal(body, container)

if err != nil {

return err

}

tty = container.Config.Tty

if !container.Config.Tty {

sigc := cli.forwardAllSignals(cmd.Arg(0))

defer signal.StopCatch(sigc)

}

var in io.ReadCloser

v := url.Values{}

v.Set("stream", "1")

if *openStdin && container.Config.OpenStdin {

v.Set("stdin", "1")

in = cli.in

}

v.Set("stdout", "1")

v.Set("stderr", "1")

cErr = utils.Go(func() error {

return cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), container.Config.Tty, in, cli.out, cli.err, nil)

})

}

var encounteredError error

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

_, _, err := readBody(cli.call("POST", "/containers/"+name+"/start", nil, false))

if err != nil {

if !*attach || !*openStdin {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to start one or more containers")

}

} else {

if !*attach || !*openStdin {

fmt.Fprintf(cli.out, "%s\n", name)

}

}

}

if encounteredError != nil {

if *openStdin || *attach {

cli.in.Close()

<-cErr

}

return encounteredError

}

if *openStdin || *attach {

if tty && cli.isTerminal {

if err := cli.monitorTtySize(cmd.Arg(0)); err != nil {

utils.Errorf("Error monitoring TTY size: %s\n", err)

}

}

return <-cErr

}

return nil

}

func (cli *DockerCli) CmdInspect(args ...string) error {

cmd := cli.Subcmd("inspect", "CONTAINER|IMAGE [CONTAINER|IMAGE...]", "Return low-level information on a container/image")

tmplStr := cmd.String([]string{"f", "#format", "-format"}, "", "Format the output using the given go template.")

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

return nil

}

if cmd.NArg() < 1 {

cmd.Usage()

return nil

}

var tmpl *template.Template

if *tmplStr != "" {

var err error

if tmpl, err = template.New("").Funcs(funcMap).Parse(*tmplStr); err != nil {

fmt.Fprintf(cli.err, "Template parsing error: %v\n", err)

return &utils.StatusError{StatusCode: 64,

Status: "Template parsing error: " + err.Error()}

}

}

indented := new(bytes.Buffer)

indented.WriteByte('[')

status := 0

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

obj, _, err := readBody(cli.call("GET", "/containers/"+name+"/json", nil, false))

if err != nil {

obj, _, err = readBody(cli.call("GET", "/images/"+name+"/json", nil, false))

if err != nil {

if strings.Contains(err.Error(), "No such") {

fmt.Fprintf(cli.err, "Error: No such image or container: %s\n", name)

} else {

fmt.Fprintf(cli.err, "%s", err)

}

status = 1

continue

}

}

if tmpl == nil {

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

fmt.Fprintf(cli.err, "%s\n", err)

status = 1

continue

}

} else {

// Has template, will render

var value interface{}

if err := json.Unmarshal(obj, &value); err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

status = 1

continue

}

if err := tmpl.Execute(cli.out, value); err != nil {

return err

}

cli.out.Write([]byte{'\n'})

}

indented.WriteString(",")

}

if indented.Len() > 1 {

// Remove trailing ','

indented.Truncate(indented.Len() - 1)

}

indented.WriteByte(']')

if tmpl == nil {

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

return err

}

}

if status != 0 {

return &utils.StatusError{StatusCode: status}

}

return nil

}

func (cli *DockerCli) CmdTop(args ...string) error {

cmd := cli.Subcmd("top", "CONTAINER [ps OPTIONS]", "Lookup the running processes of a container")

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

return nil

}

if cmd.NArg() == 0 {

cmd.Usage()

return nil

}

val := url.Values{}

if cmd.NArg() > 1 {

val.Set("ps_args", strings.Join(cmd.Args()[1:], " "))

}

stream, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/top?"+val.Encode(), nil, false)

if err != nil {

return err

}

var procs engine.Env

if err := procs.Decode(stream); err != nil {

return err

}

w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)

fmt.Fprintln(w, strings.Join(procs.GetList("Titles"), "\t"))

processes := [][]string{}

if err := procs.GetJson("Processes", &processes); err != nil {

return err

}

for _, proc := range processes {

fmt.Fprintln(w, strings.Join(proc, "\t"))

}

w.Flush()

return nil

}

func (cli *DockerCli) CmdPort(args ...string) error {

cmd := cli.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

}

port := cmd.Arg(1)

proto := "tcp"

parts := strings.SplitN(port, "/", 2)

if len(parts) == 2 && len(parts[1]) != 0 {

port = parts[0]

proto = parts[1]

}

body, _, err := readBody(cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil, false))

if err != nil {

return err

}

var out Container

err = json.Unmarshal(body, &out)

if err != nil {

return err

}

if frontends, exists := out.NetworkSettings.Ports[nat.Port(port+"/"+proto)]; exists && frontends != nil {

for _, frontend := range frontends {

fmt.Fprintf(cli.out, "%s:%s\n", frontend.HostIp, frontend.HostPort)

}

} else {

return fmt.Errorf("Error: No public port '%s' published for %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 {

var (

cmd = cli.Subcmd("rmi", "IMAGE [IMAGE...]", "Remove one or more images")

force = cmd.Bool([]string{"f", "-force"}, false, "Force")

)

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

return nil

}

if cmd.NArg() < 1 {

cmd.Usage()

return nil

}

v := url.Values{}

if *force {

v.Set("force", "1")

}

var encounteredError error

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

body, _, err := readBody(cli.call("DELETE", "/images/"+name+"?"+v.Encode(), nil, false))

if err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to remove one or more images")

} else {

outs := engine.NewTable("Created", 0)

if _, err := outs.ReadListFrom(body); err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to remove one or more images")

continue

}

for _, out := range outs.Data {

if out.Get("Deleted") != "" {

fmt.Fprintf(cli.out, "Deleted: %s\n", out.Get("Deleted"))

} else {

fmt.Fprintf(cli.out, "Untagged: %s\n", out.Get("Untagged"))

}

}

}

}

return encounteredError

}

func (cli *DockerCli) CmdHistory(args ...string) error {

cmd := cli.Subcmd("history", "[OPTIONS] IMAGE", "Show the history of an image")

quiet := cmd.Bool([]string{"q", "-quiet"}, false, "Only show numeric IDs")

noTrunc := cmd.Bool([]string{"#notrunc", "-no-trunc"}, false, "Don't truncate output")

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

return nil

}

if cmd.NArg() != 1 {

cmd.Usage()

return nil

}

body, _, err := readBody(cli.call("GET", "/images/"+cmd.Arg(0)+"/history", nil, false))

if err != nil {

return err

}

outs := engine.NewTable("Created", 0)

if _, err := outs.ReadListFrom(body); err != nil {

return err

}

w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)

if !*quiet {

fmt.Fprintln(w, "IMAGE\tCREATED\tCREATED BY\tSIZE")

}

for _, out := range outs.Data {

outID := out.Get("Id")

if !*quiet {

if *noTrunc {

fmt.Fprintf(w, "%s\t", outID)

} else {

fmt.Fprintf(w, "%s\t", utils.TruncateID(outID))

}

fmt.Fprintf(w, "%s ago\t", utils.HumanDuration(time.Now().UTC().Sub(time.Unix(out.GetInt64("Created"), 0))))

if *noTrunc {

fmt.Fprintf(w, "%s\t", out.Get("CreatedBy"))

} else {

fmt.Fprintf(w, "%s\t", utils.Trunc(out.Get("CreatedBy"), 45))

}

fmt.Fprintf(w, "%s\n", utils.HumanSize(out.GetInt64("Size")))

} else {

if *noTrunc {

fmt.Fprintln(w, outID)

} else {

fmt.Fprintln(w, utils.TruncateID(outID))

}

}

}

w.Flush()

return nil

}

func (cli *DockerCli) CmdRm(args ...string) error {

cmd := cli.Subcmd("rm", "[OPTIONS] CONTAINER [CONTAINER...]", "Remove one or more containers")

v := cmd.Bool([]string{"v", "-volumes"}, false, "Remove the volumes associated to the container")

link := cmd.Bool([]string{"l", "#link", "-link"}, false, "Remove the specified link and not the underlying container")

force := cmd.Bool([]string{"f", "-force"}, false, "Force removal of running 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")

}

if *link {

val.Set("link", "1")

}

if *force {

val.Set("force", "1")

}

var encounteredError error

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

_, _, err := readBody(cli.call("DELETE", "/containers/"+name+"?"+val.Encode(), nil, false))

if err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to remove one or more containers")

} else {

fmt.Fprintf(cli.out, "%s\n", name)

}

}

return encounteredError

}

// 'docker kill NAME' kills a running container

func (cli *DockerCli) CmdKill(args ...string) error {

cmd := cli.Subcmd("kill", "[OPTIONS] CONTAINER [CONTAINER...]", "Kill a running container (send SIGKILL, or specified signal)")

signal := cmd.String([]string{"s", "-signal"}, "KILL", "Signal to send to the container")

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

return nil

}

if cmd.NArg() < 1 {

cmd.Usage()

return nil

}

var encounteredError error

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

if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%s", name, *signal), nil, false)); err != nil {

fmt.Fprintf(cli.err, "%s\n", err)

encounteredError = fmt.Errorf("Error: failed to kill one or more containers")

} else {

fmt.Fprintf(cli.out, "%s\n", name)

}

}

return encounteredError

}

func (cli *DockerCli) CmdImport(args ...string) error {

cmd := cli.Subcmd("import", "URL|- [REPOSITORY[:TAG]]", "Create an empty filesystem image and import the contents of the tarball (.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz) into it, then optionally tag it.")

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

return nil

}

if cmd.NArg() < 1 {

cmd.Usage()

return nil

}

var src, repository, tag string

if cmd.NArg() == 3 {

fmt.Fprintf(cli.err, "[DEPRECATED] The format 'URL|- [REPOSITORY [TAG]]' as been deprecated. Please use URL|- [REPOSITORY[:TAG]]\n")

src, repository, tag = cmd.Arg(0), cmd.Arg(1), cmd.Arg(2)

} else {

src = cmd.Arg(0)

repository, tag = utils.ParseRepositoryTag(cmd.Arg(1))

}

v := url.Values{}

v.Set("repo", repository)

v.Set("tag", tag)

v.Set("fromSrc", src)

var in io.Reader

if src == "-" {

in = cli.in

}

return cli.stream("POST", "/images/create?"+v.Encode(), in, cli.out, nil)

}

func (cli *DockerCli) CmdPush(args ...string) error {

cmd := cli.Subcmd("push", "NAME", "Push an image or a repository to the registry")

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

return nil