2014-03-28 22:59:29 +00:00
|
|
|
package server
|
2013-04-11 02:48:21 +00:00
|
|
|
|
|
|
|
import (
|
2013-11-20 07:37:03 +00:00
|
|
|
"bufio"
|
|
|
|
"bytes"
|
2014-11-07 20:21:19 +00:00
|
|
|
|
2013-08-30 20:49:37 +00:00
|
|
|
"encoding/base64"
|
2013-04-18 01:13:43 +00:00
|
|
|
"encoding/json"
|
2013-12-03 18:04:18 +00:00
|
|
|
"expvar"
|
2013-04-19 13:24:37 +00:00
|
|
|
"fmt"
|
2013-05-08 01:06:49 +00:00
|
|
|
"io"
|
2013-06-06 23:09:46 +00:00
|
|
|
"io/ioutil"
|
2013-06-18 18:59:56 +00:00
|
|
|
"net"
|
2013-04-11 02:48:21 +00:00
|
|
|
"net/http"
|
2013-11-19 19:25:17 +00:00
|
|
|
"net/http/pprof"
|
2013-06-18 18:59:56 +00:00
|
|
|
"os"
|
2013-04-22 16:17:47 +00:00
|
|
|
"strconv"
|
2013-04-19 13:24:37 +00:00
|
|
|
"strings"
|
2013-12-07 05:19:30 +00:00
|
|
|
"syscall"
|
2014-03-28 22:59:29 +00:00
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
"crypto/tls"
|
|
|
|
"crypto/x509"
|
|
|
|
|
2014-05-02 21:43:51 +00:00
|
|
|
"code.google.com/p/go.net/websocket"
|
2014-07-24 20:37:44 +00:00
|
|
|
"github.com/docker/libcontainer/user"
|
|
|
|
"github.com/gorilla/mux"
|
2014-05-02 21:43:51 +00:00
|
|
|
|
2014-10-24 17:12:35 +00:00
|
|
|
log "github.com/Sirupsen/logrus"
|
2014-07-24 22:19:50 +00:00
|
|
|
"github.com/docker/docker/api"
|
2014-11-15 04:38:02 +00:00
|
|
|
"github.com/docker/docker/daemon/networkdriver/portallocator"
|
2014-07-24 22:19:50 +00:00
|
|
|
"github.com/docker/docker/engine"
|
|
|
|
"github.com/docker/docker/pkg/listenbuffer"
|
2014-07-29 00:23:38 +00:00
|
|
|
"github.com/docker/docker/pkg/parsers"
|
2014-09-17 15:04:56 +00:00
|
|
|
"github.com/docker/docker/pkg/stdcopy"
|
2014-07-24 22:19:50 +00:00
|
|
|
"github.com/docker/docker/pkg/systemd"
|
|
|
|
"github.com/docker/docker/pkg/version"
|
|
|
|
"github.com/docker/docker/registry"
|
|
|
|
"github.com/docker/docker/utils"
|
2013-04-11 02:48:21 +00:00
|
|
|
)
|
|
|
|
|
2014-02-16 04:24:55 +00:00
|
|
|
var (
|
|
|
|
activationLock chan struct{}
|
|
|
|
)
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
type HttpServer struct {
|
|
|
|
srv *http.Server
|
|
|
|
l net.Listener
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *HttpServer) Serve() error {
|
|
|
|
return s.srv.Serve(s.l)
|
|
|
|
}
|
|
|
|
func (s *HttpServer) Close() error {
|
|
|
|
return s.l.Close()
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
type HttpApiFunc func(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error
|
2013-07-13 14:59:07 +00:00
|
|
|
|
2013-05-08 01:06:49 +00:00
|
|
|
func hijackServer(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {
|
|
|
|
conn, _, err := w.(http.Hijacker).Hijack()
|
2013-05-06 09:31:22 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
// Flush the options to make sure the client sets the raw mode
|
2013-05-08 01:06:49 +00:00
|
|
|
conn.Write([]byte{})
|
|
|
|
return conn, conn, nil
|
2013-05-06 09:31:22 +00:00
|
|
|
}
|
|
|
|
|
2014-12-09 19:21:21 +00:00
|
|
|
func closeStreams(streams ...interface{}) {
|
|
|
|
for _, stream := range streams {
|
|
|
|
if tcpc, ok := stream.(interface {
|
|
|
|
CloseWrite() error
|
|
|
|
}); ok {
|
|
|
|
tcpc.CloseWrite()
|
|
|
|
} else if closer, ok := stream.(io.Closer); ok {
|
|
|
|
closer.Close()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-25 15:24:41 +00:00
|
|
|
// Check to make sure request's Content-Type is application/json
|
|
|
|
func checkForJson(r *http.Request) error {
|
|
|
|
ct := r.Header.Get("Content-Type")
|
|
|
|
|
|
|
|
// No Content-Type header is ok as long as there's no Body
|
|
|
|
if ct == "" {
|
|
|
|
if r.Body == nil || r.ContentLength == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise it better be json
|
|
|
|
if api.MatchesContentType(ct, "application/json") {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return fmt.Errorf("Content-Type specified (%s) must be 'application/json'", ct)
|
|
|
|
}
|
|
|
|
|
2013-05-08 16:52:01 +00:00
|
|
|
//If we don't do this, POST method without Content-type (even with empty body) will fail
|
|
|
|
func parseForm(r *http.Request) error {
|
2013-10-08 19:15:29 +00:00
|
|
|
if r == nil {
|
|
|
|
return nil
|
|
|
|
}
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := r.ParseForm(); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-05-23 03:07:26 +00:00
|
|
|
func parseMultipartForm(r *http.Request) error {
|
|
|
|
if err := r.ParseMultipartForm(4096); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-05-06 09:31:22 +00:00
|
|
|
func httpError(w http.ResponseWriter, err error) {
|
2013-07-11 12:21:43 +00:00
|
|
|
statusCode := http.StatusInternalServerError
|
2013-11-14 23:53:43 +00:00
|
|
|
// 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.
|
2014-10-23 17:34:06 +00:00
|
|
|
errStr := strings.ToLower(err.Error())
|
|
|
|
if strings.Contains(errStr, "no such") {
|
2013-07-11 12:21:43 +00:00
|
|
|
statusCode = http.StatusNotFound
|
2014-10-23 17:34:06 +00:00
|
|
|
} else if strings.Contains(errStr, "bad parameter") {
|
2013-07-11 12:21:43 +00:00
|
|
|
statusCode = http.StatusBadRequest
|
2014-10-23 17:34:06 +00:00
|
|
|
} else if strings.Contains(errStr, "conflict") {
|
2013-07-11 12:21:43 +00:00
|
|
|
statusCode = http.StatusConflict
|
2014-10-23 17:34:06 +00:00
|
|
|
} else if strings.Contains(errStr, "impossible") {
|
2013-07-11 12:21:43 +00:00
|
|
|
statusCode = http.StatusNotAcceptable
|
2014-10-23 17:34:06 +00:00
|
|
|
} else if strings.Contains(errStr, "wrong login/password") {
|
2013-07-11 12:21:43 +00:00
|
|
|
statusCode = http.StatusUnauthorized
|
2014-10-23 17:34:06 +00:00
|
|
|
} else if strings.Contains(errStr, "hasn't been activated") {
|
2013-07-11 12:21:43 +00:00
|
|
|
statusCode = http.StatusForbidden
|
2013-10-17 00:08:14 +00:00
|
|
|
}
|
|
|
|
|
2013-10-08 07:54:47 +00:00
|
|
|
if err != nil {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Errorf("HTTP Error: statusCode=%d %s", statusCode, err.Error())
|
2013-10-17 00:08:14 +00:00
|
|
|
http.Error(w, err.Error(), statusCode)
|
|
|
|
}
|
2013-05-06 09:31:22 +00:00
|
|
|
}
|
|
|
|
|
2014-01-25 07:15:40 +00:00
|
|
|
func writeJSON(w http.ResponseWriter, code int, v engine.Env) error {
|
2013-05-10 19:11:59 +00:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2013-09-11 07:23:53 +00:00
|
|
|
w.WriteHeader(code)
|
2014-01-25 07:15:40 +00:00
|
|
|
return v.Encode(w)
|
2013-05-10 19:11:59 +00:00
|
|
|
}
|
|
|
|
|
2014-02-13 19:21:27 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-16 13:45:29 +00:00
|
|
|
func getBoolParam(value string) (bool, error) {
|
2013-06-20 14:34:58 +00:00
|
|
|
if value == "" {
|
2013-05-16 13:45:29 +00:00
|
|
|
return false, nil
|
|
|
|
}
|
2013-06-21 22:55:33 +00:00
|
|
|
ret, err := strconv.ParseBool(value)
|
|
|
|
if err != nil {
|
2013-06-21 09:06:09 +00:00
|
|
|
return false, fmt.Errorf("Bad parameter")
|
2013-06-20 14:34:58 +00:00
|
|
|
}
|
2013-06-21 22:55:33 +00:00
|
|
|
return ret, nil
|
2013-05-16 13:45:29 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postAuth(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-01-25 00:39:41 +00:00
|
|
|
var (
|
|
|
|
authConfig, err = ioutil.ReadAll(r.Body)
|
2014-01-29 19:26:54 +00:00
|
|
|
job = eng.Job("auth")
|
2014-05-09 18:09:59 +00:00
|
|
|
stdoutBuffer = bytes.NewBuffer(nil)
|
2014-01-25 00:39:41 +00:00
|
|
|
)
|
2013-05-07 23:33:12 +00:00
|
|
|
if err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-25 00:39:41 +00:00
|
|
|
job.Setenv("authConfig", string(authConfig))
|
2014-05-09 18:09:59 +00:00
|
|
|
job.Stdout.Add(stdoutBuffer)
|
2014-01-25 00:39:41 +00:00
|
|
|
if err = job.Run(); err != nil {
|
2013-07-23 15:04:31 +00:00
|
|
|
return err
|
2013-06-03 12:09:16 +00:00
|
|
|
}
|
2014-05-09 18:09:59 +00:00
|
|
|
if status := engine.Tail(stdoutBuffer, 1); status != "" {
|
2014-01-25 00:39:41 +00:00
|
|
|
var env engine.Env
|
|
|
|
env.Set("Status", status)
|
|
|
|
return writeJSON(w, http.StatusOK, env)
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 19:42:29 +00:00
|
|
|
w.WriteHeader(http.StatusNoContent)
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-06 11:34:31 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getVersion(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-01-08 08:14:00 +00:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2014-01-29 19:26:54 +00:00
|
|
|
eng.ServeHTTP(w, r)
|
2013-12-08 07:41:53 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-06 11:34:31 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersKill(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2013-09-12 06:50:26 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("kill", vars["name"])
|
2013-11-17 00:26:04 +00:00
|
|
|
if sig := r.Form.Get("signal"); sig != "" {
|
|
|
|
job.Args = append(job.Args, sig)
|
|
|
|
}
|
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 19:42:29 +00:00
|
|
|
w.WriteHeader(http.StatusNoContent)
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-06 11:34:31 +00:00
|
|
|
|
2014-05-21 21:06:18 +00:00
|
|
|
func postContainersPause(eng *engine.Engine, version version.Version, 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("pause", vars["name"])
|
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func postContainersUnpause(eng *engine.Engine, version version.Version, 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("unpause", vars["name"])
|
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getContainersExport(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("export", vars["name"])
|
2014-01-22 23:54:22 +00:00
|
|
|
job.Stdout.Add(w)
|
2013-12-08 01:33:37 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2013-05-13 09:38:13 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-24 12:01:40 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getImagesJSON(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-13 22:55:31 +00:00
|
|
|
|
|
|
|
var (
|
2014-01-18 02:54:02 +00:00
|
|
|
err error
|
|
|
|
outs *engine.Table
|
2014-01-29 19:26:54 +00:00
|
|
|
job = eng.Job("images")
|
2014-01-13 22:55:31 +00:00
|
|
|
)
|
|
|
|
|
2014-02-26 22:04:11 +00:00
|
|
|
job.Setenv("filters", r.Form.Get("filters"))
|
2014-05-19 20:31:15 +00:00
|
|
|
// FIXME this parameter could just be a match filter
|
2013-12-12 22:39:35 +00:00
|
|
|
job.Setenv("filter", r.Form.Get("filter"))
|
|
|
|
job.Setenv("all", r.Form.Get("all"))
|
2014-01-13 22:55:31 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.GreaterThanOrEqualTo("1.7") {
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-21 23:06:23 +00:00
|
|
|
} else if outs, err = job.Stdout.AddListTable(); err != nil {
|
2014-01-18 02:54:02 +00:00
|
|
|
return err
|
2014-01-13 22:55:31 +00:00
|
|
|
}
|
|
|
|
|
2014-01-21 23:06:23 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-13 22:55:31 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.LessThan("1.7") && outs != nil { // Convert to legacy format
|
2014-01-21 23:06:23 +00:00
|
|
|
outsLegacy := engine.NewTable("Created", 0)
|
|
|
|
for _, out := range outs.Data {
|
|
|
|
for _, repoTag := range out.GetList("RepoTags") {
|
2014-08-01 01:19:30 +00:00
|
|
|
repo, tag := parsers.ParseRepositoryTag(repoTag)
|
2014-01-21 23:06:23 +00:00
|
|
|
outLegacy := &engine.Env{}
|
2014-07-03 09:58:13 +00:00
|
|
|
outLegacy.Set("Repository", repo)
|
|
|
|
outLegacy.SetJson("Tag", tag)
|
2014-02-06 02:09:55 +00:00
|
|
|
outLegacy.Set("Id", out.Get("Id"))
|
2014-01-21 23:06:23 +00:00
|
|
|
outLegacy.SetInt64("Created", out.GetInt64("Created"))
|
|
|
|
outLegacy.SetInt64("Size", out.GetInt64("Size"))
|
|
|
|
outLegacy.SetInt64("VirtualSize", out.GetInt64("VirtualSize"))
|
|
|
|
outsLegacy.Add(outLegacy)
|
2014-01-13 22:55:31 +00:00
|
|
|
}
|
2014-01-21 23:06:23 +00:00
|
|
|
}
|
2014-02-13 19:24:40 +00:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2014-01-21 23:06:23 +00:00
|
|
|
if _, err := outsLegacy.WriteListTo(w); err != nil {
|
2014-01-13 22:55:31 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
2013-12-12 22:39:35 +00:00
|
|
|
return nil
|
2013-05-09 21:52:12 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getImagesViz(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if version.GreaterThan("1.6") {
|
2013-10-08 13:52:36 +00:00
|
|
|
w.WriteHeader(http.StatusNotFound)
|
|
|
|
return fmt.Errorf("This is now implemented in the client.")
|
|
|
|
}
|
2014-01-29 19:26:54 +00:00
|
|
|
eng.ServeHTTP(w, r)
|
2013-10-08 13:52:36 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getInfo(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-01-08 08:14:00 +00:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2014-01-29 19:26:54 +00:00
|
|
|
eng.ServeHTTP(w, r)
|
2013-12-11 18:35:21 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-18 16:56:22 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getEvents(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-07-12 16:29:23 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-01-23 19:12:17 +00:00
|
|
|
|
2014-05-15 23:27:36 +00:00
|
|
|
var job = eng.Job("events")
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, true)
|
2014-01-23 19:12:17 +00:00
|
|
|
job.Setenv("since", r.Form.Get("since"))
|
2014-03-23 23:14:40 +00:00
|
|
|
job.Setenv("until", r.Form.Get("until"))
|
2014-11-20 19:46:48 +00:00
|
|
|
job.Setenv("filters", r.Form.Get("filters"))
|
2014-01-23 19:12:17 +00:00
|
|
|
return job.Run()
|
2013-07-10 12:55:05 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getImagesHistory(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-01-14 00:50:10 +00:00
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
var job = eng.Job("history", vars["name"])
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-14 00:50:10 +00:00
|
|
|
|
2014-01-21 23:06:23 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-14 00:50:10 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-19 13:24:37 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getContainersChanges(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-07-31 21:17:50 +00:00
|
|
|
var job = eng.Job("container_changes", vars["name"])
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-15 00:51:59 +00:00
|
|
|
|
2014-01-21 23:06:23 +00:00
|
|
|
return job.Run()
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-19 13:24:37 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getContainersTop(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if version.LessThan("1.4") {
|
2013-07-19 10:34:55 +00:00
|
|
|
return fmt.Errorf("top was improved a lot since 1.3, Please upgrade your docker client.")
|
|
|
|
}
|
2013-06-28 15:51:58 +00:00
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter")
|
|
|
|
}
|
2013-07-19 10:06:32 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-01-16 22:58:20 +00:00
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("top", vars["name"], r.Form.Get("ps_args"))
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-16 22:58:20 +00:00
|
|
|
return job.Run()
|
2013-06-28 15:51:58 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getContainersJSON(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-16 22:00:18 +00:00
|
|
|
var (
|
|
|
|
err error
|
|
|
|
outs *engine.Table
|
2014-01-29 19:26:54 +00:00
|
|
|
job = eng.Job("containers")
|
2014-01-16 22:00:18 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
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"))
|
2014-06-02 19:08:39 +00:00
|
|
|
job.Setenv("filters", r.Form.Get("filters"))
|
2014-01-16 22:00:18 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.GreaterThanOrEqualTo("1.5") {
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-16 22:00:18 +00:00
|
|
|
} else if outs, err = job.Stdout.AddTable(); err != nil {
|
2013-05-16 13:45:29 +00:00
|
|
|
return err
|
|
|
|
}
|
2014-01-16 22:00:18 +00:00
|
|
|
if err = job.Run(); err != nil {
|
2013-06-20 14:19:50 +00:00
|
|
|
return err
|
|
|
|
}
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.LessThan("1.5") { // Convert to legacy format
|
2014-01-16 22:00:18 +00:00
|
|
|
for _, out := range outs.Data {
|
|
|
|
ports := engine.NewTable("", 0)
|
|
|
|
ports.ReadListFrom([]byte(out.Get("Ports")))
|
2014-03-28 22:59:29 +00:00
|
|
|
out.Set("Ports", api.DisplayablePorts(ports))
|
2014-01-16 22:00:18 +00:00
|
|
|
}
|
2014-02-13 19:24:40 +00:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2014-01-16 22:00:18 +00:00
|
|
|
if _, err = outs.WriteListTo(w); err != nil {
|
|
|
|
return err
|
2013-09-04 21:41:44 +00:00
|
|
|
}
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-16 22:00:18 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-06 09:31:22 +00:00
|
|
|
|
2015-01-07 22:43:04 +00:00
|
|
|
func getContainersStats(eng *engine.Engine, version version.Version, 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"]
|
|
|
|
job := eng.Job("container_stats", name)
|
|
|
|
streamJSON(job, w, true)
|
|
|
|
return job.Run()
|
|
|
|
}
|
|
|
|
|
2014-04-02 19:26:06 +00:00
|
|
|
func getContainersLogs(eng *engine.Engine, version version.Version, 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")
|
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
2014-06-18 19:11:04 +00:00
|
|
|
inspectJob = eng.Job("container_inspect", vars["name"])
|
|
|
|
logsJob = eng.Job("logs", vars["name"])
|
|
|
|
c, err = inspectJob.Stdout.AddEnv()
|
2014-04-02 19:26:06 +00:00
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-06-18 19:11:04 +00:00
|
|
|
logsJob.Setenv("follow", r.Form.Get("follow"))
|
2014-06-03 11:09:33 +00:00
|
|
|
logsJob.Setenv("tail", r.Form.Get("tail"))
|
2014-06-18 19:11:04 +00:00
|
|
|
logsJob.Setenv("stdout", r.Form.Get("stdout"))
|
|
|
|
logsJob.Setenv("stderr", r.Form.Get("stderr"))
|
|
|
|
logsJob.Setenv("timestamps", r.Form.Get("timestamps"))
|
|
|
|
// Validate args here, because we can't return not StatusOK after job.Run() call
|
|
|
|
stdout, stderr := logsJob.GetenvBool("stdout"), logsJob.GetenvBool("stderr")
|
|
|
|
if !(stdout || stderr) {
|
|
|
|
return fmt.Errorf("Bad parameters: you must choose at least one stream")
|
|
|
|
}
|
|
|
|
if err = inspectJob.Run(); err != nil {
|
2014-04-02 19:26:06 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
var outStream, errStream io.Writer
|
|
|
|
outStream = utils.NewWriteFlusher(w)
|
|
|
|
|
|
|
|
if c.GetSubEnv("Config") != nil && !c.GetSubEnv("Config").GetBool("Tty") && version.GreaterThanOrEqualTo("1.6") {
|
2014-09-17 15:04:56 +00:00
|
|
|
errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
|
|
|
|
outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
|
2014-04-02 19:26:06 +00:00
|
|
|
} else {
|
|
|
|
errStream = outStream
|
|
|
|
}
|
|
|
|
|
2014-06-18 19:11:04 +00:00
|
|
|
logsJob.Stdout.Add(outStream)
|
|
|
|
logsJob.Stderr.Set(errStream)
|
|
|
|
if err := logsJob.Run(); err != nil {
|
2014-06-17 20:07:34 +00:00
|
|
|
fmt.Fprintf(outStream, "Error running logs job: %s\n", err)
|
2014-04-02 19:26:06 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postImagesTag(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2013-04-19 13:24:37 +00:00
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("tag", vars["name"], r.Form.Get("repo"), r.Form.Get("tag"))
|
2013-12-12 01:52:41 +00:00
|
|
|
job.Setenv("force", r.Form.Get("force"))
|
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusCreated)
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-24 14:06:03 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postCommit(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-25 07:15:40 +00:00
|
|
|
var (
|
2014-05-09 18:09:59 +00:00
|
|
|
config engine.Env
|
|
|
|
env engine.Env
|
|
|
|
job = eng.Job("commit", r.Form.Get("container"))
|
|
|
|
stdoutBuffer = bytes.NewBuffer(nil)
|
2014-01-25 07:15:40 +00:00
|
|
|
)
|
2014-09-25 15:24:41 +00:00
|
|
|
|
|
|
|
if err := checkForJson(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-02-10 23:52:15 +00:00
|
|
|
if err := config.Decode(r.Body); err != nil {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Errorf("%s", err)
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-12-12 01:03:48 +00:00
|
|
|
|
2014-06-08 06:37:31 +00:00
|
|
|
if r.FormValue("pause") == "" && version.GreaterThanOrEqualTo("1.13") {
|
|
|
|
job.Setenv("pause", "1")
|
|
|
|
} else {
|
|
|
|
job.Setenv("pause", r.FormValue("pause"))
|
|
|
|
}
|
|
|
|
|
2013-12-12 01:03:48 +00:00
|
|
|
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"))
|
2014-01-28 03:26:24 +00:00
|
|
|
job.SetenvSubEnv("config", &config)
|
2013-12-12 01:03:48 +00:00
|
|
|
|
2014-05-09 18:09:59 +00:00
|
|
|
job.Stdout.Add(stdoutBuffer)
|
2013-12-12 01:03:48 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-05-09 18:09:59 +00:00
|
|
|
env.Set("Id", engine.Tail(stdoutBuffer, 1))
|
2014-01-25 07:15:40 +00:00
|
|
|
return writeJSON(w, http.StatusCreated, env)
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-24 14:06:03 +00:00
|
|
|
|
2013-05-10 00:50:56 +00:00
|
|
|
// Creates an image from Pull or from Import
|
2014-02-21 23:15:28 +00:00
|
|
|
func postImagesCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-22 21:37:22 +00:00
|
|
|
|
2014-01-22 21:35:35 +00:00
|
|
|
var (
|
|
|
|
image = r.Form.Get("fromImage")
|
2014-07-07 23:09:42 +00:00
|
|
|
repo = r.Form.Get("repo")
|
2014-01-22 21:35:35 +00:00
|
|
|
tag = r.Form.Get("tag")
|
|
|
|
job *engine.Job
|
|
|
|
)
|
2013-08-30 20:49:37 +00:00
|
|
|
authEncoded := r.Header.Get("X-Registry-Auth")
|
2014-03-11 00:16:58 +00:00
|
|
|
authConfig := ®istry.AuthConfig{}
|
2013-08-30 20:49:37 +00:00
|
|
|
if authEncoded != "" {
|
|
|
|
authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
|
|
|
|
if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {
|
2013-09-03 18:45:49 +00:00
|
|
|
// for a pull it is not an error if no auth was given
|
2013-08-30 19:46:19 +00:00
|
|
|
// to increase compatibility with the existing api it is defaulting to be empty
|
2014-03-11 00:16:58 +00:00
|
|
|
authConfig = ®istry.AuthConfig{}
|
2013-09-03 18:45:49 +00:00
|
|
|
}
|
|
|
|
}
|
2013-05-07 23:33:12 +00:00
|
|
|
if image != "" { //pull
|
2014-07-07 23:09:42 +00:00
|
|
|
if tag == "" {
|
2014-07-29 00:23:38 +00:00
|
|
|
image, tag = parsers.ParseRepositoryTag(image)
|
2014-07-07 23:09:42 +00:00
|
|
|
}
|
2013-08-22 19:15:31 +00:00
|
|
|
metaHeaders := map[string][]string{}
|
|
|
|
for k, v := range r.Header {
|
|
|
|
if strings.HasPrefix(k, "X-Meta-") {
|
|
|
|
metaHeaders[k] = v
|
|
|
|
}
|
|
|
|
}
|
2014-07-07 23:09:42 +00:00
|
|
|
job = eng.Job("pull", image, tag)
|
2014-02-21 23:15:28 +00:00
|
|
|
job.SetenvBool("parallel", version.GreaterThan("1.3"))
|
2014-01-22 21:35:35 +00:00
|
|
|
job.SetenvJson("metaHeaders", metaHeaders)
|
|
|
|
job.SetenvJson("authConfig", authConfig)
|
2013-05-07 23:33:12 +00:00
|
|
|
} else { //import
|
2014-07-07 23:09:42 +00:00
|
|
|
if tag == "" {
|
2014-07-29 00:23:38 +00:00
|
|
|
repo, tag = parsers.ParseRepositoryTag(repo)
|
2014-07-07 23:09:42 +00:00
|
|
|
}
|
|
|
|
job = eng.Job("import", r.Form.Get("fromSrc"), repo, tag)
|
2014-01-22 21:35:35 +00:00
|
|
|
job.Stdin.Add(r.Body)
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.GreaterThan("1.0") {
|
2014-02-13 19:21:27 +00:00
|
|
|
job.SetenvBool("json", true)
|
|
|
|
streamJSON(job, w, true)
|
|
|
|
} else {
|
|
|
|
job.Stdout.Add(utils.NewWriteFlusher(w))
|
|
|
|
}
|
2014-01-22 21:35:35 +00:00
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
if !job.Stdout.Used() {
|
2013-05-16 19:09:06 +00:00
|
|
|
return err
|
2013-05-07 15:19:41 +00:00
|
|
|
}
|
2014-02-21 23:15:28 +00:00
|
|
|
sf := utils.NewStreamFormatter(version.GreaterThan("1.0"))
|
2014-01-22 21:35:35 +00:00
|
|
|
w.Write(sf.FormatError(err))
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-22 21:35:35 +00:00
|
|
|
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-07 15:19:41 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getImagesSearch(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-01-21 04:06:19 +00:00
|
|
|
var (
|
|
|
|
authEncoded = r.Header.Get("X-Registry-Auth")
|
2014-03-11 00:16:58 +00:00
|
|
|
authConfig = ®istry.AuthConfig{}
|
2014-01-21 04:06:19 +00:00
|
|
|
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
|
2014-03-11 00:16:58 +00:00
|
|
|
authConfig = ®istry.AuthConfig{}
|
2014-01-21 04:06:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
for k, v := range r.Header {
|
|
|
|
if strings.HasPrefix(k, "X-Meta-") {
|
|
|
|
metaHeaders[k] = v
|
|
|
|
}
|
|
|
|
}
|
2013-05-06 09:31:22 +00:00
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
var job = eng.Job("search", r.Form.Get("term"))
|
2014-01-21 04:06:19 +00:00
|
|
|
job.SetenvJson("metaHeaders", metaHeaders)
|
|
|
|
job.SetenvJson("authConfig", authConfig)
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-21 23:06:23 +00:00
|
|
|
|
|
|
|
return job.Run()
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-30 15:04:31 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postImagesPush(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-01-23 01:33:29 +00:00
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter")
|
|
|
|
}
|
|
|
|
|
2013-08-22 19:15:31 +00:00
|
|
|
metaHeaders := map[string][]string{}
|
|
|
|
for k, v := range r.Header {
|
|
|
|
if strings.HasPrefix(k, "X-Meta-") {
|
|
|
|
metaHeaders[k] = v
|
|
|
|
}
|
|
|
|
}
|
2013-05-15 19:21:37 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-03-11 00:16:58 +00:00
|
|
|
authConfig := ®istry.AuthConfig{}
|
2013-08-23 07:38:33 +00:00
|
|
|
|
2013-08-30 20:49:37 +00:00
|
|
|
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
|
2014-03-11 00:16:58 +00:00
|
|
|
authConfig = ®istry.AuthConfig{}
|
2013-08-23 07:38:33 +00:00
|
|
|
}
|
|
|
|
} else {
|
2013-08-30 19:46:19 +00:00
|
|
|
// the old format is supported for compatibility if there was no authConfig header
|
2013-08-23 07:38:33 +00:00
|
|
|
if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
2013-05-15 19:21:37 +00:00
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("push", vars["name"])
|
2014-01-23 01:33:29 +00:00
|
|
|
job.SetenvJson("metaHeaders", metaHeaders)
|
|
|
|
job.SetenvJson("authConfig", authConfig)
|
2014-04-01 01:50:10 +00:00
|
|
|
job.Setenv("tag", r.Form.Get("tag"))
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.GreaterThan("1.0") {
|
2014-02-13 19:21:27 +00:00
|
|
|
job.SetenvBool("json", true)
|
|
|
|
streamJSON(job, w, true)
|
|
|
|
} else {
|
|
|
|
job.Stdout.Add(utils.NewWriteFlusher(w))
|
|
|
|
}
|
2014-01-23 01:33:29 +00:00
|
|
|
|
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
if !job.Stdout.Used() {
|
|
|
|
return err
|
2013-05-25 15:09:46 +00:00
|
|
|
}
|
2014-02-21 23:15:28 +00:00
|
|
|
sf := utils.NewStreamFormatter(version.GreaterThan("1.0"))
|
2014-01-23 01:33:29 +00:00
|
|
|
w.Write(sf.FormatError(err))
|
2013-05-15 19:21:37 +00:00
|
|
|
}
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-07 17:23:50 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getImagesGet(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-01-07 20:39:15 +00:00
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter")
|
|
|
|
}
|
2014-05-01 04:26:24 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.GreaterThan("1.0") {
|
2013-11-14 01:05:37 +00:00
|
|
|
w.Header().Set("Content-Type", "application/x-tar")
|
|
|
|
}
|
2014-05-01 04:26:24 +00:00
|
|
|
var job *engine.Job
|
|
|
|
if name, ok := vars["name"]; ok {
|
|
|
|
job = eng.Job("image_export", name)
|
|
|
|
} else {
|
|
|
|
job = eng.Job("image_export", r.Form["names"]...)
|
|
|
|
}
|
2014-01-22 23:54:22 +00:00
|
|
|
job.Stdout.Add(w)
|
2014-01-07 20:39:15 +00:00
|
|
|
return job.Run()
|
2013-09-02 16:06:17 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postImagesLoad(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("load")
|
2014-01-21 00:09:17 +00:00
|
|
|
job.Stdin.Add(r.Body)
|
|
|
|
return job.Run()
|
2013-09-02 16:06:17 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-10-28 23:58:59 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
2014-01-25 07:15:40 +00:00
|
|
|
var (
|
2014-05-09 18:09:59 +00:00
|
|
|
out engine.Env
|
|
|
|
job = eng.Job("create", r.Form.Get("name"))
|
|
|
|
outWarnings []string
|
|
|
|
stdoutBuffer = bytes.NewBuffer(nil)
|
|
|
|
warnings = bytes.NewBuffer(nil)
|
2014-01-25 07:15:40 +00:00
|
|
|
)
|
2014-09-25 15:24:41 +00:00
|
|
|
|
|
|
|
if err := checkForJson(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2013-10-28 02:20:00 +00:00
|
|
|
if err := job.DecodeEnv(r.Body); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-10-28 02:20:00 +00:00
|
|
|
// Read container ID from the first line of stdout
|
2014-05-09 18:09:59 +00:00
|
|
|
job.Stdout.Add(stdoutBuffer)
|
2013-10-28 02:20:00 +00:00
|
|
|
// Read warnings from stderr
|
2013-11-20 07:37:03 +00:00
|
|
|
job.Stderr.Add(warnings)
|
2013-10-28 02:20:00 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-11-20 07:37:03 +00:00
|
|
|
// Parse warnings from stderr
|
|
|
|
scanner := bufio.NewScanner(warnings)
|
|
|
|
for scanner.Scan() {
|
2014-01-25 07:15:40 +00:00
|
|
|
outWarnings = append(outWarnings, scanner.Text())
|
2013-11-20 07:37:03 +00:00
|
|
|
}
|
2014-05-09 18:09:59 +00:00
|
|
|
out.Set("Id", engine.Tail(stdoutBuffer, 1))
|
2014-01-25 07:15:40 +00:00
|
|
|
out.SetList("Warnings", outWarnings)
|
2014-09-16 06:43:43 +00:00
|
|
|
|
2013-09-11 08:28:20 +00:00
|
|
|
return writeJSON(w, http.StatusCreated, out)
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-07 17:23:50 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersRestart(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("restart", vars["name"])
|
2014-01-07 01:34:51 +00:00
|
|
|
job.Setenv("t", r.Form.Get("t"))
|
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 19:42:29 +00:00
|
|
|
w.WriteHeader(http.StatusNoContent)
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-06 11:34:31 +00:00
|
|
|
|
2014-10-05 02:47:54 +00:00
|
|
|
func postContainerRename(eng *engine.Engine, version version.Version, 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")
|
|
|
|
}
|
|
|
|
|
|
|
|
newName := r.URL.Query().Get("name")
|
|
|
|
job := eng.Job("container_rename", vars["name"], newName)
|
|
|
|
job.Setenv("t", r.Form.Get("t"))
|
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func deleteContainers(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-08-21 10:40:47 +00:00
|
|
|
job := eng.Job("rm", vars["name"])
|
2014-07-06 20:43:24 +00:00
|
|
|
|
2014-08-07 18:50:59 +00:00
|
|
|
job.Setenv("forceRemove", r.Form.Get("force"))
|
2014-07-06 20:43:24 +00:00
|
|
|
|
2013-12-11 23:23:38 +00:00
|
|
|
job.Setenv("removeVolume", r.Form.Get("v"))
|
|
|
|
job.Setenv("removeLink", r.Form.Get("link"))
|
|
|
|
if err := job.Run(); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 19:42:29 +00:00
|
|
|
w.WriteHeader(http.StatusNoContent)
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-22 21:37:22 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func deleteImages(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-20 18:31:45 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-01-29 19:26:54 +00:00
|
|
|
var job = eng.Job("image_delete", vars["name"])
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-02-11 02:44:17 +00:00
|
|
|
job.Setenv("force", r.Form.Get("force"))
|
2014-03-14 01:02:28 +00:00
|
|
|
job.Setenv("noprune", r.Form.Get("noprune"))
|
2014-01-17 02:40:33 +00:00
|
|
|
|
2014-01-20 22:10:23 +00:00
|
|
|
return job.Run()
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-19 13:24:37 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersStart(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-10-27 02:24:01 +00:00
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter")
|
|
|
|
}
|
2014-06-24 18:31:56 +00:00
|
|
|
var (
|
|
|
|
name = vars["name"]
|
|
|
|
job = eng.Job("start", name)
|
|
|
|
)
|
|
|
|
|
2014-10-01 02:06:31 +00:00
|
|
|
// If contentLength is -1, we can assumed chunked encoding
|
|
|
|
// or more technically that the length is unknown
|
|
|
|
// http://golang.org/src/pkg/net/http/request.go#L139
|
|
|
|
// net/http otherwise seems to swallow any headers related to chunked encoding
|
|
|
|
// including r.TransferEncoding
|
2013-05-13 23:39:54 +00:00
|
|
|
// allow a nil body for backwards compatibility
|
2014-10-01 02:06:31 +00:00
|
|
|
if r.Body != nil && (r.ContentLength > 0 || r.ContentLength == -1) {
|
2014-09-25 15:24:41 +00:00
|
|
|
if err := checkForJson(r); err != nil {
|
|
|
|
return err
|
2014-08-01 22:26:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if err := job.DecodeEnv(r.Body); err != nil {
|
|
|
|
return err
|
2013-05-13 23:39:54 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-01 22:59:19 +00:00
|
|
|
|
2013-10-27 02:24:01 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2014-06-24 18:31:56 +00:00
|
|
|
if err.Error() == "Container already started" {
|
|
|
|
w.WriteHeader(http.StatusNotModified)
|
|
|
|
return nil
|
|
|
|
}
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 19:42:29 +00:00
|
|
|
w.WriteHeader(http.StatusNoContent)
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-19 13:24:37 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersStop(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("stop", vars["name"])
|
2013-12-11 23:36:50 +00:00
|
|
|
job.Setenv("t", r.Form.Get("t"))
|
2013-11-17 03:00:16 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2014-06-24 18:31:56 +00:00
|
|
|
if err.Error() == "Container already stopped" {
|
|
|
|
w.WriteHeader(http.StatusNotModified)
|
|
|
|
return nil
|
|
|
|
}
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 19:42:29 +00:00
|
|
|
w.WriteHeader(http.StatusNoContent)
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-04-19 13:24:37 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersWait(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-01-25 07:15:40 +00:00
|
|
|
var (
|
2014-05-09 18:09:59 +00:00
|
|
|
env engine.Env
|
|
|
|
stdoutBuffer = bytes.NewBuffer(nil)
|
|
|
|
job = eng.Job("wait", vars["name"])
|
2014-01-25 07:15:40 +00:00
|
|
|
)
|
2014-05-09 18:09:59 +00:00
|
|
|
job.Stdout.Add(stdoutBuffer)
|
2013-11-25 01:05:59 +00:00
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-05-09 18:09:59 +00:00
|
|
|
|
|
|
|
env.Set("StatusCode", engine.Tail(stdoutBuffer, 1))
|
2014-01-25 07:15:40 +00:00
|
|
|
return writeJSON(w, http.StatusOK, env)
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-06 09:31:22 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersResize(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-24 02:33:28 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter")
|
|
|
|
}
|
2014-01-29 19:26:54 +00:00
|
|
|
if err := eng.Job("resize", vars["name"], r.Form.Get("h"), r.Form.Get("w")).Run(); err != nil {
|
2013-05-24 02:33:28 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersAttach(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-08 16:52:01 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2013-05-07 23:33:12 +00:00
|
|
|
|
2014-01-16 01:43:57 +00:00
|
|
|
var (
|
2014-05-20 19:36:15 +00:00
|
|
|
job = eng.Job("container_inspect", vars["name"])
|
2014-01-28 03:26:24 +00:00
|
|
|
c, err = job.Stdout.AddEnv()
|
2014-01-16 01:43:57 +00:00
|
|
|
)
|
2014-01-28 03:26:24 +00:00
|
|
|
if err != nil {
|
2014-01-16 01:43:57 +00:00
|
|
|
return err
|
|
|
|
}
|
2014-01-28 03:26:24 +00:00
|
|
|
if err = job.Run(); err != nil {
|
2013-05-28 16:19:12 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2013-09-11 18:35:09 +00:00
|
|
|
inStream, outStream, err := hijackServer(w)
|
2013-05-07 23:33:12 +00:00
|
|
|
if err != nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return err
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2014-12-09 19:21:21 +00:00
|
|
|
defer closeStreams(inStream, outStream)
|
2013-04-11 02:48:21 +00:00
|
|
|
|
2013-09-11 18:35:09 +00:00
|
|
|
var errStream io.Writer
|
|
|
|
|
2014-12-15 18:57:39 +00:00
|
|
|
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")
|
|
|
|
}
|
2013-09-11 18:35:09 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
if c.GetSubEnv("Config") != nil && !c.GetSubEnv("Config").GetBool("Tty") && version.GreaterThanOrEqualTo("1.6") {
|
2014-09-17 15:04:56 +00:00
|
|
|
errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
|
|
|
|
outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
|
2013-09-11 18:35:09 +00:00
|
|
|
} else {
|
|
|
|
errStream = outStream
|
|
|
|
}
|
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
job = eng.Job("attach", vars["name"])
|
2014-01-08 22:05:05 +00:00
|
|
|
job.Setenv("logs", r.Form.Get("logs"))
|
|
|
|
job.Setenv("stream", r.Form.Get("stream"))
|
|
|
|
job.Setenv("stdin", r.Form.Get("stdin"))
|
|
|
|
job.Setenv("stdout", r.Form.Get("stdout"))
|
|
|
|
job.Setenv("stderr", r.Form.Get("stderr"))
|
|
|
|
job.Stdin.Add(inStream)
|
|
|
|
job.Stdout.Add(outStream)
|
2014-01-22 23:54:22 +00:00
|
|
|
job.Stderr.Set(errStream)
|
2014-01-08 22:05:05 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2014-06-17 20:07:34 +00:00
|
|
|
fmt.Fprintf(outStream, "Error attaching: %s\n", err)
|
2014-01-08 22:05:05 +00:00
|
|
|
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-10 18:20:49 +00:00
|
|
|
return nil
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-02 03:07:06 +00:00
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func wsContainersAttach(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-07-05 17:55:15 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter")
|
|
|
|
}
|
|
|
|
|
2014-05-20 19:36:15 +00:00
|
|
|
if err := eng.Job("container_inspect", vars["name"]).Run(); err != nil {
|
2013-07-05 17:55:15 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2013-07-13 14:59:07 +00:00
|
|
|
h := websocket.Handler(func(ws *websocket.Conn) {
|
|
|
|
defer ws.Close()
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("attach", vars["name"])
|
2014-01-08 22:05:05 +00:00
|
|
|
job.Setenv("logs", r.Form.Get("logs"))
|
|
|
|
job.Setenv("stream", r.Form.Get("stream"))
|
|
|
|
job.Setenv("stdin", r.Form.Get("stdin"))
|
|
|
|
job.Setenv("stdout", r.Form.Get("stdout"))
|
|
|
|
job.Setenv("stderr", r.Form.Get("stderr"))
|
|
|
|
job.Stdin.Add(ws)
|
|
|
|
job.Stdout.Add(ws)
|
2014-01-22 23:54:22 +00:00
|
|
|
job.Stderr.Set(ws)
|
2014-01-08 22:05:05 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Errorf("Error attaching websocket: %s", err)
|
2013-07-13 14:59:07 +00:00
|
|
|
}
|
|
|
|
})
|
|
|
|
h.ServeHTTP(w, r)
|
2013-07-05 17:55:15 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getContainersByName(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-05-20 19:36:15 +00:00
|
|
|
var job = eng.Job("container_inspect", vars["name"])
|
2014-05-31 01:13:37 +00:00
|
|
|
if version.LessThan("1.12") {
|
2014-06-17 00:06:21 +00:00
|
|
|
job.SetenvBool("raw", true)
|
2014-05-31 01:13:37 +00:00
|
|
|
}
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-20 23:15:00 +00:00
|
|
|
return job.Run()
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-05-02 03:07:06 +00:00
|
|
|
|
2014-11-17 23:50:09 +00:00
|
|
|
func getExecByID(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter 'id'")
|
|
|
|
}
|
|
|
|
var job = eng.Job("execInspect", vars["id"])
|
|
|
|
streamJSON(job, w, false)
|
|
|
|
return job.Run()
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func getImagesByName(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-05-09 23:28:47 +00:00
|
|
|
if vars == nil {
|
2013-05-10 18:20:49 +00:00
|
|
|
return fmt.Errorf("Missing parameter")
|
2013-05-09 23:28:47 +00:00
|
|
|
}
|
2014-05-20 19:36:15 +00:00
|
|
|
var job = eng.Job("image_inspect", vars["name"])
|
2014-05-31 01:13:37 +00:00
|
|
|
if version.LessThan("1.12") {
|
2014-06-17 00:06:21 +00:00
|
|
|
job.SetenvBool("raw", true)
|
2014-05-31 01:13:37 +00:00
|
|
|
}
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, false)
|
2014-01-20 23:15:00 +00:00
|
|
|
return job.Run()
|
2013-05-19 17:46:24 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postBuild(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if version.LessThan("1.3") {
|
2013-06-19 21:59:28 +00:00
|
|
|
return fmt.Errorf("Multipart upload for build is no longer supported. Please upgrade your docker client.")
|
2013-05-23 03:07:26 +00:00
|
|
|
}
|
2013-12-10 00:25:19 +00:00
|
|
|
var (
|
2014-05-07 22:59:13 +00:00
|
|
|
authEncoded = r.Header.Get("X-Registry-Auth")
|
|
|
|
authConfig = ®istry.AuthConfig{}
|
2014-01-03 20:13:32 +00:00
|
|
|
configFileEncoded = r.Header.Get("X-Registry-Config")
|
2014-03-11 00:16:58 +00:00
|
|
|
configFile = ®istry.ConfigFile{}
|
2014-01-29 19:26:54 +00:00
|
|
|
job = eng.Job("build")
|
2013-12-10 00:25:19 +00:00
|
|
|
)
|
2014-01-03 20:13:32 +00:00
|
|
|
|
|
|
|
// This block can be removed when API versions prior to 1.9 are deprecated.
|
|
|
|
// Both headers will be parsed and sent along to the daemon, but if a non-empty
|
|
|
|
// ConfigFile is present, any value provided as an AuthConfig directly will
|
|
|
|
// be overridden. See BuildFile::CmdFrom for details.
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.LessThan("1.9") && authEncoded != "" {
|
2013-12-06 22:27:10 +00:00
|
|
|
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
|
2014-03-11 00:16:58 +00:00
|
|
|
authConfig = ®istry.AuthConfig{}
|
2013-12-06 22:27:10 +00:00
|
|
|
}
|
|
|
|
}
|
2013-05-23 03:07:26 +00:00
|
|
|
|
2014-01-03 20:13:32 +00:00
|
|
|
if configFileEncoded != "" {
|
|
|
|
configFileJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(configFileEncoded))
|
|
|
|
if err := json.NewDecoder(configFileJson).Decode(configFile); 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
|
2014-03-11 00:16:58 +00:00
|
|
|
configFile = ®istry.ConfigFile{}
|
2014-01-03 20:13:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
if version.GreaterThanOrEqualTo("1.8") {
|
2014-01-23 20:19:52 +00:00
|
|
|
job.SetenvBool("json", true)
|
2014-02-13 19:21:27 +00:00
|
|
|
streamJSON(job, w, true)
|
|
|
|
} else {
|
|
|
|
job.Stdout.Add(utils.NewWriteFlusher(w))
|
2013-10-12 12:14:52 +00:00
|
|
|
}
|
2014-05-19 18:01:55 +00:00
|
|
|
|
2014-05-16 11:47:33 +00:00
|
|
|
if r.FormValue("forcerm") == "1" && version.GreaterThanOrEqualTo("1.12") {
|
|
|
|
job.Setenv("rm", "1")
|
2014-05-19 18:01:55 +00:00
|
|
|
} else if r.FormValue("rm") == "" && version.GreaterThanOrEqualTo("1.12") {
|
|
|
|
job.Setenv("rm", "1")
|
2014-05-16 11:47:33 +00:00
|
|
|
} else {
|
|
|
|
job.Setenv("rm", r.FormValue("rm"))
|
|
|
|
}
|
2014-11-21 17:51:32 +00:00
|
|
|
if r.FormValue("pull") == "1" && version.GreaterThanOrEqualTo("1.16") {
|
|
|
|
job.Setenv("pull", "1")
|
|
|
|
}
|
2014-01-23 20:19:52 +00:00
|
|
|
job.Stdin.Add(r.Body)
|
|
|
|
job.Setenv("remote", r.FormValue("remote"))
|
2014-09-11 14:42:17 +00:00
|
|
|
job.Setenv("dockerfile", r.FormValue("dockerfile"))
|
2014-01-23 20:19:52 +00:00
|
|
|
job.Setenv("t", r.FormValue("t"))
|
|
|
|
job.Setenv("q", r.FormValue("q"))
|
|
|
|
job.Setenv("nocache", r.FormValue("nocache"))
|
2014-05-16 11:47:33 +00:00
|
|
|
job.Setenv("forcerm", r.FormValue("forcerm"))
|
2014-05-07 22:59:13 +00:00
|
|
|
job.SetenvJson("authConfig", authConfig)
|
2014-05-07 22:58:09 +00:00
|
|
|
job.SetenvJson("configFile", configFile)
|
2014-01-23 20:19:52 +00:00
|
|
|
|
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
if !job.Stdout.Used() {
|
|
|
|
return err
|
2013-10-12 12:14:52 +00:00
|
|
|
}
|
2014-02-21 23:15:28 +00:00
|
|
|
sf := utils.NewStreamFormatter(version.GreaterThanOrEqualTo("1.8"))
|
2014-01-23 20:19:52 +00:00
|
|
|
w.Write(sf.FormatError(err))
|
2013-05-23 03:07:26 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func postContainersCopy(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-07-17 04:07:41 +00:00
|
|
|
if vars == nil {
|
|
|
|
return fmt.Errorf("Missing parameter")
|
|
|
|
}
|
|
|
|
|
2014-01-25 07:15:40 +00:00
|
|
|
var copyData engine.Env
|
|
|
|
|
2014-09-25 15:24:41 +00:00
|
|
|
if err := checkForJson(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := copyData.Decode(r.Body); err != nil {
|
|
|
|
return err
|
2013-07-17 04:07:41 +00:00
|
|
|
}
|
|
|
|
|
2014-01-25 07:15:40 +00:00
|
|
|
if copyData.Get("Resource") == "" {
|
2013-11-16 10:15:04 +00:00
|
|
|
return fmt.Errorf("Path cannot be empty")
|
2013-07-17 04:07:41 +00:00
|
|
|
}
|
2014-03-16 17:48:46 +00:00
|
|
|
|
|
|
|
origResource := copyData.Get("Resource")
|
|
|
|
|
2014-01-25 07:15:40 +00:00
|
|
|
if copyData.Get("Resource")[0] == '/' {
|
|
|
|
copyData.Set("Resource", copyData.Get("Resource")[1:])
|
2013-07-17 04:07:41 +00:00
|
|
|
}
|
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
job := eng.Job("container_copy", vars["name"], copyData.Get("Resource"))
|
2014-02-25 22:49:19 +00:00
|
|
|
job.Stdout.Add(w)
|
2014-09-13 23:03:35 +00:00
|
|
|
w.Header().Set("Content-Type", "application/x-tar")
|
2014-01-10 00:37:56 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Errorf("%s", err.Error())
|
2014-12-16 23:06:35 +00:00
|
|
|
if strings.Contains(strings.ToLower(err.Error()), "no such id") {
|
2014-02-15 00:43:55 +00:00
|
|
|
w.WriteHeader(http.StatusNotFound)
|
2014-03-16 17:48:46 +00:00
|
|
|
} else if strings.Contains(err.Error(), "no such file or directory") {
|
|
|
|
return fmt.Errorf("Could not find the file %s in container %s", origResource, vars["name"])
|
2014-02-15 00:43:55 +00:00
|
|
|
}
|
2013-07-17 04:07:41 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-09-15 22:56:47 +00:00
|
|
|
func postContainerExecCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-09-09 05:51:53 +00:00
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
var (
|
2014-09-15 22:56:47 +00:00
|
|
|
out engine.Env
|
|
|
|
name = vars["name"]
|
|
|
|
job = eng.Job("execCreate", name)
|
|
|
|
stdoutBuffer = bytes.NewBuffer(nil)
|
|
|
|
)
|
2014-09-25 15:24:41 +00:00
|
|
|
|
2014-09-15 22:56:47 +00:00
|
|
|
if err := job.DecodeEnv(r.Body); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
job.Stdout.Add(stdoutBuffer)
|
|
|
|
// Register an instance of Exec in container.
|
|
|
|
if err := job.Run(); err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "Error setting up exec command in container %s: %s\n", name, err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// Return the ID
|
|
|
|
out.Set("Id", engine.Tail(stdoutBuffer, 1))
|
|
|
|
|
|
|
|
return writeJSON(w, http.StatusCreated, out)
|
|
|
|
}
|
|
|
|
|
2014-09-17 18:36:51 +00:00
|
|
|
// TODO(vishh): Refactor the code to avoid having to specify stream config as part of both create and start.
|
2014-09-15 22:56:47 +00:00
|
|
|
func postContainerExecStart(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if err := parseForm(r); err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
var (
|
|
|
|
name = vars["name"]
|
|
|
|
job = eng.Job("execStart", name)
|
|
|
|
errOut io.Writer = os.Stderr
|
2014-09-09 05:51:53 +00:00
|
|
|
)
|
2014-09-25 15:24:41 +00:00
|
|
|
|
2014-09-09 05:51:53 +00:00
|
|
|
if err := job.DecodeEnv(r.Body); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if !job.GetenvBool("Detach") {
|
|
|
|
// Setting up the streaming http interface.
|
|
|
|
inStream, outStream, err := hijackServer(w)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-12-09 19:21:21 +00:00
|
|
|
defer closeStreams(inStream, outStream)
|
2014-09-09 05:51:53 +00:00
|
|
|
|
|
|
|
var errStream io.Writer
|
|
|
|
|
2014-12-15 18:57:39 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2014-09-09 05:51:53 +00:00
|
|
|
if !job.GetenvBool("Tty") && version.GreaterThanOrEqualTo("1.6") {
|
2014-09-17 15:04:56 +00:00
|
|
|
errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
|
|
|
|
outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
|
2014-09-09 05:51:53 +00:00
|
|
|
} else {
|
|
|
|
errStream = outStream
|
|
|
|
}
|
|
|
|
job.Stdin.Add(inStream)
|
|
|
|
job.Stdout.Add(outStream)
|
|
|
|
job.Stderr.Set(errStream)
|
|
|
|
errOut = outStream
|
|
|
|
}
|
|
|
|
// Now run the user process in container.
|
2014-09-16 06:43:43 +00:00
|
|
|
job.SetCloseIO(false)
|
2014-09-09 05:51:53 +00:00
|
|
|
if err := job.Run(); err != nil {
|
2014-09-15 22:56:47 +00:00
|
|
|
fmt.Fprintf(errOut, "Error starting exec command in container %s: %s\n", name, err)
|
2014-09-09 05:51:53 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
2014-09-17 18:36:51 +00:00
|
|
|
|
2014-09-09 05:51:53 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-09-15 22:56:47 +00:00
|
|
|
func postContainerExecResize(eng *engine.Engine, version version.Version, 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 err := eng.Job("execResize", vars["name"], r.Form.Get("h"), r.Form.Get("w")).Run(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func optionsHandler(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2013-06-11 01:10:40 +00:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
return nil
|
|
|
|
}
|
2013-06-04 01:39:00 +00:00
|
|
|
func writeCorsHeaders(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.Header().Add("Access-Control-Allow-Origin", "*")
|
2014-11-01 16:22:28 +00:00
|
|
|
w.Header().Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, X-Registry-Auth")
|
2013-06-10 02:17:35 +00:00
|
|
|
w.Header().Add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS")
|
2013-06-04 01:39:00 +00:00
|
|
|
}
|
|
|
|
|
2014-05-02 21:43:51 +00:00
|
|
|
func ping(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2014-05-02 22:03:59 +00:00
|
|
|
_, err := w.Write([]byte{'O', 'K'})
|
|
|
|
return err
|
2014-05-02 21:43:51 +00:00
|
|
|
}
|
|
|
|
|
2014-02-21 23:15:28 +00:00
|
|
|
func makeHttpHandler(eng *engine.Engine, logging bool, localMethod string, localRoute string, handlerFunc HttpApiFunc, enableCors bool, dockerVersion version.Version) http.HandlerFunc {
|
2013-07-13 14:59:07 +00:00
|
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
// log the request
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Debugf("Calling %s %s", localMethod, localRoute)
|
2013-07-13 14:59:07 +00:00
|
|
|
|
|
|
|
if logging {
|
2014-08-14 01:08:27 +00:00
|
|
|
log.Infof("%s %s", r.Method, r.RequestURI)
|
2013-07-13 14:59:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if strings.Contains(r.Header.Get("User-Agent"), "Docker-Client/") {
|
|
|
|
userAgent := strings.Split(r.Header.Get("User-Agent"), "/")
|
2014-04-01 22:46:52 +00:00
|
|
|
if len(userAgent) == 2 && !dockerVersion.Equal(version.Version(userAgent[1])) {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Debugf("Warning: client and server don't have the same version (client: %s, server: %s)", userAgent[1], dockerVersion)
|
2013-07-13 14:59:07 +00:00
|
|
|
}
|
|
|
|
}
|
2014-02-21 23:15:28 +00:00
|
|
|
version := version.Version(mux.Vars(r)["version"])
|
2014-02-14 22:53:53 +00:00
|
|
|
if version == "" {
|
2014-03-28 22:59:29 +00:00
|
|
|
version = api.APIVERSION
|
2013-07-13 14:59:07 +00:00
|
|
|
}
|
2014-01-29 00:20:51 +00:00
|
|
|
if enableCors {
|
2013-07-13 14:59:07 +00:00
|
|
|
writeCorsHeaders(w, r)
|
|
|
|
}
|
|
|
|
|
2014-03-28 22:59:29 +00:00
|
|
|
if version.GreaterThan(api.APIVERSION) {
|
|
|
|
http.Error(w, fmt.Errorf("client and server don't have same version (client : %s, server: %s)", version, api.APIVERSION).Error(), http.StatusNotFound)
|
2013-07-13 14:59:07 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-01-29 19:26:54 +00:00
|
|
|
if err := handlerFunc(eng, version, w, r, mux.Vars(r)); err != nil {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Errorf("Handler for %s %s returned error: %s", localMethod, localRoute, err)
|
2013-07-13 14:59:07 +00:00
|
|
|
httpError(w, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-03 18:04:18 +00:00
|
|
|
// Replicated from expvar.go as not public.
|
|
|
|
func expvarHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
|
|
fmt.Fprintf(w, "{\n")
|
|
|
|
first := true
|
|
|
|
expvar.Do(func(kv expvar.KeyValue) {
|
|
|
|
if !first {
|
|
|
|
fmt.Fprintf(w, ",\n")
|
|
|
|
}
|
|
|
|
first = false
|
|
|
|
fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
|
|
|
|
})
|
|
|
|
fmt.Fprintf(w, "\n}\n")
|
|
|
|
}
|
|
|
|
|
2013-11-19 19:25:17 +00:00
|
|
|
func AttachProfiler(router *mux.Router) {
|
2013-12-03 18:04:18 +00:00
|
|
|
router.HandleFunc("/debug/vars", expvarHandler)
|
2013-11-19 19:25:17 +00:00
|
|
|
router.HandleFunc("/debug/pprof/", pprof.Index)
|
|
|
|
router.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
|
|
|
|
router.HandleFunc("/debug/pprof/profile", pprof.Profile)
|
|
|
|
router.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
|
2014-12-01 08:45:53 +00:00
|
|
|
router.HandleFunc("/debug/pprof/block", pprof.Handler("block").ServeHTTP)
|
2013-11-19 19:25:17 +00:00
|
|
|
router.HandleFunc("/debug/pprof/heap", pprof.Handler("heap").ServeHTTP)
|
|
|
|
router.HandleFunc("/debug/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
|
|
|
|
router.HandleFunc("/debug/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
|
|
|
|
}
|
|
|
|
|
2015-01-13 21:41:34 +00:00
|
|
|
func createRouter(eng *engine.Engine, logging, enableCors bool, dockerVersion string) *mux.Router {
|
2013-05-07 23:33:12 +00:00
|
|
|
r := mux.NewRouter()
|
2013-11-19 19:25:17 +00:00
|
|
|
if os.Getenv("DEBUG") != "" {
|
|
|
|
AttachProfiler(r)
|
|
|
|
}
|
2013-07-13 17:19:38 +00:00
|
|
|
m := map[string]map[string]HttpApiFunc{
|
2013-05-07 23:33:12 +00:00
|
|
|
"GET": {
|
2014-05-02 21:43:51 +00:00
|
|
|
"/_ping": ping,
|
2013-08-07 21:30:28 +00:00
|
|
|
"/events": getEvents,
|
2013-07-13 14:59:07 +00:00
|
|
|
"/info": getInfo,
|
2013-08-07 21:30:28 +00:00
|
|
|
"/version": getVersion,
|
2013-07-13 14:59:07 +00:00
|
|
|
"/images/json": getImagesJSON,
|
2013-10-08 13:52:36 +00:00
|
|
|
"/images/viz": getImagesViz,
|
2013-07-13 14:59:07 +00:00
|
|
|
"/images/search": getImagesSearch,
|
2014-05-01 04:26:24 +00:00
|
|
|
"/images/get": getImagesGet,
|
2013-09-02 16:06:17 +00:00
|
|
|
"/images/{name:.*}/get": getImagesGet,
|
2013-07-13 14:59:07 +00:00
|
|
|
"/images/{name:.*}/history": getImagesHistory,
|
|
|
|
"/images/{name:.*}/json": getImagesByName,
|
|
|
|
"/containers/ps": getContainersJSON,
|
|
|
|
"/containers/json": getContainersJSON,
|
|
|
|
"/containers/{name:.*}/export": getContainersExport,
|
|
|
|
"/containers/{name:.*}/changes": getContainersChanges,
|
|
|
|
"/containers/{name:.*}/json": getContainersByName,
|
2013-08-07 21:30:28 +00:00
|
|
|
"/containers/{name:.*}/top": getContainersTop,
|
2014-04-02 19:26:06 +00:00
|
|
|
"/containers/{name:.*}/logs": getContainersLogs,
|
2015-01-07 22:43:04 +00:00
|
|
|
"/containers/{name:.*}/stats": getContainersStats,
|
2013-07-13 14:59:07 +00:00
|
|
|
"/containers/{name:.*}/attach/ws": wsContainersAttach,
|
2014-11-17 23:50:09 +00:00
|
|
|
"/exec/{id:.*}/json": getExecByID,
|
2013-05-07 23:33:12 +00:00
|
|
|
},
|
|
|
|
"POST": {
|
2013-05-10 00:50:56 +00:00
|
|
|
"/auth": postAuth,
|
2013-05-07 23:33:12 +00:00
|
|
|
"/commit": postCommit,
|
2013-05-23 03:07:26 +00:00
|
|
|
"/build": postBuild,
|
2013-05-10 00:50:56 +00:00
|
|
|
"/images/create": postImagesCreate,
|
2013-09-02 16:06:17 +00:00
|
|
|
"/images/load": postImagesLoad,
|
2013-05-10 05:28:52 +00:00
|
|
|
"/images/{name:.*}/push": postImagesPush,
|
2013-05-10 00:50:56 +00:00
|
|
|
"/images/{name:.*}/tag": postImagesTag,
|
|
|
|
"/containers/create": postContainersCreate,
|
|
|
|
"/containers/{name:.*}/kill": postContainersKill,
|
2014-05-21 21:06:18 +00:00
|
|
|
"/containers/{name:.*}/pause": postContainersPause,
|
|
|
|
"/containers/{name:.*}/unpause": postContainersUnpause,
|
2013-05-07 23:33:12 +00:00
|
|
|
"/containers/{name:.*}/restart": postContainersRestart,
|
|
|
|
"/containers/{name:.*}/start": postContainersStart,
|
|
|
|
"/containers/{name:.*}/stop": postContainersStop,
|
|
|
|
"/containers/{name:.*}/wait": postContainersWait,
|
2013-05-24 02:33:28 +00:00
|
|
|
"/containers/{name:.*}/resize": postContainersResize,
|
2013-05-07 23:33:12 +00:00
|
|
|
"/containers/{name:.*}/attach": postContainersAttach,
|
2013-07-17 04:07:41 +00:00
|
|
|
"/containers/{name:.*}/copy": postContainersCopy,
|
2014-09-15 22:56:47 +00:00
|
|
|
"/containers/{name:.*}/exec": postContainerExecCreate,
|
|
|
|
"/exec/{name:.*}/start": postContainerExecStart,
|
|
|
|
"/exec/{name:.*}/resize": postContainerExecResize,
|
2014-10-05 02:47:54 +00:00
|
|
|
"/containers/{name:.*}/rename": postContainerRename,
|
2013-05-07 23:33:12 +00:00
|
|
|
},
|
|
|
|
"DELETE": {
|
|
|
|
"/containers/{name:.*}": deleteContainers,
|
|
|
|
"/images/{name:.*}": deleteImages,
|
|
|
|
},
|
2013-06-11 01:10:40 +00:00
|
|
|
"OPTIONS": {
|
|
|
|
"": optionsHandler,
|
|
|
|
},
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for method, routes := range m {
|
|
|
|
for route, fct := range routes {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Debugf("Registering %s, %s", method, route)
|
2013-05-07 23:33:12 +00:00
|
|
|
// NOTE: scope issue, make sure the variables are local and won't be changed
|
|
|
|
localRoute := route
|
|
|
|
localFct := fct
|
2013-07-13 14:59:07 +00:00
|
|
|
localMethod := method
|
2013-06-21 01:18:36 +00:00
|
|
|
|
2013-07-13 14:59:07 +00:00
|
|
|
// build the handler function
|
2014-02-21 23:15:28 +00:00
|
|
|
f := makeHttpHandler(eng, logging, localMethod, localRoute, localFct, enableCors, version.Version(dockerVersion))
|
2013-06-11 01:10:40 +00:00
|
|
|
|
2013-07-13 14:59:07 +00:00
|
|
|
// add the new route
|
2013-06-11 01:10:40 +00:00
|
|
|
if localRoute == "" {
|
|
|
|
r.Methods(localMethod).HandlerFunc(f)
|
|
|
|
} else {
|
|
|
|
r.Path("/v{version:[0-9.]+}" + localRoute).Methods(localMethod).HandlerFunc(f)
|
|
|
|
r.Path(localRoute).Methods(localMethod).HandlerFunc(f)
|
|
|
|
}
|
2013-04-29 15:46:41 +00:00
|
|
|
}
|
2013-05-07 23:33:12 +00:00
|
|
|
}
|
2013-07-05 17:55:15 +00:00
|
|
|
|
2015-01-13 21:41:34 +00:00
|
|
|
return r
|
2013-06-10 22:02:40 +00:00
|
|
|
}
|
|
|
|
|
2013-11-14 06:08:08 +00:00
|
|
|
// ServeRequest processes a single http request to the docker remote api.
|
|
|
|
// FIXME: refactor this to be part of Server and not require re-creating a new
|
|
|
|
// router each time. This requires first moving ListenAndServe into Server.
|
2015-01-13 21:41:34 +00:00
|
|
|
func ServeRequest(eng *engine.Engine, apiversion version.Version, w http.ResponseWriter, req *http.Request) {
|
|
|
|
router := createRouter(eng, false, true, "")
|
2013-11-14 06:08:08 +00:00
|
|
|
// Insert APIVERSION into the request as a convenience
|
2014-02-18 01:44:53 +00:00
|
|
|
req.URL.Path = fmt.Sprintf("/v%s%s", apiversion, req.URL.Path)
|
2013-11-14 06:08:08 +00:00
|
|
|
router.ServeHTTP(w, req)
|
|
|
|
}
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
// serveFd creates an http.Server and sets it up to serve given a socket activated
|
2013-12-07 05:19:30 +00:00
|
|
|
// argument.
|
2014-11-07 20:21:19 +00:00
|
|
|
func serveFd(addr string, job *engine.Job) error {
|
2015-01-13 21:41:34 +00:00
|
|
|
r := createRouter(job.Eng, job.GetenvBool("Logging"), job.GetenvBool("EnableCors"), job.Getenv("Version"))
|
2014-11-07 20:21:19 +00:00
|
|
|
|
2013-12-07 05:19:30 +00:00
|
|
|
ls, e := systemd.ListenFD(addr)
|
|
|
|
if e != nil {
|
|
|
|
return e
|
|
|
|
}
|
|
|
|
|
|
|
|
chErrors := make(chan error, len(ls))
|
|
|
|
|
2014-03-01 04:43:08 +00:00
|
|
|
// We don't want to start serving on these sockets until the
|
2014-08-08 09:12:39 +00:00
|
|
|
// daemon is initialized and installed. Otherwise required handlers
|
2014-03-01 04:43:08 +00:00
|
|
|
// won't be ready.
|
|
|
|
<-activationLock
|
|
|
|
|
2013-12-07 05:19:30 +00:00
|
|
|
// Since ListenFD will return one or more sockets we have
|
|
|
|
// to create a go func to spawn off multiple serves
|
2014-01-28 01:09:36 +00:00
|
|
|
for i := range ls {
|
2013-12-07 05:19:30 +00:00
|
|
|
listener := ls[i]
|
2014-01-15 04:07:39 +00:00
|
|
|
go func() {
|
2014-11-07 20:21:19 +00:00
|
|
|
httpSrv := http.Server{Handler: r}
|
2013-12-07 05:19:30 +00:00
|
|
|
chErrors <- httpSrv.Serve(listener)
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2014-08-30 17:43:48 +00:00
|
|
|
for i := 0; i < len(ls); i++ {
|
2013-12-07 05:19:30 +00:00
|
|
|
err := <-chErrors
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-01-25 00:18:02 +00:00
|
|
|
func lookupGidByName(nameOrGid string) (int, error) {
|
2014-12-23 20:10:03 +00:00
|
|
|
groupFile, err := user.GetGroupPath()
|
2014-11-07 22:58:39 +00:00
|
|
|
if err != nil {
|
|
|
|
return -1, err
|
|
|
|
}
|
|
|
|
groups, err := user.ParseGroupFileFilter(groupFile, func(g user.Group) bool {
|
2014-01-25 00:18:02 +00:00
|
|
|
return g.Name == nameOrGid || strconv.Itoa(g.Gid) == nameOrGid
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return -1, err
|
|
|
|
}
|
|
|
|
if groups != nil && len(groups) > 0 {
|
|
|
|
return groups[0].Gid, nil
|
|
|
|
}
|
|
|
|
return -1, fmt.Errorf("Group %s not found", nameOrGid)
|
|
|
|
}
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
func setupTls(cert, key, ca string, l net.Listener) (net.Listener, error) {
|
|
|
|
tlsCert, err := tls.LoadX509KeyPair(cert, key)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("Couldn't load X509 key pair (%s, %s): %s. Key encrypted?",
|
|
|
|
cert, key, err)
|
|
|
|
}
|
|
|
|
tlsConfig := &tls.Config{
|
|
|
|
NextProtos: []string{"http/1.1"},
|
|
|
|
Certificates: []tls.Certificate{tlsCert},
|
|
|
|
// Avoid fallback on insecure SSL protocols
|
|
|
|
MinVersion: tls.VersionTLS10,
|
|
|
|
}
|
|
|
|
|
|
|
|
if ca != "" {
|
|
|
|
certPool := x509.NewCertPool()
|
|
|
|
file, err := ioutil.ReadFile(ca)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("Couldn't read CA certificate: %s", err)
|
|
|
|
}
|
|
|
|
certPool.AppendCertsFromPEM(file)
|
|
|
|
tlsConfig.ClientAuth = tls.RequireAndVerifyClientCert
|
|
|
|
tlsConfig.ClientCAs = certPool
|
|
|
|
}
|
|
|
|
|
|
|
|
return tls.NewListener(l, tlsConfig), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func newListener(proto, addr string, bufferRequests bool) (net.Listener, error) {
|
|
|
|
if bufferRequests {
|
|
|
|
return listenbuffer.NewListenBuffer(proto, addr, activationLock)
|
|
|
|
}
|
|
|
|
|
|
|
|
return net.Listen(proto, addr)
|
|
|
|
}
|
|
|
|
|
2014-01-25 00:18:02 +00:00
|
|
|
func changeGroup(addr string, nameOrGid string) error {
|
|
|
|
gid, err := lookupGidByName(nameOrGid)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Debugf("%s group found. gid: %d", nameOrGid, gid)
|
2014-01-25 00:18:02 +00:00
|
|
|
return os.Chown(addr, 0, gid)
|
|
|
|
}
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
func setSocketGroup(addr, group string) error {
|
|
|
|
if group == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := changeGroup(addr, group); err != nil {
|
|
|
|
if group != "docker" {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
log.Debugf("Warning: could not chgrp %s to docker: %v", addr, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func setupUnixHttp(addr string, job *engine.Job) (*HttpServer, error) {
|
2015-01-13 21:41:34 +00:00
|
|
|
r := createRouter(job.Eng, job.GetenvBool("Logging"), job.GetenvBool("EnableCors"), job.Getenv("Version"))
|
2013-12-07 05:19:30 +00:00
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
if err := syscall.Unlink(addr); err != nil && !os.IsNotExist(err) {
|
|
|
|
return nil, err
|
2013-06-18 18:59:56 +00:00
|
|
|
}
|
2014-11-07 20:21:19 +00:00
|
|
|
mask := syscall.Umask(0777)
|
|
|
|
defer syscall.Umask(mask)
|
2013-12-07 05:19:30 +00:00
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
l, err := newListener("unix", addr, job.GetenvBool("BufferRequests"))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2013-12-07 05:19:30 +00:00
|
|
|
}
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
if err := setSocketGroup(addr, job.Getenv("SocketGroup")); err != nil {
|
|
|
|
return nil, err
|
2014-05-20 17:02:55 +00:00
|
|
|
}
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
if err := os.Chmod(addr, 0660); err != nil {
|
|
|
|
return nil, err
|
2014-05-01 23:07:11 +00:00
|
|
|
}
|
2014-05-20 17:02:55 +00:00
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
return &HttpServer{&http.Server{Addr: addr, Handler: r}, l}, nil
|
|
|
|
}
|
|
|
|
|
2014-11-15 04:38:02 +00:00
|
|
|
func allocateDaemonPort(addr string) error {
|
|
|
|
host, port, err := net.SplitHostPort(addr)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
intPort, err := strconv.Atoi(port)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
var hostIPs []net.IP
|
|
|
|
if parsedIP := net.ParseIP(host); parsedIP != nil {
|
|
|
|
hostIPs = append(hostIPs, parsedIP)
|
|
|
|
} else if hostIPs, err = net.LookupIP(host); err != nil {
|
|
|
|
return fmt.Errorf("failed to lookup %s address in host specification", host)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, hostIP := range hostIPs {
|
|
|
|
if _, err := portallocator.RequestPort(hostIP, "tcp", intPort); err != nil {
|
|
|
|
return fmt.Errorf("failed to allocate daemon listening port %d (err: %v)", intPort, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
func setupTcpHttp(addr string, job *engine.Job) (*HttpServer, error) {
|
2015-02-12 08:00:32 +00:00
|
|
|
if !job.GetenvBool("TlsVerify") {
|
|
|
|
log.Infof("/!\\ DON'T BIND ON ANY IP ADDRESS WITHOUT setting -tlsverify IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
|
2014-05-20 17:02:55 +00:00
|
|
|
}
|
2014-11-07 20:21:19 +00:00
|
|
|
|
2015-01-13 21:41:34 +00:00
|
|
|
r := createRouter(job.Eng, job.GetenvBool("Logging"), job.GetenvBool("EnableCors"), job.Getenv("Version"))
|
2013-12-07 05:19:30 +00:00
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
l, err := newListener("tcp", addr, job.GetenvBool("BufferRequests"))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2014-02-27 12:47:59 +00:00
|
|
|
|
2014-11-15 04:38:02 +00:00
|
|
|
if err := allocateDaemonPort(addr); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
if job.GetenvBool("Tls") || job.GetenvBool("TlsVerify") {
|
|
|
|
var tlsCa string
|
|
|
|
if job.GetenvBool("TlsVerify") {
|
|
|
|
tlsCa = job.Getenv("TlsCa")
|
|
|
|
}
|
|
|
|
l, err = setupTls(job.Getenv("TlsCert"), job.Getenv("TlsKey"), tlsCa, l)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2014-02-27 12:47:59 +00:00
|
|
|
}
|
|
|
|
}
|
2014-11-07 20:21:19 +00:00
|
|
|
return &HttpServer{&http.Server{Addr: addr, Handler: r}, l}, nil
|
|
|
|
}
|
2014-02-27 12:47:59 +00:00
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
// NewServer sets up the required Server and does protocol specific checking.
|
|
|
|
func NewServer(proto, addr string, job *engine.Job) (Server, error) {
|
2013-12-07 05:19:30 +00:00
|
|
|
// Basic error and sanity checking
|
|
|
|
switch proto {
|
2014-11-07 20:21:19 +00:00
|
|
|
case "fd":
|
|
|
|
return nil, serveFd(addr, job)
|
2013-12-07 05:19:30 +00:00
|
|
|
case "tcp":
|
2014-11-07 20:21:19 +00:00
|
|
|
return setupTcpHttp(addr, job)
|
2013-12-07 05:19:30 +00:00
|
|
|
case "unix":
|
2014-11-07 20:21:19 +00:00
|
|
|
return setupUnixHttp(addr, job)
|
2013-12-07 05:19:30 +00:00
|
|
|
default:
|
2014-11-07 20:21:19 +00:00
|
|
|
return nil, fmt.Errorf("Invalid protocol format.")
|
2013-06-18 18:59:56 +00:00
|
|
|
}
|
2014-11-07 20:21:19 +00:00
|
|
|
}
|
2013-12-05 01:44:08 +00:00
|
|
|
|
2014-11-07 20:21:19 +00:00
|
|
|
type Server interface {
|
|
|
|
Serve() error
|
|
|
|
Close() error
|
2013-04-11 02:48:21 +00:00
|
|
|
}
|
2014-01-31 19:30:43 +00:00
|
|
|
|
|
|
|
// ServeApi loops through all of the protocols sent in to docker and spawns
|
|
|
|
// off a go routine to setup a serving http.Server for each.
|
|
|
|
func ServeApi(job *engine.Job) engine.Status {
|
2014-05-01 23:08:39 +00:00
|
|
|
if len(job.Args) == 0 {
|
|
|
|
return job.Errorf("usage: %s PROTO://ADDR [PROTO://ADDR ...]", job.Name)
|
|
|
|
}
|
2014-02-16 04:24:55 +00:00
|
|
|
var (
|
|
|
|
protoAddrs = job.Args
|
|
|
|
chErrors = make(chan error, len(protoAddrs))
|
|
|
|
)
|
|
|
|
activationLock = make(chan struct{})
|
2014-01-31 19:30:43 +00:00
|
|
|
|
|
|
|
for _, protoAddr := range protoAddrs {
|
|
|
|
protoAddrParts := strings.SplitN(protoAddr, "://", 2)
|
2014-05-01 23:08:39 +00:00
|
|
|
if len(protoAddrParts) != 2 {
|
|
|
|
return job.Errorf("usage: %s PROTO://ADDR [PROTO://ADDR ...]", job.Name)
|
|
|
|
}
|
2014-01-31 19:30:43 +00:00
|
|
|
go func() {
|
2014-08-14 01:08:27 +00:00
|
|
|
log.Infof("Listening for HTTP on %s (%s)", protoAddrParts[0], protoAddrParts[1])
|
2014-11-07 20:21:19 +00:00
|
|
|
srv, err := NewServer(protoAddrParts[0], protoAddrParts[1], job)
|
|
|
|
if err != nil {
|
|
|
|
chErrors <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
chErrors <- srv.Serve()
|
2014-01-31 19:30:43 +00:00
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
2014-08-30 17:43:48 +00:00
|
|
|
for i := 0; i < len(protoAddrs); i++ {
|
2014-01-31 19:30:43 +00:00
|
|
|
err := <-chErrors
|
|
|
|
if err != nil {
|
|
|
|
return job.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-16 04:24:55 +00:00
|
|
|
return engine.StatusOK
|
|
|
|
}
|
|
|
|
|
|
|
|
func AcceptConnections(job *engine.Job) engine.Status {
|
2014-01-31 19:30:43 +00:00
|
|
|
// Tell the init daemon we are accepting requests
|
|
|
|
go systemd.SdNotify("READY=1")
|
|
|
|
|
2014-02-16 04:24:55 +00:00
|
|
|
// close the lock so the listeners start accepting connections
|
2014-05-03 00:11:20 +00:00
|
|
|
if activationLock != nil {
|
|
|
|
close(activationLock)
|
|
|
|
}
|
2014-02-16 04:24:55 +00:00
|
|
|
|
2014-01-31 19:30:43 +00:00
|
|
|
return engine.StatusOK
|
|
|
|
}
|