@@ -22,3 +22,4 @@ bundles/

 .git/

 vendor/pkg/

 pyenv

+Vagrantfile

@@ -6,4 +6,3 @@ Michael Crosby <michael@crosbymichael.com> (@crosbymichael)

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

 Dockerfile: Tianon Gravi <admwiggin@gmail.com> (@tianon)

 Makefile: Tianon Gravi <admwiggin@gmail.com> (@tianon)

-Vagrantfile: Cristian Staretu <cristian.staretu@gmail.com> (@unclejack)

deleted file mode 100644

@@ -1,206 +0,0 @@

-# -*- mode: ruby -*-

-# vi: set ft=ruby :

-

-BOX_NAME = ENV['BOX_NAME'] || "ubuntu"

-BOX_URI = ENV['BOX_URI'] || "http://files.vagrantup.com/precise64.box"

-VF_BOX_URI = ENV['BOX_URI'] || "http://files.vagrantup.com/precise64_vmware_fusion.box"

-AWS_BOX_URI = ENV['BOX_URI'] || "https://github.com/mitchellh/vagrant-aws/raw/master/dummy.box"

-AWS_REGION = ENV['AWS_REGION'] || "us-east-1"

-AWS_AMI = ENV['AWS_AMI'] || "ami-69f5a900"

-AWS_INSTANCE_TYPE = ENV['AWS_INSTANCE_TYPE'] || 't1.micro'

-SSH_PRIVKEY_PATH = ENV['SSH_PRIVKEY_PATH']

-PRIVATE_NETWORK = ENV['PRIVATE_NETWORK']

-

-# Boolean that forwards the Docker dynamic ports 49000-49900

-# See http://docs.docker.io/en/latest/use/port_redirection/ for more

-# $ FORWARD_DOCKER_PORTS=1 vagrant [up|reload]

-FORWARD_DOCKER_PORTS = ENV['FORWARD_DOCKER_PORTS']

-VAGRANT_RAM = ENV['VAGRANT_RAM'] || 512

-VAGRANT_CORES = ENV['VAGRANT_CORES'] || 1

-

-# You may also provide a comma-separated list of ports

-# for Vagrant to forward. For example:

-# $ FORWARD_PORTS=8080,27017 vagrant [up|reload]

-FORWARD_PORTS = ENV['FORWARD_PORTS']

-

-# A script to upgrade from the 12.04 kernel to the raring backport kernel (3.8)

-# and install docker.

-$script = <<SCRIPT

-# The username to add to the docker group will be passed as the first argument

-# to the script.  If nothing is passed, default to "vagrant".

-user="$1"

-if [ -z "$user" ]; then

-    user=vagrant

-fi

-

-# Enable memory cgroup and swap accounting

-sed -i 's/GRUB_CMDLINE_LINUX=""/GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1"/g' /etc/default/grub

-update-grub

-

-# Adding an apt gpg key is idempotent.

-apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9

-

-# Creating the docker.list file is idempotent, but it may overwrite desired

-# settings if it already exists.  This could be solved with md5sum but it

-# doesn't seem worth it.

-echo 'deb http://get.docker.io/ubuntu docker main' > \

-    /etc/apt/sources.list.d/docker.list

-

-# Update remote package metadata.  'apt-get update' is idempotent.

-apt-get update -q

-

-# Install docker.  'apt-get install' is idempotent.

-apt-get install -q -y lxc-docker

-

-usermod -a -G docker "$user"

-

-tmp=`mktemp -q` && {

-    # Only install the backport kernel, don't bother upgrading if the backport is

-    # already installed.  We want parse the output of apt so we need to save it

-    # with 'tee'.  NOTE: The installation of the kernel will trigger dkms to

-    # install vboxguest if needed.

-    apt-get install -q -y --no-upgrade linux-image-generic-lts-raring | \

-        tee "$tmp"

-

-    # Parse the number of installed packages from the output

-    NUM_INST=`awk '$2 == "upgraded," && $4 == "newly" { print $3 }' "$tmp"`

-    rm "$tmp"

-}

-

-# If the number of installed packages is greater than 0, we want to reboot (the

-# backport kernel was installed but is not running).

-if [ "$NUM_INST" -gt 0 ];

-then

-    echo "Rebooting down to activate new kernel."

-    echo "/vagrant will not be mounted.  Use 'vagrant halt' followed by"

-    echo "'vagrant up' to ensure /vagrant is mounted."

-    shutdown -r now

-fi

-SCRIPT

-

-# We need to install the virtualbox guest additions *before* we do the normal

-# docker installation.  As such this script is prepended to the common docker

-# install script above.  This allows the install of the backport kernel to

-# trigger dkms to build the virtualbox guest module install.

-$vbox_script = <<VBOX_SCRIPT + $script

-# Install the VirtualBox guest additions if they aren't already installed.

-if [ ! -d /opt/VBoxGuestAdditions-4.3.6/ ]; then

-    # Update remote package metadata.  'apt-get update' is idempotent.

-    apt-get update -q

-

-    # Kernel Headers and dkms are required to build the vbox guest kernel

-    # modules.

-    apt-get install -q -y linux-headers-generic-lts-raring dkms

-

-    echo 'Downloading VBox Guest Additions...'

-    wget -cq http://dlc.sun.com.edgesuite.net/virtualbox/4.3.6/VBoxGuestAdditions_4.3.6.iso

-    echo "95648fcdb5d028e64145a2fe2f2f28c946d219da366389295a61fed296ca79f0  VBoxGuestAdditions_4.3.6.iso" | sha256sum --check || exit 1

-

-    mount -o loop,ro /home/vagrant/VBoxGuestAdditions_4.3.6.iso /mnt

-    /mnt/VBoxLinuxAdditions.run --nox11

-    umount /mnt

-fi

-VBOX_SCRIPT

-

-Vagrant::Config.run do |config|

-  # Setup virtual machine box. This VM configuration code is always executed.

-  config.vm.box = BOX_NAME

-  config.vm.box_url = BOX_URI

-

-  # Use the specified private key path if it is specified and not empty.

-  if SSH_PRIVKEY_PATH

-      config.ssh.private_key_path = SSH_PRIVKEY_PATH

-  end

-

-  config.ssh.forward_agent = true

-end

-

-# Providers were added on Vagrant >= 1.1.0

-#

-# NOTE: The vagrant "vm.provision" appends its arguments to a list and executes

-# them in order.  If you invoke "vm.provision :shell, :inline => $script"

-# twice then vagrant will run the script two times.  Unfortunately when you use

-# providers and the override argument to set up provisioners (like the vbox

-# guest extensions) they 1) don't replace the other provisioners (they append

-# to the end of the list) and 2) you can't control the order the provisioners

-# are executed (you can only append to the list).  If you want the virtualbox

-# only script to run before the other script, you have to jump through a lot of

-# hoops.

-#

-# Here is my only repeatable solution: make one script that is common ($script)

-# and another script that is the virtual box guest *prepended* to the common

-# script.  Only ever use "vm.provision" *one time* per provider.  That means

-# every single provider has an override, and every single one configures

-# "vm.provision".  Much saddness, but such is life.

-Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|

-  config.vm.provider :aws do |aws, override|

-    username = "ubuntu"

-    override.vm.box_url = AWS_BOX_URI

-    override.vm.provision :shell, :inline => $script, :args => username

-    aws.access_key_id = ENV["AWS_ACCESS_KEY"]

-    aws.secret_access_key = ENV["AWS_SECRET_KEY"]

-    aws.keypair_name = ENV["AWS_KEYPAIR_NAME"]

-    override.ssh.username = username

-    aws.region = AWS_REGION

-    aws.ami    = AWS_AMI

-    aws.instance_type = AWS_INSTANCE_TYPE

-  end

-

-  config.vm.provider :rackspace do |rs, override|

-    override.vm.provision :shell, :inline => $script

-    rs.username = ENV["RS_USERNAME"]

-    rs.api_key  = ENV["RS_API_KEY"]

-    rs.public_key_path = ENV["RS_PUBLIC_KEY"]

-    rs.flavor   = /512MB/

-    rs.image    = /Ubuntu/

-  end

-

-  config.vm.provider :vmware_fusion do |f, override|

-    override.vm.box_url = VF_BOX_URI

-    override.vm.synced_folder ".", "/vagrant", disabled: true

-    override.vm.provision :shell, :inline => $script

-    f.vmx["displayName"] = "docker"

-  end

-

-  config.vm.provider :virtualbox do |vb, override|

-    override.vm.provision :shell, :inline => $vbox_script

-    vb.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]

-    vb.customize ["modifyvm", :id, "--natdnsproxy1", "on"]

-    vb.customize ["modifyvm", :id, "--memory", VAGRANT_RAM]

-    vb.customize ["modifyvm", :id, "--cpus", VAGRANT_CORES]

-  end

-end

-

-# If this is a version 1 config, virtualbox is the only option.  A version 2

-# config would have already been set in the above provider section.

-Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|

-  config.vm.provision :shell, :inline => $vbox_script

-end

-

-# Setup port forwarding per loaded environment variables

-forward_ports = FORWARD_DOCKER_PORTS.nil? ? [] : [*49153..49900]

-forward_ports += FORWARD_PORTS.split(',').map{|i| i.to_i } if FORWARD_PORTS

-if forward_ports.any?

-  Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|

-    forward_ports.each do |port|

-      config.vm.forward_port port, port

-    end

-  end

-

-  Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|

-    forward_ports.each do |port|

-      config.vm.network :forwarded_port, :host => port, :guest => port, auto_correct: true

-    end

-  end

-end

-

-if !PRIVATE_NETWORK.nil?

-  Vagrant::VERSION < "1.1.0" and Vagrant::Config.run do |config|

-    config.vm.network :hostonly, PRIVATE_NETWORK

-  end

-

-  Vagrant::VERSION >= "1.1.0" and Vagrant.configure("2") do |config|

-    config.vm.network "private_network", ip: PRIVATE_NETWORK

-  end

-end

-

deleted file mode 100644

@@ -1,1248 +0,0 @@

-package api

-

-import (

-	"bufio"

-	"bytes"

-	"code.google.com/p/go.net/websocket"

-	"encoding/base64"

-	"encoding/json"

-	"expvar"

-	"fmt"

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

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

-	"github.com/dotcloud/docker/pkg/listenbuffer"

-	"github.com/dotcloud/docker/pkg/systemd"

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

-	"github.com/gorilla/mux"

-	"io"

-	"io/ioutil"

-	"log"

-	"mime"

-	"net"

-	"net/http"

-	"net/http/pprof"

-	"os"

-	"regexp"

-	"strconv"

-	"strings"

-	"syscall"

-	"time"

-)

-

-// FIXME: move code common to client and server to common.go

-const (

-	APIVERSION        = 1.9

-	DEFAULTHTTPHOST   = "127.0.0.1"

-	DEFAULTUNIXSOCKET = "/var/run/docker.sock"

-)

-

-var (

-	activationLock chan struct{}

-)

-

-func ValidateHost(val string) (string, error) {

-	host, err := utils.ParseHost(DEFAULTHTTPHOST, DEFAULTUNIXSOCKET, val)

-	if err != nil {

-		return val, err

-	}

-	return host, nil

-}

-

-type HttpApiFunc func(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error

-

-func init() {

-	engine.Register("serveapi", ServeApi)

-}

-

-func hijackServer(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {

-	conn, _, err := w.(http.Hijacker).Hijack()

-	if err != nil {

-		return nil, nil, err

-	}

-	// Flush the options to make sure the client sets the raw mode

-	conn.Write([]byte{})

-	return conn, conn, nil

-}

-

-//If we don't do this, POST method without Content-type (even with empty body) will fail

-func parseForm(r *http.Request) error {

-	if r == nil {

-		return nil

-	}

-	if err := r.ParseForm(); err != nil && !strings.HasPrefix(err.Error(), "mime:") {

-		return err

-	}

-	return nil

-}

-

-func parseMultipartForm(r *http.Request) error {

-	if err := r.ParseMultipartForm(4096); err != nil && !strings.HasPrefix(err.Error(), "mime:") {

-		return err

-	}

-	return nil

-}

-

-func httpError(w http.ResponseWriter, err error) {

-	statusCode := http.StatusInternalServerError

-	// FIXME: this is brittle and should not be necessary.

-	// If we need to differentiate between different possible error types, we should

-	// create appropriate error types with clearly defined meaning.

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

-		statusCode = http.StatusNotFound

-	} else if strings.Contains(err.Error(), "Bad parameter") {

-		statusCode = http.StatusBadRequest

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

-		statusCode = http.StatusConflict

-	} else if strings.Contains(err.Error(), "Impossible") {

-		statusCode = http.StatusNotAcceptable

-	} else if strings.Contains(err.Error(), "Wrong login/password") {

-		statusCode = http.StatusUnauthorized

-	} else if strings.Contains(err.Error(), "hasn't been activated") {

-		statusCode = http.StatusForbidden

-	}

-

-	if err != nil {

-		utils.Errorf("HTTP Error: statusCode=%d %s", statusCode, err.Error())

-		http.Error(w, err.Error(), statusCode)

-	}

-}

-

-func writeJSON(w http.ResponseWriter, code int, v engine.Env) error {

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

-	w.WriteHeader(code)

-	return v.Encode(w)

-}

-

-func streamJSON(job *engine.Job, w http.ResponseWriter, flush bool) {

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

-	if flush {

-		job.Stdout.Add(utils.NewWriteFlusher(w))

-	} else {

-		job.Stdout.Add(w)

-	}

-}

-

-func getBoolParam(value string) (bool, error) {

-	if value == "" {

-		return false, nil

-	}

-	ret, err := strconv.ParseBool(value)

-	if err != nil {

-		return false, fmt.Errorf("Bad parameter")

-	}

-	return ret, nil

-}

-

-//TODO remove, used on < 1.5 in getContainersJSON

-func displayablePorts(ports *engine.Table) string {

-	result := []string{}

-	for _, port := range ports.Data {

-		if port.Get("IP") == "" {

-			result = append(result, fmt.Sprintf("%d/%s", port.GetInt("PublicPort"), port.Get("Type")))

-		} else {

-			result = append(result, fmt.Sprintf("%s:%d->%d/%s", port.Get("IP"), port.GetInt("PublicPort"), port.GetInt("PrivatePort"), port.Get("Type")))

-		}

-	}

-	return strings.Join(result, ", ")

-}

-

-func MatchesContentType(contentType, expectedType string) bool {

-	mimetype, _, err := mime.ParseMediaType(contentType)

-	if err != nil {

-		utils.Errorf("Error parsing media type: %s error: %s", contentType, err.Error())

-	}

-	return err == nil && mimetype == expectedType

-}

-

-func postAuth(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	var (

-		authConfig, err = ioutil.ReadAll(r.Body)

-		job             = eng.Job("auth")

-		status          string

-	)

-	if err != nil {

-		return err

-	}

-	job.Setenv("authConfig", string(authConfig))

-	job.Stdout.AddString(&status)

-	if err = job.Run(); err != nil {

-		return err

-	}

-	if status != "" {

-		var env engine.Env

-		env.Set("Status", status)

-		return writeJSON(w, http.StatusOK, env)

-	}

-	w.WriteHeader(http.StatusNoContent)

-	return nil

-}

-

-func getVersion(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

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

-	eng.ServeHTTP(w, r)

-	return nil

-}

-

-func postContainersKill(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	job := eng.Job("kill", vars["name"])

-	if sig := r.Form.Get("signal"); sig != "" {

-		job.Args = append(job.Args, sig)

-	}

-	if err := job.Run(); err != nil {

-		return err

-	}

-	w.WriteHeader(http.StatusNoContent)

-	return nil

-}

-

-func getContainersExport(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-	job := eng.Job("export", vars["name"])

-	job.Stdout.Add(w)

-	if err := job.Run(); err != nil {

-		return err

-	}

-	return nil

-}

-

-func getImagesJSON(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-

-	var (

-		err  error

-		outs *engine.Table

-		job  = eng.Job("images")

-	)

-

-	job.Setenv("filter", r.Form.Get("filter"))

-	job.Setenv("all", r.Form.Get("all"))

-

-	if version >= 1.7 {

-		streamJSON(job, w, false)

-	} else if outs, err = job.Stdout.AddListTable(); err != nil {

-		return err

-	}

-

-	if err := job.Run(); err != nil {

-		return err

-	}

-

-	if version < 1.7 && outs != nil { // Convert to legacy format

-		outsLegacy := engine.NewTable("Created", 0)

-		for _, out := range outs.Data {

-			for _, repoTag := range out.GetList("RepoTags") {

-				parts := strings.Split(repoTag, ":")

-				outLegacy := &engine.Env{}

-				outLegacy.Set("Repository", parts[0])

-				outLegacy.Set("Tag", parts[1])

-				outLegacy.Set("Id", out.Get("Id"))

-				outLegacy.SetInt64("Created", out.GetInt64("Created"))

-				outLegacy.SetInt64("Size", out.GetInt64("Size"))

-				outLegacy.SetInt64("VirtualSize", out.GetInt64("VirtualSize"))

-				outsLegacy.Add(outLegacy)

-			}

-		}

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

-		if _, err := outsLegacy.WriteListTo(w); err != nil {

-			return err

-		}

-	}

-	return nil

-}

-

-func getImagesViz(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if version > 1.6 {

-		w.WriteHeader(http.StatusNotFound)

-		return fmt.Errorf("This is now implemented in the client.")

-	}

-	eng.ServeHTTP(w, r)

-	return nil

-}

-

-func getInfo(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

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

-	eng.ServeHTTP(w, r)

-	return nil

-}

-

-func getEvents(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-

-	var job = eng.Job("events", r.RemoteAddr)

-	streamJSON(job, w, true)

-	job.Setenv("since", r.Form.Get("since"))

-	return job.Run()

-}

-

-func getImagesHistory(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

-	var job = eng.Job("history", vars["name"])

-	streamJSON(job, w, false)

-

-	if err := job.Run(); err != nil {

-		return err

-	}

-	return nil

-}

-

-func getContainersChanges(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-	var job = eng.Job("changes", vars["name"])

-	streamJSON(job, w, false)

-

-	return job.Run()

-}

-

-func getContainersTop(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if version < 1.4 {

-		return fmt.Errorf("top was improved a lot since 1.3, Please upgrade your docker client.")

-	}

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-	if err := parseForm(r); err != nil {

-		return err

-	}

-

-	job := eng.Job("top", vars["name"], r.Form.Get("ps_args"))

-	streamJSON(job, w, false)

-	return job.Run()

-}

-

-func getContainersJSON(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	var (

-		err  error

-		outs *engine.Table

-		job  = eng.Job("containers")

-	)

-

-	job.Setenv("all", r.Form.Get("all"))

-	job.Setenv("size", r.Form.Get("size"))

-	job.Setenv("since", r.Form.Get("since"))

-	job.Setenv("before", r.Form.Get("before"))

-	job.Setenv("limit", r.Form.Get("limit"))

-

-	if version >= 1.5 {

-		streamJSON(job, w, false)

-	} else if outs, err = job.Stdout.AddTable(); err != nil {

-		return err

-	}

-	if err = job.Run(); err != nil {

-		return err

-	}

-	if version < 1.5 { // Convert to legacy format

-		for _, out := range outs.Data {

-			ports := engine.NewTable("", 0)

-			ports.ReadListFrom([]byte(out.Get("Ports")))

-			out.Set("Ports", displayablePorts(ports))

-		}

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

-		if _, err = outs.WriteListTo(w); err != nil {

-			return err

-		}

-	}

-	return nil

-}

-

-func postImagesTag(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

-	job := eng.Job("tag", vars["name"], r.Form.Get("repo"), r.Form.Get("tag"))

-	job.Setenv("force", r.Form.Get("force"))

-	if err := job.Run(); err != nil {

-		return err

-	}

-	w.WriteHeader(http.StatusCreated)

-	return nil

-}

-

-func postCommit(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	var (

-		config engine.Env

-		env    engine.Env

-		job    = eng.Job("commit", r.Form.Get("container"))

-	)

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

-		utils.Errorf("%s", err)

-	}

-

-	job.Setenv("repo", r.Form.Get("repo"))

-	job.Setenv("tag", r.Form.Get("tag"))

-	job.Setenv("author", r.Form.Get("author"))

-	job.Setenv("comment", r.Form.Get("comment"))

-	job.SetenvSubEnv("config", &config)

-

-	var id string

-	job.Stdout.AddString(&id)

-	if err := job.Run(); err != nil {

-		return err

-	}

-	env.Set("Id", id)

-	return writeJSON(w, http.StatusCreated, env)

-}

-

-// Creates an image from Pull or from Import

-func postImagesCreate(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-

-	var (

-		image = r.Form.Get("fromImage")

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

-		job   *engine.Job

-	)

-	authEncoded := r.Header.Get("X-Registry-Auth")

-	authConfig := &auth.AuthConfig{}

-	if authEncoded != "" {

-		authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))

-		if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {

-			// for a pull it is not an error if no auth was given

-			// to increase compatibility with the existing api it is defaulting to be empty

-			authConfig = &auth.AuthConfig{}

-		}

-	}

-	if version > 1.0 {

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

-	}

-	if image != "" { //pull

-		metaHeaders := map[string][]string{}

-		for k, v := range r.Header {

-			if strings.HasPrefix(k, "X-Meta-") {

-				metaHeaders[k] = v

-			}

-		}

-		job = eng.Job("pull", r.Form.Get("fromImage"), tag)

-		job.SetenvBool("parallel", version > 1.3)

-		job.SetenvJson("metaHeaders", metaHeaders)

-		job.SetenvJson("authConfig", authConfig)

-	} else { //import

-		job = eng.Job("import", r.Form.Get("fromSrc"), r.Form.Get("repo"), tag)

-		job.Stdin.Add(r.Body)

-	}

-

-	if version > 1.0 {

-		job.SetenvBool("json", true)

-		streamJSON(job, w, true)

-	} else {

-		job.Stdout.Add(utils.NewWriteFlusher(w))

-	}

-	if err := job.Run(); err != nil {

-		if !job.Stdout.Used() {

-			return err

-		}

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

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

-	}

-

-	return nil

-}

-

-func getImagesSearch(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	var (

-		authEncoded = r.Header.Get("X-Registry-Auth")

-		authConfig  = &auth.AuthConfig{}

-		metaHeaders = map[string][]string{}

-	)

-

-	if authEncoded != "" {

-		authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))

-		if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {

-			// for a search it is not an error if no auth was given

-			// to increase compatibility with the existing api it is defaulting to be empty

-			authConfig = &auth.AuthConfig{}

-		}

-	}

-	for k, v := range r.Header {

-		if strings.HasPrefix(k, "X-Meta-") {

-			metaHeaders[k] = v

-		}

-	}

-

-	var job = eng.Job("search", r.Form.Get("term"))

-	job.SetenvJson("metaHeaders", metaHeaders)

-	job.SetenvJson("authConfig", authConfig)

-	streamJSON(job, w, false)

-

-	return job.Run()

-}

-

-func postImagesInsert(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-	if version > 1.0 {

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

-	}

-

-	job := eng.Job("insert", vars["name"], r.Form.Get("url"), r.Form.Get("path"))

-	if version > 1.0 {

-		job.SetenvBool("json", true)

-		streamJSON(job, w, false)

-	} else {

-		job.Stdout.Add(w)

-	}

-	if err := job.Run(); err != nil {

-		if !job.Stdout.Used() {

-			return err

-		}

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

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

-	}

-

-	return nil

-}

-

-func postImagesPush(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

-	metaHeaders := map[string][]string{}

-	for k, v := range r.Header {

-		if strings.HasPrefix(k, "X-Meta-") {

-			metaHeaders[k] = v

-		}

-	}

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	authConfig := &auth.AuthConfig{}

-

-	authEncoded := r.Header.Get("X-Registry-Auth")

-	if authEncoded != "" {

-		// the new format is to handle the authConfig as a header

-		authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))

-		if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {

-			// to increase compatibility to existing api it is defaulting to be empty

-			authConfig = &auth.AuthConfig{}

-		}

-	} else {

-		// the old format is supported for compatibility if there was no authConfig header

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

-			return err

-		}

-	}

-

-	if version > 1.0 {

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

-	}

-	job := eng.Job("push", vars["name"])

-	job.SetenvJson("metaHeaders", metaHeaders)

-	job.SetenvJson("authConfig", authConfig)

-	if version > 1.0 {

-		job.SetenvBool("json", true)

-		streamJSON(job, w, true)

-	} else {

-		job.Stdout.Add(utils.NewWriteFlusher(w))

-	}

-

-	if err := job.Run(); err != nil {

-		if !job.Stdout.Used() {

-			return err

-		}

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

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

-	}

-	return nil

-}

-

-func getImagesGet(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-	if version > 1.0 {

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

-	}

-	job := eng.Job("image_export", vars["name"])

-	job.Stdout.Add(w)

-	return job.Run()

-}

-

-func postImagesLoad(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	job := eng.Job("load")

-	job.Stdin.Add(r.Body)

-	return job.Run()

-}

-

-func postContainersCreate(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return nil

-	}

-	var (

-		out         engine.Env

-		job         = eng.Job("create", r.Form.Get("name"))

-		outWarnings []string

-		outId       string

-		warnings    = bytes.NewBuffer(nil)

-	)

-	if err := job.DecodeEnv(r.Body); err != nil {

-		return err

-	}

-	// Read container ID from the first line of stdout

-	job.Stdout.AddString(&outId)

-	// Read warnings from stderr

-	job.Stderr.Add(warnings)

-	if err := job.Run(); err != nil {

-		return err

-	}

-	// Parse warnings from stderr

-	scanner := bufio.NewScanner(warnings)

-	for scanner.Scan() {

-		outWarnings = append(outWarnings, scanner.Text())

-	}

-	out.Set("Id", outId)

-	out.SetList("Warnings", outWarnings)

-	return writeJSON(w, http.StatusCreated, out)

-}

-

-func postContainersRestart(eng *engine.Engine, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := parseForm(r); err != nil {

-		return err

-	}

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-	job := eng.Job("restart", vars["name"])

-	job.Setenv("t", r.Form.Get("t"))

-	if err := job.Run(); err != nil {

-		return err

-	}