new file mode 100644

@@ -0,0 +1,102 @@

+package client

+

+import (

+	"crypto/tls"

+	"encoding/json"

+	"fmt"

+	"io"

+	"os"

+	"reflect"

+	"strings"

+	"text/template"

+

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

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

+	"github.com/dotcloud/docker/registry"

+)

+

+var funcMap = template.FuncMap{

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

+		a, _ := json.Marshal(v)

+		return string(a)

+	},

+}

+

+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 (cli *DockerCli) ParseCommands(args ...string) error {

+	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) Subcmd(name, signature, description string) *flag.FlagSet {

+	flags := flag.NewFlagSet(name, flag.ContinueOnError)

+	flags.Usage = func() {

+		fmt.Fprintf(cli.err, "\nUsage: docker %s %s\n\n%s\n\n", name, signature, description)

+		flags.PrintDefaults()

+		os.Exit(2)

+	}

+	return flags

+}

+

+func (cli *DockerCli) LoadConfigFile() (err error) {

+	cli.configFile, err = registry.LoadConfig(os.Getenv("HOME"))

+	if err != nil {

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

+	}

+	return err

+}

+

+func NewDockerCli(in io.ReadCloser, out, err io.Writer, proto, addr string, tlsConfig *tls.Config) *DockerCli {

+	var (

+		isTerminal = false

+		terminalFd uintptr

+	)

+

+	if in != nil {

+		if file, ok := in.(*os.File); ok {

+			terminalFd = file.Fd()

+			isTerminal = term.IsTerminal(terminalFd)

+		}

+	}

+

+	if err == nil {

+		err = out

+	}

+	return &DockerCli{

+		proto:      proto,

+		addr:       addr,

+		in:         in,

+		out:        out,

+		err:        err,

+		isTerminal: isTerminal,

+		terminalFd: terminalFd,

+		tlsConfig:  tlsConfig,

+	}

+}

+

+type DockerCli struct {

+	proto      string

+	addr       string

+	configFile *registry.ConfigFile

+	in         io.ReadCloser

+	out        io.Writer

+	err        io.Writer

+	isTerminal bool

+	terminalFd uintptr

+	tlsConfig  *tls.Config

+}

deleted file mode 100644

@@ -1,2551 +0,0 @@

-package client

-

-import (

-	"bufio"

-	"bytes"

-	"crypto/tls"

-	"encoding/base64"

-	"encoding/json"

-	"errors"

-	"fmt"

-	"github.com/dotcloud/docker/api"

-	"github.com/dotcloud/docker/archive"

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

-	"os/exec"

-	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 (cli *DockerCli) ParseCommands(args ...string) error {

-	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", api.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

-	)

-

-	_, err = exec.LookPath("git")

-	hasGit := err == nil

-	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)) || !hasGit) {

-		isRemote = true

-	} else {

-		root := cmd.Arg(0)

-		if utils.IsGIT(root) {

-			remoteURL := cmd.Arg(0)

-			if !strings.HasPrefix(remoteURL, "git://") && !strings.HasPrefix(remoteURL, "git@") && !utils.IsURL(remoteURL) {

-				remoteURL = "https://" + remoteURL

-			}

-

-			root, err = ioutil.TempDir("", "docker-build-git")

-			if err != nil {

-				return err

-			}

-			defer os.RemoveAll(root)

-

-			if output, err := exec.Command("git", "clone", "--recursive", remoteURL, root).CombinedOutput(); err != nil {

-				return fmt.Errorf("Error trying to use git: %s (%s)", err, output)

-			}

-		}

-		if _, err := os.Stat(root); err != nil {

-			return err

-		}

-		filename := path.Join(root, "Dockerfile")

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

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

-		}

-		context, err = archive.Tar(root, 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{}

-

-	//Check if the given image name can be resolved

-	if *tag != "" {

-		repository, _ := utils.ParseRepositoryTag(*tag)

-		if _, _, err := registry.ResolveRepositoryName(repository); err != nil {

-			return err

-		}

-	}

-

-	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 \""+registry.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 := registry.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 = registry.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)

-		registry.SaveConfig(cli.configFile)

-		return err

-	}

-	if err != nil {

-		return err

-	}

-	var out2 engine.Env

-	err = out2.Decode(stream)

-	if err != nil {

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

-		return err

-	}

-	registry.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 := &api.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 {