deleted file mode 100644

@@ -1,26 +0,0 @@

-package server

-

-import (

-	"encoding/json"

-	"net/http"

-

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

-	"github.com/docker/docker/cliconfig"

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

-)

-

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

-	var config *cliconfig.AuthConfig

-	err := json.NewDecoder(r.Body).Decode(&config)

-	r.Body.Close()

-	if err != nil {

-		return err

-	}

-	status, err := s.daemon.RegistryService.Auth(config)

-	if err != nil {

-		return err

-	}

-	return writeJSON(w, http.StatusOK, &types.AuthResponse{

-		Status: status,

-	})

-}

deleted file mode 100644

@@ -1,506 +0,0 @@

-package server

-

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

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

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

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

-)

-

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

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

-		return err

-	}

-

-	config := &daemon.ContainersConfig{

-		All:     boolValue(r, "all"),

-		Size:    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 writeJSON(w, http.StatusOK, containers)

-}

-

-func (s *Server) getContainersStats(ctx context.Context, 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")

-	}

-

-	stream := boolValueOrDefault(r, "stream", true)

-	var out io.Writer

-	if !stream {

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

-		out = w

-	} else {

-		out = ioutils.NewWriteFlusher(w)

-	}

-

-	var closeNotifier <-chan bool

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

-		closeNotifier = notifier.CloseNotify()

-	}

-

-	config := &daemon.ContainerStatsConfig{

-		Stream:    stream,

-		OutStream: out,

-		Stop:      closeNotifier,

-		Version:   versionFromContext(ctx),

-	}

-

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

-}

-

-func (s *Server) getContainersLogs(ctx context.Context, 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")

-	}

-

-	// 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 := boolValue(r, "stdout"), 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, err := strconv.ParseInt(r.Form.Get("since"), 10, 64)

-		if err != nil {

-			return err

-		}

-		since = time.Unix(s, 0)

-	}

-

-	var closeNotifier <-chan bool

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

-		closeNotifier = notifier.CloseNotify()

-	}

-

-	c, err := s.daemon.Get(vars["name"])

-	if err != nil {

-		return err

-	}

-

-	outStream := ioutils.NewWriteFlusher(w)

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

-	outStream.Write(nil)

-

-	logsConfig := &daemon.ContainerLogsConfig{

-		Follow:     boolValue(r, "follow"),

-		Timestamps: boolValue(r, "timestamps"),

-		Since:      since,

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

-		UseStdout:  stdout,

-		UseStderr:  stderr,

-		OutStream:  outStream,

-		Stop:       closeNotifier,

-	}

-

-	if err := s.daemon.ContainerLogs(c, 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 *Server) getContainersExport(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

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

-}

-

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

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

-	// 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 := 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 *Server) postContainersStop(ctx context.Context, 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")

-	}

-

-	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 *Server) postContainersKill(ctx context.Context, 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

-	}

-

-	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 := 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 *Server) postContainersRestart(ctx context.Context, 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")

-	}

-

-	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 *Server) postContainersPause(ctx context.Context, 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

-	}

-

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

-		return err

-	}

-

-	w.WriteHeader(http.StatusNoContent)

-

-	return nil

-}

-

-func (s *Server) postContainersUnpause(ctx context.Context, 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

-	}

-

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

-		return err

-	}

-

-	w.WriteHeader(http.StatusNoContent)

-

-	return nil

-}

-

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

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

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

-	if err != nil {

-		return err

-	}

-

-	return writeJSON(w, http.StatusOK, &types.ContainerWaitResponse{

-		StatusCode: status,

-	})

-}

-

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

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

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

-	if err != nil {

-		return err

-	}

-

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

-}

-

-func (s *Server) getContainersTop(ctx context.Context, 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

-	}

-

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

-	if err != nil {

-		return err

-	}

-

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

-}

-

-func (s *Server) postContainerRename(ctx context.Context, 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")

-	}

-

-	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 *Server) postContainersCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

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

-		return err

-	}

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

-		return err

-	}

-

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

-

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

-	if err != nil {

-		return err

-	}

-	version := versionFromContext(ctx)

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

-

-	ccr, err := s.daemon.ContainerCreate(name, config, hostConfig, adjustCPUShares)

-	if err != nil {

-		return err

-	}

-

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

-}

-

-func (s *Server) deleteContainers(ctx context.Context, 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")

-	}

-

-	name := vars["name"]

-	config := &daemon.ContainerRmConfig{

-		ForceRemove:  boolValue(r, "force"),

-		RemoveVolume: boolValue(r, "v"),

-		RemoveLink:   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 *Server) postContainersResize(ctx context.Context, 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")

-	}

-

-	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 *Server) postContainersAttach(ctx context.Context, 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")

-	}

-	containerName := vars["name"]

-

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

-		return derr.ErrorCodeNoSuchContainer.WithArgs(containerName)

-	}

-

-	inStream, outStream, err := hijackServer(w)

-	if err != nil {

-		return err

-	}

-	defer 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:  boolValue(r, "stdin"),

-		UseStdout: boolValue(r, "stdout"),

-		UseStderr: boolValue(r, "stderr"),

-		Logs:      boolValue(r, "logs"),

-		Stream:    boolValue(r, "stream"),

-	}

-

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

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

-	}

-

-	return nil

-}

-

-func (s *Server) wsContainersAttach(ctx context.Context, 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")

-	}

-	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:      boolValue(r, "logs"),

-			Stream:    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

-}

deleted file mode 100644

@@ -1,115 +0,0 @@

-package server

-

-import (

-	"encoding/base64"

-	"encoding/json"

-	"fmt"

-	"io"

-	"net/http"

-	"os"

-	"strings"

-

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

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

-)

-

-// postContainersCopy is deprecated in favor of getContainersArchive.

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

-	if vars == nil {

-		return fmt.Errorf("Missing parameter")

-	}

-

-	if err := 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 *Server) headContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	v, err := 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 *Server) getContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	v, err := 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 *Server) putContainersArchive(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	v, err := archiveFormValues(r, vars)

-	if err != nil {

-		return err

-	}

-

-	noOverwriteDirNonDir := boolValue(r, "noOverwriteDirNonDir")

-	return s.daemon.ContainerExtractToDir(v.name, v.path, noOverwriteDirNonDir, r.Body)

-}

deleted file mode 100644

@@ -1,180 +0,0 @@

-package server

-

-import (

-	"encoding/json"

-	"net/http"

-	"runtime"

-	"strconv"

-	"strings"

-	"time"

-

-	"github.com/Sirupsen/logrus"

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

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

-	"github.com/docker/docker/autogen/dockerversion"

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

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

-	"github.com/docker/docker/pkg/parsers/filters"

-	"github.com/docker/docker/pkg/parsers/kernel"

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

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

-)

-

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

-	v := &types.Version{

-		Version:    dockerversion.VERSION,

-		APIVersion: api.Version,

-		GitCommit:  dockerversion.GITCOMMIT,

-		GoVersion:  runtime.Version(),

-		Os:         runtime.GOOS,

-		Arch:       runtime.GOARCH,

-		BuildTime:  dockerversion.BUILDTIME,

-	}

-

-	version := versionFromContext(ctx)

-

-	if version.GreaterThanOrEqualTo("1.19") {

-		v.Experimental = utils.ExperimentalBuild()

-	}

-

-	if kernelVersion, err := kernel.GetKernelVersion(); err == nil {

-		v.KernelVersion = kernelVersion.String()

-	}

-

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

-}

-

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

-	info, err := s.daemon.SystemInfo()

-	if err != nil {

-		return err

-	}

-

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

-}

-

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

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

-		return err

-	}

-	var since int64 = -1

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

-		s, err := strconv.ParseInt(r.Form.Get("since"), 10, 64)

-		if err != nil {

-			return err

-		}

-		since = s

-	}

-

-	var until int64 = -1

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

-		u, err := strconv.ParseInt(r.Form.Get("until"), 10, 64)

-		if err != nil {

-			return err

-		}

-		until = u

-	}

-

-	timer := time.NewTimer(0)

-	timer.Stop()

-	if until > 0 {

-		dur := time.Unix(until, 0).Sub(time.Now())

-		timer = time.NewTimer(dur)

-	}

-

-	ef, err := filters.FromParam(r.Form.Get("filters"))

-	if err != nil {

-		return err

-	}

-

-	isFiltered := func(field string, filter []string) bool {

-		if len(field) == 0 {

-			return false

-		}

-		if len(filter) == 0 {

-			return false

-		}

-		for _, v := range filter {

-			if v == field {

-				return false

-			}

-			if strings.Contains(field, ":") {

-				image := strings.Split(field, ":")

-				if image[0] == v {

-					return false

-				}

-			}

-		}

-		return true

-	}

-

-	d := s.daemon

-	es := d.EventsService

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

-

-	outStream := ioutils.NewWriteFlusher(w)

-	// Write an empty chunk of data.

-	// This is to ensure that the HTTP status code is sent immediately,

-	// so that it will not block the receiver.

-	outStream.Write(nil)

-	enc := json.NewEncoder(outStream)

-

-	getContainerID := func(cn string) string {

-		c, err := d.Get(cn)

-		if err != nil {

-			return ""

-		}

-		return c.ID

-	}

-

-	sendEvent := func(ev *jsonmessage.JSONMessage) error {

-		//incoming container filter can be name,id or partial id, convert and replace as a full container id

-		for i, cn := range ef["container"] {

-			ef["container"][i] = getContainerID(cn)

-		}

-

-		if isFiltered(ev.Status, ef["event"]) || (isFiltered(ev.ID, ef["image"]) &&

-			isFiltered(ev.From, ef["image"])) || isFiltered(ev.ID, ef["container"]) {

-			return nil

-		}

-

-		return enc.Encode(ev)

-	}

-

-	current, l := es.Subscribe()

-	if since == -1 {

-		current = nil

-	}

-	defer es.Evict(l)

-	for _, ev := range current {

-		if ev.Time < since {

-			continue

-		}

-		if err := sendEvent(ev); err != nil {

-			return err

-		}

-	}

-

-	var closeNotify <-chan bool

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

-		closeNotify = closeNotifier.CloseNotify()

-	}

-

-	for {

-		select {

-		case ev := <-l:

-			jev, ok := ev.(*jsonmessage.JSONMessage)

-			if !ok {

-				continue

-			}

-			if err := sendEvent(jev); err != nil {

-				return err

-			}

-		case <-timer.C:

-			return nil

-		case <-closeNotify:

-			logrus.Debug("Client disconnected, stop sending events")

-			return nil

-		}

-	}

-}

deleted file mode 100644

@@ -1,127 +0,0 @@

-package server

-

-import (

-	"encoding/json"

-	"fmt"

-	"io"

-	"net/http"

-	"strconv"

-

-	"github.com/Sirupsen/logrus"

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

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

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

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

-)

-

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

-	if vars == nil {

-		return fmt.Errorf("Missing parameter 'id'")

-	}

-

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

-	if err != nil {

-		return err