new file mode 100644

@@ -0,0 +1,469 @@

+package local

+

+import (

+	"fmt"

+	"io"

+	"net/http"

+	"strconv"

+	"strings"

+	"syscall"

+	"time"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/distribution/registry/api/errcode"

+	"github.com/docker/docker/api/server/httputils"

+	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/daemon"

+	derr "github.com/docker/docker/errors"

+	"github.com/docker/docker/pkg/ioutils"

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

+	"github.com/docker/docker/pkg/timeutils"

+	"github.com/docker/docker/runconfig"

+	"github.com/docker/docker/utils"

+	"golang.org/x/net/context"

+	"golang.org/x/net/websocket"

+)

+

+func (s *router) getContainersJSON(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	config := &daemon.ContainersConfig{

+		All:     httputils.BoolValue(r, "all"),

+		Size:    httputils.BoolValue(r, "size"),

+		Since:   r.Form.Get("since"),

+		Before:  r.Form.Get("before"),

+		Filters: r.Form.Get("filters"),

+	}

+

+	if tmpLimit := r.Form.Get("limit"); tmpLimit != "" {

+		limit, err := strconv.Atoi(tmpLimit)

+		if err != nil {

+			return err

+		}

+		config.Limit = limit

+	}

+

+	containers, err := s.daemon.Containers(config)

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, containers)

+}

+

+func (s *router) getContainersStats(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	stream := httputils.BoolValueOrDefault(r, "stream", true)

+	var out io.Writer

+	if !stream {

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

+		out = w

+	} else {

+		wf := ioutils.NewWriteFlusher(w)

+		out = wf

+		defer wf.Close()

+	}

+

+	var closeNotifier <-chan bool

+	if notifier, ok := w.(http.CloseNotifier); ok {

+		closeNotifier = notifier.CloseNotify()

+	}

+

+	config := &daemon.ContainerStatsConfig{

+		Stream:    stream,

+		OutStream: out,

+		Stop:      closeNotifier,

+		Version:   httputils.VersionFromContext(ctx),

+	}

+

+	return s.daemon.ContainerStats(vars["name"], config)

+}

+

+func (s *router) getContainersLogs(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	// Args are validated before the stream starts because when it starts we're

+	// sending HTTP 200 by writing an empty chunk of data to tell the client that

+	// daemon is going to stream. By sending this initial HTTP 200 we can't report

+	// any error after the stream starts (i.e. container not found, wrong parameters)

+	// with the appropriate status code.

+	stdout, stderr := httputils.BoolValue(r, "stdout"), httputils.BoolValue(r, "stderr")

+	if !(stdout || stderr) {

+		return fmt.Errorf("Bad parameters: you must choose at least one stream")

+	}

+

+	var since time.Time

+	if r.Form.Get("since") != "" {

+		s, n, err := timeutils.ParseTimestamps(r.Form.Get("since"), 0)

+		if err != nil {

+			return err

+		}

+		since = time.Unix(s, n)

+	}

+

+	var closeNotifier <-chan bool

+	if notifier, ok := w.(http.CloseNotifier); ok {

+		closeNotifier = notifier.CloseNotify()

+	}

+

+	containerName := vars["name"]

+

+	if !s.daemon.Exists(containerName) {

+		return derr.ErrorCodeNoSuchContainer.WithArgs(containerName)

+	}

+

+	// write an empty chunk of data (this is to ensure that the

+	// HTTP Response is sent immediately, even if the container has

+	// not yet produced any data)

+	w.WriteHeader(http.StatusOK)

+	if flusher, ok := w.(http.Flusher); ok {

+		flusher.Flush()

+	}

+

+	output := ioutils.NewWriteFlusher(w)

+	defer output.Close()

+

+	logsConfig := &daemon.ContainerLogsConfig{

+		Follow:     httputils.BoolValue(r, "follow"),

+		Timestamps: httputils.BoolValue(r, "timestamps"),

+		Since:      since,

+		Tail:       r.Form.Get("tail"),

+		UseStdout:  stdout,

+		UseStderr:  stderr,

+		OutStream:  output,

+		Stop:       closeNotifier,

+	}

+

+	if err := s.daemon.ContainerLogs(containerName, logsConfig); err != nil {

+		// The client may be expecting all of the data we're sending to

+		// be multiplexed, so send it through OutStream, which will

+		// have been set up to handle that if needed.

+		fmt.Fprintf(logsConfig.OutStream, "Error running logs job: %s\n", utils.GetErrorMessage(err))

+	}

+

+	return nil

+}

+

+func (s *router) getContainersExport(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	return s.daemon.ContainerExport(vars["name"], w)

+}

+

+func (s *router) postContainersStart(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	// If contentLength is -1, we can assumed chunked encoding

+	// or more technically that the length is unknown

+	// https://golang.org/src/pkg/net/http/request.go#L139

+	// net/http otherwise seems to swallow any headers related to chunked encoding

+	// including r.TransferEncoding

+	// allow a nil body for backwards compatibility

+	var hostConfig *runconfig.HostConfig

+	if r.Body != nil && (r.ContentLength > 0 || r.ContentLength == -1) {

+		if err := httputils.CheckForJSON(r); err != nil {

+			return err

+		}

+

+		c, err := runconfig.DecodeHostConfig(r.Body)

+		if err != nil {

+			return err

+		}

+

+		hostConfig = c

+	}

+

+	if err := s.daemon.ContainerStart(vars["name"], hostConfig); err != nil {

+		return err

+	}

+	w.WriteHeader(http.StatusNoContent)

+	return nil

+}

+

+func (s *router) postContainersStop(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	seconds, _ := strconv.Atoi(r.Form.Get("t"))

+

+	if err := s.daemon.ContainerStop(vars["name"], seconds); err != nil {

+		return err

+	}

+	w.WriteHeader(http.StatusNoContent)

+

+	return nil

+}

+

+func (s *router) postContainersKill(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	var sig syscall.Signal

+	name := vars["name"]

+

+	// If we have a signal, look at it. Otherwise, do nothing

+	if sigStr := r.Form.Get("signal"); sigStr != "" {

+		var err error

+		if sig, err = signal.ParseSignal(sigStr); err != nil {

+			return err

+		}

+	}

+

+	if err := s.daemon.ContainerKill(name, uint64(sig)); err != nil {

+		theErr, isDerr := err.(errcode.ErrorCoder)

+		isStopped := isDerr && theErr.ErrorCode() == derr.ErrorCodeNotRunning

+

+		// Return error that's not caused because the container is stopped.

+		// Return error if the container is not running and the api is >= 1.20

+		// to keep backwards compatibility.

+		version := httputils.VersionFromContext(ctx)

+		if version.GreaterThanOrEqualTo("1.20") || !isStopped {

+			return fmt.Errorf("Cannot kill container %s: %v", name, err)

+		}

+	}

+

+	w.WriteHeader(http.StatusNoContent)

+	return nil

+}

+

+func (s *router) postContainersRestart(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	timeout, _ := strconv.Atoi(r.Form.Get("t"))

+

+	if err := s.daemon.ContainerRestart(vars["name"], timeout); err != nil {

+		return err

+	}

+

+	w.WriteHeader(http.StatusNoContent)

+

+	return nil

+}

+

+func (s *router) postContainersPause(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	if err := s.daemon.ContainerPause(vars["name"]); err != nil {

+		return err

+	}

+

+	w.WriteHeader(http.StatusNoContent)

+

+	return nil

+}

+

+func (s *router) postContainersUnpause(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	if err := s.daemon.ContainerUnpause(vars["name"]); err != nil {

+		return err

+	}

+

+	w.WriteHeader(http.StatusNoContent)

+

+	return nil

+}

+

+func (s *router) postContainersWait(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	status, err := s.daemon.ContainerWait(vars["name"], -1*time.Second)

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, &types.ContainerWaitResponse{

+		StatusCode: status,

+	})

+}

+

+func (s *router) getContainersChanges(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	changes, err := s.daemon.ContainerChanges(vars["name"])

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, changes)

+}

+

+func (s *router) getContainersTop(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	procList, err := s.daemon.ContainerTop(vars["name"], r.Form.Get("ps_args"))

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, procList)

+}

+

+func (s *router) postContainerRename(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	name := vars["name"]

+	newName := r.Form.Get("name")

+	if err := s.daemon.ContainerRename(name, newName); err != nil {

+		return err

+	}

+	w.WriteHeader(http.StatusNoContent)

+	return nil

+}

+

+func (s *router) postContainersCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	if err := httputils.CheckForJSON(r); err != nil {

+		return err

+	}

+

+	name := r.Form.Get("name")

+

+	config, hostConfig, err := runconfig.DecodeContainerConfig(r.Body)

+	if err != nil {

+		return err

+	}

+	version := httputils.VersionFromContext(ctx)

+	adjustCPUShares := version.LessThan("1.19")

+

+	ccr, err := s.daemon.ContainerCreate(&daemon.ContainerCreateConfig{

+		Name:            name,

+		Config:          config,

+		HostConfig:      hostConfig,

+		AdjustCPUShares: adjustCPUShares,

+	})

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusCreated, ccr)

+}

+

+func (s *router) deleteContainers(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	name := vars["name"]

+	config := &daemon.ContainerRmConfig{

+		ForceRemove:  httputils.BoolValue(r, "force"),

+		RemoveVolume: httputils.BoolValue(r, "v"),

+		RemoveLink:   httputils.BoolValue(r, "link"),

+	}

+

+	if err := s.daemon.ContainerRm(name, config); err != nil {

+		// Force a 404 for the empty string

+		if strings.Contains(strings.ToLower(err.Error()), "prefix can't be empty") {

+			return fmt.Errorf("no such id: \"\"")

+		}

+		return err

+	}

+

+	w.WriteHeader(http.StatusNoContent)

+

+	return nil

+}

+

+func (s *router) postContainersResize(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	height, err := strconv.Atoi(r.Form.Get("h"))

+	if err != nil {

+		return err

+	}

+	width, err := strconv.Atoi(r.Form.Get("w"))

+	if err != nil {

+		return err

+	}

+

+	return s.daemon.ContainerResize(vars["name"], height, width)

+}

+

+func (s *router) postContainersAttach(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	containerName := vars["name"]

+

+	if !s.daemon.Exists(containerName) {

+		return derr.ErrorCodeNoSuchContainer.WithArgs(containerName)

+	}

+

+	if s.daemon.IsPaused(containerName) {

+		return derr.ErrorCodePausedContainer.WithArgs(containerName)

+	}

+

+	inStream, outStream, err := httputils.HijackConnection(w)

+	if err != nil {

+		return err

+	}

+	defer httputils.CloseStreams(inStream, outStream)

+

+	if _, ok := r.Header["Upgrade"]; ok {

+		fmt.Fprintf(outStream, "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.raw-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n\r\n")

+	} else {

+		fmt.Fprintf(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")

+	}

+

+	attachWithLogsConfig := &daemon.ContainerAttachWithLogsConfig{

+		InStream:  inStream,

+		OutStream: outStream,

+		UseStdin:  httputils.BoolValue(r, "stdin"),

+		UseStdout: httputils.BoolValue(r, "stdout"),

+		UseStderr: httputils.BoolValue(r, "stderr"),

+		Logs:      httputils.BoolValue(r, "logs"),

+		Stream:    httputils.BoolValue(r, "stream"),

+	}

+

+	if err := s.daemon.ContainerAttachWithLogs(containerName, attachWithLogsConfig); err != nil {

+		fmt.Fprintf(outStream, "Error attaching: %s\n", err)

+	}

+

+	return nil

+}

+

+func (s *router) wsContainersAttach(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	containerName := vars["name"]

+

+	if !s.daemon.Exists(containerName) {

+		return derr.ErrorCodeNoSuchContainer.WithArgs(containerName)

+	}

+

+	h := websocket.Handler(func(ws *websocket.Conn) {

+		defer ws.Close()

+

+		wsAttachWithLogsConfig := &daemon.ContainerWsAttachWithLogsConfig{

+			InStream:  ws,

+			OutStream: ws,

+			ErrStream: ws,

+			Logs:      httputils.BoolValue(r, "logs"),

+			Stream:    httputils.BoolValue(r, "stream"),

+		}

+

+		if err := s.daemon.ContainerWsAttachWithLogs(containerName, wsAttachWithLogsConfig); err != nil {

+			logrus.Errorf("Error attaching websocket: %s", err)

+		}

+	})

+	ws := websocket.Server{Handler: h, Handshake: nil}

+	ws.ServeHTTP(w, r)

+

+	return nil

+}

new file mode 100644

@@ -0,0 +1,112 @@

+package local

+

+import (

+	"encoding/base64"

+	"encoding/json"

+	"fmt"

+	"io"

+	"net/http"

+	"os"

+	"strings"

+

+	"github.com/docker/docker/api/server/httputils"

+	"github.com/docker/docker/api/types"

+	"golang.org/x/net/context"

+)

+

+// postContainersCopy is deprecated in favor of getContainersArchive.

+func (s *router) postContainersCopy(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.CheckForJSON(r); err != nil {

+		return err

+	}

+

+	cfg := types.CopyConfig{}

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

+		return err

+	}

+

+	if cfg.Resource == "" {

+		return fmt.Errorf("Path cannot be empty")

+	}

+

+	data, err := s.daemon.ContainerCopy(vars["name"], cfg.Resource)

+	if err != nil {

+		if strings.Contains(strings.ToLower(err.Error()), "no such id") {

+			w.WriteHeader(http.StatusNotFound)

+			return nil

+		}

+		if os.IsNotExist(err) {

+			return fmt.Errorf("Could not find the file %s in container %s", cfg.Resource, vars["name"])

+		}

+		return err

+	}

+	defer data.Close()

+

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

+	if _, err := io.Copy(w, data); err != nil {

+		return err

+	}

+

+	return nil

+}

+

+// // Encode the stat to JSON, base64 encode, and place in a header.

+func setContainerPathStatHeader(stat *types.ContainerPathStat, header http.Header) error {

+	statJSON, err := json.Marshal(stat)

+	if err != nil {

+		return err

+	}

+

+	header.Set(

+		"X-Docker-Container-Path-Stat",

+		base64.StdEncoding.EncodeToString(statJSON),

+	)

+

+	return nil

+}

+

+func (s *router) headContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	v, err := httputils.ArchiveFormValues(r, vars)

+	if err != nil {

+		return err

+	}

+

+	stat, err := s.daemon.ContainerStatPath(v.Name, v.Path)

+	if err != nil {

+		return err

+	}

+

+	return setContainerPathStatHeader(stat, w.Header())

+}

+

+func (s *router) getContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	v, err := httputils.ArchiveFormValues(r, vars)

+	if err != nil {

+		return err

+	}

+

+	tarArchive, stat, err := s.daemon.ContainerArchivePath(v.Name, v.Path)

+	if err != nil {

+		return err

+	}

+	defer tarArchive.Close()

+

+	if err := setContainerPathStatHeader(stat, w.Header()); err != nil {

+		return err

+	}

+

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

+	_, err = io.Copy(w, tarArchive)

+

+	return err

+}

+

+func (s *router) putContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	v, err := httputils.ArchiveFormValues(r, vars)

+	if err != nil {

+		return err

+	}

+

+	noOverwriteDirNonDir := httputils.BoolValue(r, "noOverwriteDirNonDir")

+	return s.daemon.ContainerExtractToDir(v.Name, v.Path, noOverwriteDirNonDir, r.Body)

+}

new file mode 100644

@@ -0,0 +1,135 @@

+package local

+

+import (

+	"encoding/json"

+	"fmt"

+	"io"

+	"net/http"

+	"strconv"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/api/server/httputils"

+	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/pkg/stdcopy"

+	"github.com/docker/docker/runconfig"

+	"golang.org/x/net/context"

+)

+

+func (s *router) getExecByID(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	eConfig, err := s.daemon.ContainerExecInspect(vars["id"])

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, eConfig)

+}

+

+func (s *router) postContainerExecCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	if err := httputils.CheckForJSON(r); err != nil {

+		return err

+	}

+	name := vars["name"]

+

+	execConfig := &runconfig.ExecConfig{}

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

+		return err

+	}

+	execConfig.Container = name

+

+	if len(execConfig.Cmd) == 0 {

+		return fmt.Errorf("No exec command specified")

+	}

+

+	// Register an instance of Exec in container.

+	id, err := s.daemon.ContainerExecCreate(execConfig)

+	if err != nil {

+		logrus.Errorf("Error setting up exec command in container %s: %s", name, err)

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusCreated, &types.ContainerExecCreateResponse{

+		ID: id,

+	})

+}

+

+// TODO(vishh): Refactor the code to avoid having to specify stream config as part of both create and start.

+func (s *router) postContainerExecStart(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	version := httputils.VersionFromContext(ctx)

+	if version.GreaterThan("1.21") {

+		if err := httputils.CheckForJSON(r); err != nil {

+			return err

+		}

+	}

+

+	var (

+		execName                  = vars["name"]

+		stdin, inStream           io.ReadCloser

+		stdout, stderr, outStream io.Writer

+	)

+

+	execStartCheck := &types.ExecStartCheck{}

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

+		return err

+	}

+

+	if exists, err := s.daemon.ExecExists(execName); !exists {

+		return err

+	}

+

+	if !execStartCheck.Detach {

+		var err error

+		// Setting up the streaming http interface.

+		inStream, outStream, err = httputils.HijackConnection(w)

+		if err != nil {

+			return err

+		}

+		defer httputils.CloseStreams(inStream, outStream)

+

+		if _, ok := r.Header["Upgrade"]; ok {

+			fmt.Fprintf(outStream, "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.raw-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n\r\n")

+		} else {

+			fmt.Fprintf(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")

+		}

+

+		stdin = inStream

+		stdout = outStream

+		if !execStartCheck.Tty {

+			stderr = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)

+			stdout = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)

+		}

+	} else {

+		outStream = w

+	}

+

+	// Now run the user process in container.

+	if err := s.daemon.ContainerExecStart(execName, stdin, stdout, stderr); err != nil {

+		if execStartCheck.Detach {

+			return err

+		}

+		logrus.Errorf("Error running exec in container: %v\n", err)

+	}

+	return nil

+}

+

+func (s *router) postContainerExecResize(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	height, err := strconv.Atoi(r.Form.Get("h"))

+	if err != nil {

+		return err

+	}

+	width, err := strconv.Atoi(r.Form.Get("w"))

+	if err != nil {

+		return err

+	}

+

+	return s.daemon.ContainerExecResize(vars["name"], height, width)

+}

new file mode 100644

@@ -0,0 +1,33 @@

+package local

+

+import (

+	"net/http"

+

+	"github.com/docker/docker/api/server/httputils"

+	"golang.org/x/net/context"

+)

+

+// getContainersByName inspects containers configuration and serializes it as json.

+func (s *router) getContainersByName(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	displaySize := httputils.BoolValue(r, "size")

+

+	var json interface{}

+	var err error

+

+	version := httputils.VersionFromContext(ctx)

+

+	switch {

+	case version.LessThan("1.20"):

+		json, err = s.daemon.ContainerInspectPre120(vars["name"])

+	case version.Equal("1.20"):

+		json, err = s.daemon.ContainerInspect120(vars["name"])

+	default:

+		json, err = s.daemon.ContainerInspect(vars["name"], displaySize)

+	}

+

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, json)

+}

deleted file mode 100644

@@ -1,469 +0,0 @@

-package local

-

-import (

-	"fmt"

-	"io"

-	"net/http"

-	"strconv"

-	"strings"

-	"syscall"

-	"time"

-

-	"github.com/Sirupsen/logrus"

-	"github.com/docker/distribution/registry/api/errcode"

-	"github.com/docker/docker/api/server/httputils"

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

-	"github.com/docker/docker/daemon"

-	derr "github.com/docker/docker/errors"

-	"github.com/docker/docker/pkg/ioutils"

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

-	"github.com/docker/docker/pkg/timeutils"

-	"github.com/docker/docker/runconfig"

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

-	"golang.org/x/net/context"

-	"golang.org/x/net/websocket"

-)

-

-func (s *router) getContainersJSON(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := httputils.ParseForm(r); err != nil {

-		return err

-	}

-

-	config := &daemon.ContainersConfig{

-		All:     httputils.BoolValue(r, "all"),

-		Size:    httputils.BoolValue(r, "size"),

-		Since:   r.Form.Get("since"),

-		Before:  r.Form.Get("before"),

-		Filters: r.Form.Get("filters"),

-	}

-

-	if tmpLimit := r.Form.Get("limit"); tmpLimit != "" {

-		limit, err := strconv.Atoi(tmpLimit)

-		if err != nil {

-			return err

-		}

-		config.Limit = limit

-	}

-

-	containers, err := s.daemon.Containers(config)

-	if err != nil {

-		return err

-	}

-

-	return httputils.WriteJSON(w, http.StatusOK, containers)

-}

-

-func (s *router) getContainersStats(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := httputils.ParseForm(r); err != nil {

-		return err

-	}

-

-	stream := httputils.BoolValueOrDefault(r, "stream", true)

-	var out io.Writer

-	if !stream {

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

-		out = w

-	} else {

-		wf := ioutils.NewWriteFlusher(w)

-		out = wf

-		defer wf.Close()

-	}

-

-	var closeNotifier <-chan bool

-	if notifier, ok := w.(http.CloseNotifier); ok {

-		closeNotifier = notifier.CloseNotify()

-	}

-

-	config := &daemon.ContainerStatsConfig{

-		Stream:    stream,

-		OutStream: out,

-		Stop:      closeNotifier,

-		Version:   httputils.VersionFromContext(ctx),

-	}

-

-	return s.daemon.ContainerStats(vars["name"], config)

-}

-

-func (s *router) getContainersLogs(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := httputils.ParseForm(r); err != nil {

-		return err

-	}

-

-	// Args are validated before the stream starts because when it starts we're

-	// sending HTTP 200 by writing an empty chunk of data to tell the client that

-	// daemon is going to stream. By sending this initial HTTP 200 we can't report

-	// any error after the stream starts (i.e. container not found, wrong parameters)

-	// with the appropriate status code.

-	stdout, stderr := httputils.BoolValue(r, "stdout"), httputils.BoolValue(r, "stderr")

-	if !(stdout || stderr) {

-		return fmt.Errorf("Bad parameters: you must choose at least one stream")

-	}

-

-	var since time.Time

-	if r.Form.Get("since") != "" {

-		s, n, err := timeutils.ParseTimestamps(r.Form.Get("since"), 0)

-		if err != nil {

-			return err

-		}

-		since = time.Unix(s, n)

-	}

-

-	var closeNotifier <-chan bool

-	if notifier, ok := w.(http.CloseNotifier); ok {

-		closeNotifier = notifier.CloseNotify()

-	}

-

-	containerName := vars["name"]

-