@@ -15,6 +15,7 @@ Brian McCallister <brianm@skife.org>

 Bruno Bigras <bigras.bruno@gmail.com>

 Caleb Spare <cespare@gmail.com>

 Charles Hooper <charles.hooper@dotcloud.com>

+Daniel Gasienica <daniel@gasienica.ch>

 Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com>

 Daniel Robinson <gottagetmac@gmail.com>

 Daniel Von Fange <daniel@leancoder.com>

@@ -1,5 +1,14 @@

 # Changelog

+## 0.3.4 (2013-05-30)

+ + Builder: 'docker build' builds a container, layer by layer, from a source repository containing a Dockerfile

+ + Builder: 'docker build -t FOO' applies the tag FOO to the newly built container.

+ + Runtime: interactive TTYs correctly handle window resize

+ * Runtime: fix how configuration is merged between layers

+ + Remote API: split stdout and stderr on 'docker run'

+ + Remote API: optionally listen on a different IP and port (use at your own risk)

+ * Documentation: improved install instructions.

+

 ## 0.3.3 (2013-05-23)

  - Registry: Fix push regression

  - Various bugfixes

@@ -1,4 +1,5 @@

 Solomon Hykes <solomon@dotcloud.com>

 Guillaume Charmes <guillaume@dotcloud.com>

+Victor Vieux <victor@dotcloud.com>

 api.go: Victor Vieux <victor@dotcloud.com>

 Vagrantfile: Daniel Mizyrycki <daniel@dotcloud.com>

@@ -47,6 +47,8 @@ func httpError(w http.ResponseWriter, err error) {

 		http.Error(w, err.Error(), http.StatusBadRequest)

 	} else if strings.HasPrefix(err.Error(), "Conflict") {

 		http.Error(w, err.Error(), http.StatusConflict)

+	} else if strings.HasPrefix(err.Error(), "Impossible") {

+		http.Error(w, err.Error(), http.StatusNotAcceptable)

 	} else {

 		http.Error(w, err.Error(), http.StatusInternalServerError)

 	}

@@ -69,7 +71,16 @@ func getBoolParam(value string) (bool, error) {

 }

 func getAuth(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	b, err := json.Marshal(srv.registry.GetAuthConfig(false))

+	// FIXME: Handle multiple login at once

+	// FIXME: return specific error code if config file missing?

+	authConfig, err := auth.LoadConfig(srv.runtime.root)

+	if err != nil {

+		if err != auth.ErrConfigFileMissing {

+			return err

+		}

+		authConfig = &auth.AuthConfig{}

+	}

+	b, err := json.Marshal(&auth.AuthConfig{Username: authConfig.Username, Email: authConfig.Email})

 	if err != nil {

 		return err

 	}

@@ -78,11 +89,19 @@ func getAuth(srv *Server, version float64, w http.ResponseWriter, r *http.Reques

 }

 func postAuth(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	// FIXME: Handle multiple login at once

 	config := &auth.AuthConfig{}

 	if err := json.NewDecoder(r.Body).Decode(config); err != nil {

 		return err

 	}

-	authConfig := srv.registry.GetAuthConfig(true)

+

+	authConfig, err := auth.LoadConfig(srv.runtime.root)

+	if err != nil {

+		if err != auth.ErrConfigFileMissing {

+			return err

+		}

+		authConfig = &auth.AuthConfig{}

+	}

 	if config.Username == authConfig.Username {

 		config.Password = authConfig.Password

 	}

@@ -92,7 +111,6 @@ func postAuth(srv *Server, version float64, w http.ResponseWriter, r *http.Reque

 	if err != nil {

 		return err

 	}

-	srv.registry.ResetClient(newAuthConfig)

 	if status != "" {

 		b, err := json.Marshal(&ApiAuth{Status: status})

@@ -298,16 +316,25 @@ func postImagesCreate(srv *Server, version float64, w http.ResponseWriter, r *ht

 	tag := r.Form.Get("tag")

 	repo := r.Form.Get("repo")

+	if version > 1.0 {

+		w.Header().Set("Content-Type", "application/json")

+	}

+	sf := utils.NewStreamFormatter(version > 1.0)

 	if image != "" { //pull

 		registry := r.Form.Get("registry")

-		if version > 1.0 {

-			w.Header().Set("Content-Type", "application/json")

-		}

-		if err := srv.ImagePull(image, tag, registry, w, version > 1.0); err != nil {

+		if err := srv.ImagePull(image, tag, registry, w, sf); err != nil {

+			if sf.Used() {

+				w.Write(sf.FormatError(err))

+				return nil

+			}

 			return err

 		}

 	} else { //import

-		if err := srv.ImageImport(src, repo, tag, r.Body, w); err != nil {

+		if err := srv.ImageImport(src, repo, tag, r.Body, w, sf); err != nil {

+			if sf.Used() {

+				w.Write(sf.FormatError(err))

+				return nil

+			}

 			return err

 		}

 	}

@@ -343,10 +370,16 @@ func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *ht

 		return fmt.Errorf("Missing parameter")

 	}

 	name := vars["name"]

-

-	imgId, err := srv.ImageInsert(name, url, path, w)

+	if version > 1.0 {

+		w.Header().Set("Content-Type", "application/json")

+	}

+	sf := utils.NewStreamFormatter(version > 1.0)

+	imgId, err := srv.ImageInsert(name, url, path, w, sf)

 	if err != nil {

-		return err

+		if sf.Used() {

+			w.Write(sf.FormatError(err))

+			return nil

+		}

 	}

 	b, err := json.Marshal(&ApiId{Id: imgId})

 	if err != nil {

@@ -366,8 +399,15 @@ func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http

 		return fmt.Errorf("Missing parameter")

 	}

 	name := vars["name"]

-

-	if err := srv.ImagePush(name, registry, w); err != nil {

+	if version > 1.0 {

+		w.Header().Set("Content-Type", "application/json")

+	}

+	sf := utils.NewStreamFormatter(version > 1.0)

+	if err := srv.ImagePush(name, registry, w, sf); err != nil {

+		if sf.Used() {

+			w.Write(sf.FormatError(err))

+			return nil

+		}

 		return err

 	}

 	return nil

@@ -652,6 +692,13 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ

 	if err := r.ParseMultipartForm(4096); err != nil {

 		return err

 	}

+	remote := r.FormValue("t")

+	tag := ""

+	if strings.Contains(remote, ":") {

+		remoteParts := strings.Split(remote, ":")

+		tag = remoteParts[1]

+		remote = remoteParts[0]

+	}

 	dockerfile, _, err := r.FormFile("Dockerfile")

 	if err != nil {

@@ -666,8 +713,10 @@ func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Requ

 	}

 	b := NewBuildFile(srv, utils.NewWriteFlusher(w))

-	if _, err := b.Build(dockerfile, context); err != nil {

+	if id, err := b.Build(dockerfile, context); err != nil {

 		fmt.Fprintf(w, "Error build: %s\n", err)

+	} else if remote != "" {

+		srv.runtime.repositories.Set(remote, tag, id, false)

 	}

 	return nil

 }

@@ -26,8 +26,7 @@ func TestGetAuth(t *testing.T) {

 	defer nuke(runtime)

 	srv := &Server{

-		runtime:  runtime,

-		registry: registry.NewRegistry(runtime.root),

+		runtime: runtime,

 	}

 	r := httptest.NewRecorder()

@@ -56,7 +55,7 @@ func TestGetAuth(t *testing.T) {

 		t.Fatalf("%d OK or 0 expected, received %d\n", http.StatusOK, r.Code)

 	}

-	newAuthConfig := srv.registry.GetAuthConfig(false)

+	newAuthConfig := registry.NewRegistry(runtime.root).GetAuthConfig(false)

 	if newAuthConfig.Username != authConfig.Username ||

 		newAuthConfig.Email != authConfig.Email {

 		t.Fatalf("The auth configuration hasn't been set correctly")

@@ -247,8 +246,7 @@ func TestGetImagesSearch(t *testing.T) {

 	defer nuke(runtime)

 	srv := &Server{

-		runtime:  runtime,

-		registry: registry.NewRegistry(runtime.root),

+		runtime: runtime,

 	}

 	r := httptest.NewRecorder()

@@ -504,15 +502,16 @@ func TestPostAuth(t *testing.T) {

 	defer nuke(runtime)

 	srv := &Server{

-		runtime:  runtime,

-		registry: registry.NewRegistry(runtime.root),

+		runtime: runtime,

 	}

-	authConfigOrig := &auth.AuthConfig{

+	config := &auth.AuthConfig{

 		Username: "utest",

 		Email:    "utest@yopmail.com",

 	}

-	srv.registry.ResetClient(authConfigOrig)

+

+	authStr := auth.EncodeAuth(config)

+	auth.SaveConfig(runtime.root, authStr, config.Email)

 	r := httptest.NewRecorder()

 	if err := getAuth(srv, API_VERSION, r, nil, nil); err != nil {

@@ -524,7 +523,7 @@ func TestPostAuth(t *testing.T) {

 		t.Fatal(err)

 	}

-	if authConfig.Username != authConfigOrig.Username || authConfig.Email != authConfigOrig.Email {

+	if authConfig.Username != config.Username || authConfig.Email != config.Email {

 		t.Errorf("The retrieve auth mismatch with the one set.")

 	}

 }

@@ -54,6 +54,9 @@ func Tar(path string, compression Compression) (io.Reader, error) {

 func Untar(archive io.Reader, path string) error {

 	cmd := exec.Command("bsdtar", "-f", "-", "-C", path, "-x")

 	cmd.Stdin = archive

+	// Hardcode locale environment for predictable outcome regardless of host configuration.

+	//   (see https://github.com/dotcloud/docker/issues/355)

+	cmd.Env = []string{"LANG=en_US.utf-8", "LC_ALL=en_US.utf-8"}

 	output, err := cmd.CombinedOutput()

 	if err != nil {

 		return fmt.Errorf("%s: %s", err, output)

@@ -3,6 +3,7 @@ package auth

 import (

 	"encoding/base64"

 	"encoding/json"

+	"errors"

 	"fmt"

 	"io/ioutil"

 	"net/http"

@@ -17,6 +18,12 @@ const CONFIGFILE = ".dockercfg"

 // the registry server we want to login against

 const INDEX_SERVER = "https://index.docker.io/v1"

+//const INDEX_SERVER = "http://indexstaging-docker.dotcloud.com/"

+

+var (

+	ErrConfigFileMissing error = errors.New("The Auth config file is missing")

+)

+

 type AuthConfig struct {

 	Username string `json:"username"`

 	Password string `json:"password"`

@@ -75,7 +82,7 @@ func DecodeAuth(authStr string) (*AuthConfig, error) {

 func LoadConfig(rootPath string) (*AuthConfig, error) {

 	confFile := path.Join(rootPath, CONFIGFILE)

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

-		return &AuthConfig{}, fmt.Errorf("The Auth config file is missing")

+		return nil, ErrConfigFileMissing

 	}

 	b, err := ioutil.ReadFile(confFile)

 	if err != nil {

@@ -97,7 +104,7 @@ func LoadConfig(rootPath string) (*AuthConfig, error) {

 }

 // save the auth config

-func saveConfig(rootPath, authStr string, email string) error {

+func SaveConfig(rootPath, authStr string, email string) error {

 	confFile := path.Join(rootPath, CONFIGFILE)

 	if len(email) == 0 {

 		os.Remove(confFile)

@@ -161,7 +168,9 @@ func Login(authConfig *AuthConfig) (string, error) {

 				status = "Login Succeeded\n"

 				storeConfig = true

 			} else if resp.StatusCode == 401 {

-				saveConfig(authConfig.rootPath, "", "")

+				if err := SaveConfig(authConfig.rootPath, "", ""); err != nil {

+					return "", err

+				}

 				return "", fmt.Errorf("Wrong login/password, please try again")

 			} else {

 				return "", fmt.Errorf("Login: %s (Code: %d; Headers: %s)", body,

@@ -175,7 +184,9 @@ func Login(authConfig *AuthConfig) (string, error) {

 	}

 	if storeConfig {

 		authStr := EncodeAuth(authConfig)

-		saveConfig(authConfig.rootPath, authStr, authConfig.Email)

+		if err := SaveConfig(authConfig.rootPath, authStr, authConfig.Email); err != nil {

+			return "", err

+		}

 	}

 	return status, nil

 }

@@ -32,8 +32,6 @@ type buildFile struct {

 	tmpContainers map[string]struct{}

 	tmpImages     map[string]struct{}

-	needCommit bool

-

 	out io.Writer

 }

@@ -63,7 +61,7 @@ func (b *buildFile) CmdFrom(name string) error {

 				remote = name

 			}

-			if err := b.srv.ImagePull(remote, tag, "", b.out, false); err != nil {

+			if err := b.srv.ImagePull(remote, tag, "", b.out, utils.NewStreamFormatter(false)); err != nil {

 				return err

 			}

@@ -81,9 +79,8 @@ func (b *buildFile) CmdFrom(name string) error {

 }

 func (b *buildFile) CmdMaintainer(name string) error {

-	b.needCommit = true

 	b.maintainer = name

-	return nil

+	return b.commit("", b.config.Cmd, fmt.Sprintf("MAINTAINER %s", name))

 }

 func (b *buildFile) CmdRun(args string) error {

@@ -95,28 +92,34 @@ func (b *buildFile) CmdRun(args string) error {

 		return err

 	}

-	cmd, env := b.config.Cmd, b.config.Env

+	cmd := b.config.Cmd

 	b.config.Cmd = nil

 	MergeConfig(b.config, config)

-	if cache, err := b.srv.ImageGetCached(b.image, config); err != nil {

+	utils.Debugf("Command to be executed: %v", b.config.Cmd)

+

+	if cache, err := b.srv.ImageGetCached(b.image, b.config); err != nil {

 		return err

 	} else if cache != nil {

-		utils.Debugf("Use cached version")

+		utils.Debugf("[BUILDER] Use cached version")

 		b.image = cache.Id

 		return nil

+	} else {

+		utils.Debugf("[BUILDER] Cache miss")

 	}

 	cid, err := b.run()

 	if err != nil {

 		return err

 	}

-	b.config.Cmd, b.config.Env = cmd, env

-	return b.commit(cid)

+	if err := b.commit(cid, cmd, "run"); err != nil {

+		return err

+	}

+	b.config.Cmd = cmd

+	return nil

 }

 func (b *buildFile) CmdEnv(args string) error {

-	b.needCommit = true

 	tmp := strings.SplitN(args, " ", 2)

 	if len(tmp) != 2 {

 		return fmt.Errorf("Invalid ENV format")

@@ -131,60 +134,34 @@ func (b *buildFile) CmdEnv(args string) error {

 		}

 	}

 	b.config.Env = append(b.config.Env, key+"="+value)

-	return nil

+	return b.commit("", b.config.Cmd, fmt.Sprintf("ENV %s=%s", key, value))

 }

 func (b *buildFile) CmdCmd(args string) error {

-	b.needCommit = true

 	var cmd []string

 	if err := json.Unmarshal([]byte(args), &cmd); err != nil {

 		utils.Debugf("Error unmarshalling: %s, using /bin/sh -c", err)

-		b.config.Cmd = []string{"/bin/sh", "-c", args}

-	} else {

-		b.config.Cmd = cmd

+		cmd = []string{"/bin/sh", "-c", args}

+	}

+	if err := b.commit("", cmd, fmt.Sprintf("CMD %v", cmd)); err != nil {

+		return err

 	}

+	b.config.Cmd = cmd

 	return nil

 }

 func (b *buildFile) CmdExpose(args string) error {

 	ports := strings.Split(args, " ")

 	b.config.PortSpecs = append(ports, b.config.PortSpecs...)

-	return nil

+	return b.commit("", b.config.Cmd, fmt.Sprintf("EXPOSE %v", ports))

 }

 func (b *buildFile) CmdInsert(args string) error {

-	if b.image == "" {

-		return fmt.Errorf("Please provide a source image with `from` prior to insert")

-	}

-	tmp := strings.SplitN(args, " ", 2)

-	if len(tmp) != 2 {

-		return fmt.Errorf("Invalid INSERT format")

-	}

-	sourceUrl := strings.Trim(tmp[0], " ")

-	destPath := strings.Trim(tmp[1], " ")

-

-	file, err := utils.Download(sourceUrl, b.out)

-	if err != nil {

-		return err

-	}

-	defer file.Body.Close()

-

-	b.config.Cmd = []string{"echo", "INSERT", sourceUrl, "in", destPath}

-	cid, err := b.run()

-	if err != nil {

-		return err

-	}

-

-	container := b.runtime.Get(cid)

-	if container == nil {

-		return fmt.Errorf("An error occured while creating the container")

-	}

-

-	if err := container.Inject(file.Body, destPath); err != nil {

-		return err

-	}

+	return fmt.Errorf("INSERT has been deprecated. Please use ADD instead")

+}

-	return b.commit(cid)

+func (b *buildFile) CmdCopy(args string) error {

+	return fmt.Errorf("COPY has been deprecated. Please use ADD instead")

 }

 func (b *buildFile) CmdAdd(args string) error {

@@ -193,12 +170,13 @@ func (b *buildFile) CmdAdd(args string) error {

 	}

 	tmp := strings.SplitN(args, " ", 2)

 	if len(tmp) != 2 {

-		return fmt.Errorf("Invalid INSERT format")

+		return fmt.Errorf("Invalid ADD format")

 	}

 	orig := strings.Trim(tmp[0], " ")

 	dest := strings.Trim(tmp[1], " ")

-	b.config.Cmd = []string{"echo", "PUSH", orig, "in", dest}

+	cmd := b.config.Cmd

+	b.config.Cmd = []string{"/bin/sh", "-c", fmt.Sprintf("#(nop) ADD %s in %s", orig, dest)}

 	cid, err := b.run()

 	if err != nil {

 		return err

@@ -208,19 +186,23 @@ func (b *buildFile) CmdAdd(args string) error {

 	if container == nil {

 		return fmt.Errorf("Error while creating the container (CmdAdd)")

 	}

-

-	if err := os.MkdirAll(path.Join(container.rwPath(), dest), 0700); err != nil {

+	if err := container.EnsureMounted(); err != nil {

 		return err

 	}

+	defer container.Unmount()

 	origPath := path.Join(b.context, orig)

-	destPath := path.Join(container.rwPath(), dest)

+	destPath := path.Join(container.RootfsPath(), dest)

 	fi, err := os.Stat(origPath)

 	if err != nil {

 		return err

 	}

 	if fi.IsDir() {

+		if err := os.MkdirAll(destPath, 0700); err != nil {

+			return err

+		}

+

 		files, err := ioutil.ReadDir(path.Join(b.context, orig))

 		if err != nil {

 			return err

@@ -231,12 +213,18 @@ func (b *buildFile) CmdAdd(args string) error {

 			}

 		}

 	} else {

+		if err := os.MkdirAll(path.Dir(destPath), 0700); err != nil {

+			return err

+		}

 		if err := utils.CopyDirectory(origPath, destPath); err != nil {

 			return err

 		}

 	}

-

-	return b.commit(cid)

+	if err := b.commit(cid, cmd, fmt.Sprintf("ADD %s in %s", orig, dest)); err != nil {

+		return err

+	}

+	b.config.Cmd = cmd

+	return nil

 }

 func (b *buildFile) run() (string, error) {

@@ -265,20 +253,30 @@ func (b *buildFile) run() (string, error) {

 	return c.Id, nil

 }

-func (b *buildFile) commit(id string) error {

+// Commit the container <id> with the autorun command <autoCmd>

+func (b *buildFile) commit(id string, autoCmd []string, comment string) error {

 	if b.image == "" {

 		return fmt.Errorf("Please provide a source image with `from` prior to commit")

 	}

 	b.config.Image = b.image

 	if id == "" {

-		cmd := b.config.Cmd

-		b.config.Cmd = []string{"true"}

+		b.config.Cmd = []string{"/bin/sh", "-c", "#(nop) " + comment}

+

+		if cache, err := b.srv.ImageGetCached(b.image, b.config); err != nil {

+			return err

+		} else if cache != nil {

+			utils.Debugf("[BUILDER] Use cached version")

+			b.image = cache.Id

+			return nil

+		} else {

+			utils.Debugf("[BUILDER] Cache miss")

+		}

+

 		if cid, err := b.run(); err != nil {

 			return err

 		} else {

 			id = cid

 		}

-		b.config.Cmd = cmd

 	}

 	container := b.runtime.Get(id)

@@ -286,20 +284,20 @@ func (b *buildFile) commit(id string) error {

 		return fmt.Errorf("An error occured while creating the container")

 	}

+	// Note: Actually copy the struct

+	autoConfig := *b.config

+	autoConfig.Cmd = autoCmd

 	// Commit the container

-	image, err := b.builder.Commit(container, "", "", "", b.maintainer, nil)

+	image, err := b.builder.Commit(container, "", "", "", b.maintainer, &autoConfig)

 	if err != nil {

 		return err

 	}

 	b.tmpImages[image.Id] = struct{}{}

 	b.image = image.Id

-	b.needCommit = false

 	return nil

 }

 func (b *buildFile) Build(dockerfile, context io.Reader) (string, error) {

-	defer b.clearTmp(b.tmpContainers, b.tmpImages)

-

 	if context != nil {

 		name, err := ioutil.TempDir("/tmp", "docker-build")

 		if err != nil {

@@ -337,6 +335,7 @@ func (b *buildFile) Build(dockerfile, context io.Reader) (string, error) {

 		method, exists := reflect.TypeOf(b).MethodByName("Cmd" + strings.ToUpper(instruction[:1]) + strings.ToLower(instruction[1:]))

 		if !exists {

 			fmt.Fprintf(b.out, "Skipping unknown instruction %s\n", strings.ToUpper(instruction))

+			continue

 		}

 		ret := method.Func.Call([]reflect.Value{reflect.ValueOf(b), reflect.ValueOf(arguments)})[0].Interface()

 		if ret != nil {

@@ -345,22 +344,10 @@ func (b *buildFile) Build(dockerfile, context io.Reader) (string, error) {

 		fmt.Fprintf(b.out, "===> %v\n", b.image)

 	}

-	if b.needCommit {

-		if err := b.commit(""); err != nil {

-			return "", err

-		}

-	}

 	if b.image != "" {

-		// The build is successful, keep the temporary containers and images

-		for i := range b.tmpImages {

-			delete(b.tmpImages, i)

-		}

-		fmt.Fprintf(b.out, "Build success.\n Image id:\n%s\n", b.image)

+		fmt.Fprintf(b.out, "Build successful.\n===> %s\n", b.image)

 		return b.image, nil

 	}

-	for i := range b.tmpContainers {

-		delete(b.tmpContainers, i)

-	}

 	return "", fmt.Errorf("An error occured during the build\n")

 }

@@ -17,6 +17,7 @@ import (

 	"net/url"

 	"os"

 	"os/signal"

+	"path"

 	"path/filepath"

 	"reflect"

 	"strconv"

@@ -27,7 +28,7 @@ import (

 	"unicode"

 )

-const VERSION = "0.3.3"

+const VERSION = "0.3.4"

 var (

 	GIT_COMMIT string

@@ -73,37 +74,37 @@ func (cli *DockerCli) CmdHelp(args ...string) error {

 		}

 	}

 	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 cmd, description := range map[string]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",

+	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", cmd, description)

+		help += fmt.Sprintf("    %-10.10s%s\n", command[0], command[1])

 	}

 	fmt.Println(help)

 	return nil

@@ -130,16 +131,20 @@ func (cli *DockerCli) CmdInsert(args ...string) error {

 }

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

-	cmd := Subcmd("build", "[OPTIONS] [CONTEXT]", "Build an image from a Dockerfile")

-	fileName := cmd.String("f", "Dockerfile", "Use `file` as Dockerfile. Can be '-' for stdin")

+	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 (

-		file          io.ReadCloser

 		multipartBody io.Reader

-		err           error

+		file          io.ReadCloser

+		contextPath   string

 	)

 	// Init the needed component for the Multipart

@@ -148,27 +153,19 @@ func (cli *DockerCli) CmdBuild(args ...string) error {

 	w := multipart.NewWriter(buff)

 	boundary := strings.NewReader("\r\n--" + w.Boundary() + "--\r\n")

-	// Create a FormFile multipart for the Dockerfile

-	if *fileName == "-" {

+	compression := Bzip2

+

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

 		file = os.Stdin

 	} else {

-		file, err = os.Open(*fileName)

-		if err != nil {

+		// Send Dockerfile from arg/Dockerfile (deprecate later)

+		if f, err := os.Open(path.Join(cmd.Arg(0), "Dockerfile")); err != nil {

 			return err

+		} else {

+			file = f

 		}

-		defer file.Close()

-	}

-	if wField, err := w.CreateFormFile("Dockerfile", *fileName); err != nil {

-		return err

-	} else {

-		io.Copy(wField, file)

-	}

-	multipartBody = io.MultiReader(multipartBody, boundary)

-

-	compression := Bzip2

-

-	// Create a FormFile multipart for the context if needed

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

+		// 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 {

@@ -183,19 +180,28 @@ func (cli *DockerCli) CmdBuild(args ...string) error {

 			return err

 		} else {

 			// FIXME: Find a way to have a progressbar for the upload too

-			io.Copy(wField, utils.ProgressReader(ioutil.NopCloser(context), -1, os.Stdout, "Caching Context %v/%v (%v)\r", false))

+			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

+	if wField, err := w.CreateFormFile("Dockerfile", "Dockerfile"); err != nil {

+		return err

+	} else {

+		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", cli.host, cli.port, "/build"), multipartBody)

+	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 cmd.Arg(0) != "" {

+	if contextPath != "" {

 		req.Header.Set("X-Docker-Context-Compression", compression.Flag())

 		fmt.Println("Uploading Context...")

 	}

@@ -366,12 +372,10 @@ func (cli *DockerCli) CmdWait(args ...string) error {

 // 'docker version': show version information

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

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

-	fmt.Println(len(args))

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

 		return nil

 	}

-	fmt.Println(cmd.NArg())

 	if cmd.NArg() > 0 {

 		cmd.Usage()

 		return nil

@@ -882,9 +886,9 @@ func (cli *DockerCli) CmdPs(args ...string) error {

 	for _, out := range outs {

 		if !*quiet {

 			if *noTrunc {

-				fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s ago\t%s\n", out.Id, out.Image, out.Command, utils.HumanDuration(time.Now().Sub(time.Unix(out.Created, 0))), out.Status, out.Ports)

+				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\t%s ago\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)

+				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 {

@@ -996,12 +1000,10 @@ func (cli *DockerCli) CmdLogs(args ...string) error {

 		return nil

 	}

-	v := url.Values{}

-	v.Set("logs", "1")

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

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

-

-	if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), false); err != 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

@@ -1028,15 +1030,35 @@ func (cli *DockerCli) CmdAttach(args ...string) error {

 		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("stdout", "1")

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

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

-

-	cli.monitorTtySize(cmd.Arg(0))

-	if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), container.Config.Tty); err != nil {

-		return err

+	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

 	}