f38f3109c2
We should not check if the mux framework internals work as expected in every handler. The missing parameter error doesn't make sense from the user point of view. This change initializes a proper vars context if the mux fails to do so and delegates specific parameter error checks to the handlers. Signed-off-by: David Calavera <david.calavera@gmail.com> Upstream-commit: 389ce0aae6a303660e591ef80272322ac82854e2 Component: engine
453 lines
13 KiB
Go
453 lines
13 KiB
Go
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/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 {
|
|
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: 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, 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()
|
|
}
|
|
|
|
containerName := vars["name"]
|
|
|
|
if !s.daemon.Exists(containerName) {
|
|
return derr.ErrorCodeNoSuchContainer.WithArgs(containerName)
|
|
}
|
|
|
|
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: httputils.BoolValue(r, "follow"),
|
|
Timestamps: httputils.BoolValue(r, "timestamps"),
|
|
Since: since,
|
|
Tail: r.Form.Get("tail"),
|
|
UseStdout: stdout,
|
|
UseStderr: stderr,
|
|
OutStream: outStream,
|
|
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(name, config, hostConfig, 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)
|
|
}
|
|
|
|
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
|
|
}
|