docker/api.go

1145 строки
29 KiB
Go
Исходник Обычный вид История

2013-04-11 06:48:21 +04:00
package docker
import (
"code.google.com/p/go.net/websocket"
2013-08-31 00:49:37 +04:00
"encoding/base64"
"encoding/json"
"fmt"
2013-05-06 15:34:31 +04:00
"github.com/dotcloud/docker/auth"
2013-05-15 02:37:35 +04:00
"github.com/dotcloud/docker/utils"
2013-04-11 06:48:21 +04:00
"github.com/gorilla/mux"
"io"
"io/ioutil"
2013-04-18 20:56:22 +04:00
"log"
2013-08-04 00:55:54 +04:00
"mime"
2013-06-18 22:59:56 +04:00
"net"
2013-04-11 06:48:21 +04:00
"net/http"
2013-06-18 22:59:56 +04:00
"os"
2013-06-07 03:41:41 +04:00
"os/exec"
"regexp"
2013-04-22 20:17:47 +04:00
"strconv"
"strings"
2013-04-11 06:48:21 +04:00
)
const APIVERSION = 1.5
const DEFAULTHTTPHOST = "127.0.0.1"
const DEFAULTHTTPPORT = 4243
const DEFAULTUNIXSOCKET = "/var/run/docker.sock"
2013-05-22 19:29:54 +04:00
type HttpApiFunc func(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error
func hijackServer(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {
conn, _, err := w.(http.Hijacker).Hijack()
if err != nil {
return nil, nil, err
}
// Flush the options to make sure the client sets the raw mode
conn.Write([]byte{})
return conn, conn, nil
}
2013-05-08 20:52:01 +04:00
//If we don't do this, POST method without Content-type (even with empty body) will fail
func parseForm(r *http.Request) error {
if err := r.ParseForm(); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
return err
}
return nil
}
func parseMultipartForm(r *http.Request) error {
if err := r.ParseMultipartForm(4096); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
return err
}
return nil
}
func httpError(w http.ResponseWriter, err error) {
2013-07-11 16:21:43 +04:00
statusCode := http.StatusInternalServerError
if strings.HasPrefix(err.Error(), "No such") {
2013-07-11 16:21:43 +04:00
statusCode = http.StatusNotFound
2013-05-16 17:45:29 +04:00
} else if strings.HasPrefix(err.Error(), "Bad parameter") {
2013-07-11 16:21:43 +04:00
statusCode = http.StatusBadRequest
} else if strings.HasPrefix(err.Error(), "Conflict") {
2013-07-11 16:21:43 +04:00
statusCode = http.StatusConflict
} else if strings.HasPrefix(err.Error(), "Impossible") {
2013-07-11 16:21:43 +04:00
statusCode = http.StatusNotAcceptable
2013-06-14 17:38:51 +04:00
} else if strings.HasPrefix(err.Error(), "Wrong login/password") {
2013-07-11 16:21:43 +04:00
statusCode = http.StatusUnauthorized
2013-06-14 17:38:51 +04:00
} else if strings.Contains(err.Error(), "hasn't been activated") {
2013-07-11 16:21:43 +04:00
statusCode = http.StatusForbidden
}
2013-07-11 16:21:43 +04:00
utils.Debugf("[error %d] %s", statusCode, err)
http.Error(w, err.Error(), statusCode)
}
2013-06-04 22:00:22 +04:00
func writeJSON(w http.ResponseWriter, b []byte) {
2013-05-10 23:11:59 +04:00
w.Header().Set("Content-Type", "application/json")
w.Write(b)
}
2013-05-16 17:45:29 +04:00
func getBoolParam(value string) (bool, error) {
2013-06-20 18:34:58 +04:00
if value == "" {
2013-05-16 17:45:29 +04:00
return false, nil
}
2013-06-22 02:55:33 +04:00
ret, err := strconv.ParseBool(value)
if err != nil {
2013-06-21 13:06:09 +04:00
return false, fmt.Errorf("Bad parameter")
2013-06-20 18:34:58 +04:00
}
2013-06-22 02:55:33 +04:00
return ret, nil
2013-05-16 17:45:29 +04:00
}
2013-08-04 00:55:54 +04:00
func matchesContentType(contentType, expectedType string) bool {
mimetype, _, err := mime.ParseMediaType(contentType)
if err != nil {
utils.Debugf("Error parsing media type: %s error: %s", contentType, err.Error())
}
return err == nil && mimetype == expectedType
}
func postAuth(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
authConfig := &auth.AuthConfig{}
err := json.NewDecoder(r.Body).Decode(authConfig)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
status, err := auth.Login(authConfig, srv.HTTPRequestFactory(nil))
if err != nil {
return err
}
if status != "" {
2013-06-04 22:00:22 +04:00
b, err := json.Marshal(&APIAuth{Status: status})
2013-05-06 15:34:31 +04:00
if err != nil {
2013-05-10 22:20:49 +04:00
return err
2013-05-06 15:34:31 +04:00
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusNoContent)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-06 15:34:31 +04:00
2013-05-22 19:29:54 +04:00
func getVersion(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
m := srv.DockerVersion()
b, err := json.Marshal(m)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-06 15:34:31 +04:00
2013-05-22 19:29:54 +04:00
func postContainersKill(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
if err := srv.ContainerKill(name); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusNoContent)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-06 15:34:31 +04:00
2013-05-22 19:29:54 +04:00
func getContainersExport(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
2013-04-11 06:48:21 +04:00
2013-05-10 01:28:03 +04:00
if err := srv.ContainerExport(name, w); err != nil {
utils.Debugf("%s", err)
2013-05-13 13:38:13 +04:00
return err
}
2013-05-10 22:20:49 +04:00
return nil
}
2013-06-04 22:00:22 +04:00
func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-04-24 18:32:51 +04:00
2013-05-16 17:45:29 +04:00
all, err := getBoolParam(r.Form.Get("all"))
if err != nil {
return err
}
2013-05-10 01:52:12 +04:00
filter := r.Form.Get("filter")
2013-04-24 18:32:51 +04:00
outs, err := srv.Images(all, filter)
2013-05-10 01:52:12 +04:00
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-10 01:52:12 +04:00
b, err := json.Marshal(outs)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
2013-05-10 01:52:12 +04:00
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
2013-05-10 01:52:12 +04:00
}
2013-05-22 19:29:54 +04:00
func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-10 01:52:12 +04:00
if err := srv.ImagesViz(w); err != nil {
2013-05-10 22:20:49 +04:00
return err
2013-05-10 01:52:12 +04:00
}
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-07 21:23:50 +04:00
2013-05-22 19:29:54 +04:00
func getInfo(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
out := srv.DockerInfo()
b, err := json.Marshal(out)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-04-18 20:56:22 +04:00
2013-07-10 16:55:05 +04:00
func getEvents(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-07-24 16:28:22 +04:00
sendEvent := func(wf *utils.WriteFlusher, event *utils.JSONMessage) error {
2013-07-10 16:55:05 +04:00
b, err := json.Marshal(event)
if err != nil {
2013-07-17 17:56:09 +04:00
return fmt.Errorf("JSON error")
2013-07-10 16:55:05 +04:00
}
_, err = wf.Write(b)
if err != nil {
2013-07-17 17:56:09 +04:00
// On error, evict the listener
2013-07-10 16:55:05 +04:00
utils.Debugf("%s", err)
srv.Lock()
delete(srv.listeners, r.RemoteAddr)
2013-07-10 16:55:05 +04:00
srv.Unlock()
2013-07-17 17:56:09 +04:00
return err
}
2013-07-17 17:56:09 +04:00
return nil
}
if err := parseForm(r); err != nil {
return err
}
listener := make(chan utils.JSONMessage)
srv.Lock()
srv.listeners[r.RemoteAddr] = listener
srv.Unlock()
since, err := strconv.ParseInt(r.Form.Get("since"), 10, 0)
if err != nil {
since = 0
}
w.Header().Set("Content-Type", "application/json")
wf := utils.NewWriteFlusher(w)
if since != 0 {
2013-07-17 17:56:09 +04:00
// If since, send previous events that happened after the timestamp
for _, event := range srv.events {
if event.Time >= since {
2013-07-17 17:56:09 +04:00
err := sendEvent(wf, &event)
if err != nil && err.Error() == "JSON error" {
continue
}
if err != nil {
return err
}
}
}
}
2013-08-10 04:42:20 +04:00
for event := range listener {
2013-07-17 17:56:09 +04:00
err := sendEvent(wf, &event)
if err != nil && err.Error() == "JSON error" {
continue
}
if err != nil {
2013-07-10 16:55:05 +04:00
return err
}
}
return nil
}
2013-05-22 19:29:54 +04:00
func getImagesHistory(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
outs, err := srv.ImageHistory(name)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
b, err := json.Marshal(outs)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-22 19:29:54 +04:00
func getContainersChanges(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
changesStr, err := srv.ContainerChanges(name)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
b, err := json.Marshal(changesStr)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-07-01 19:19:42 +04:00
func getContainersTop(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-07-19 14:34:55 +04:00
if version < 1.4 {
return fmt.Errorf("top was improved a lot since 1.3, Please upgrade your docker client.")
}
if vars == nil {
return fmt.Errorf("Missing parameter")
}
2013-07-19 14:06:32 +04:00
if err := parseForm(r); err != nil {
return err
}
name := vars["name"]
2013-07-19 14:06:32 +04:00
ps_args := r.Form.Get("ps_args")
procsStr, err := srv.ContainerTop(name, ps_args)
if err != nil {
return err
}
b, err := json.Marshal(procsStr)
if err != nil {
return err
}
writeJSON(w, b)
return nil
}
2013-06-04 22:00:22 +04:00
func getContainersJSON(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-16 17:45:29 +04:00
all, err := getBoolParam(r.Form.Get("all"))
if err != nil {
return err
}
2013-06-20 18:19:50 +04:00
size, err := getBoolParam(r.Form.Get("size"))
if err != nil {
return err
}
2013-05-08 20:28:11 +04:00
since := r.Form.Get("since")
before := r.Form.Get("before")
n, err := strconv.Atoi(r.Form.Get("limit"))
if err != nil {
n = -1
}
var b []byte
2013-06-20 18:19:50 +04:00
outs := srv.Containers(all, size, n, since, before)
if version < 1.5 {
outs2 := []APIContainersOld{}
for _, ctnr := range outs {
outs2 = append(outs2, ctnr.ToLegacy())
}
b, err = json.Marshal(outs2)
} else {
b, err = json.Marshal(outs)
}
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-22 19:29:54 +04:00
func postImagesTag(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
repo := r.Form.Get("repo")
tag := r.Form.Get("tag")
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
2013-05-16 17:45:29 +04:00
force, err := getBoolParam(r.Form.Get("force"))
if err != nil {
return err
}
if err := srv.ContainerTag(name, repo, tag, force); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
w.WriteHeader(http.StatusCreated)
2013-05-10 22:20:49 +04:00
return nil
}
2013-04-24 18:06:03 +04:00
2013-05-22 19:29:54 +04:00
func postCommit(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-10 23:28:07 +04:00
config := &Config{}
if err := json.NewDecoder(r.Body).Decode(config); err != nil {
utils.Debugf("%s", err)
}
repo := r.Form.Get("repo")
tag := r.Form.Get("tag")
container := r.Form.Get("container")
author := r.Form.Get("author")
comment := r.Form.Get("comment")
2013-05-10 23:28:07 +04:00
id, err := srv.ContainerCommit(container, repo, tag, author, comment, config)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
b, err := json.Marshal(&APIID{id})
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusCreated)
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-04-24 18:06:03 +04:00
// Creates an image from Pull or from Import
2013-05-22 19:29:54 +04:00
func postImagesCreate(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-04-23 01:37:22 +04:00
src := r.Form.Get("fromSrc")
image := r.Form.Get("fromImage")
tag := r.Form.Get("tag")
repo := r.Form.Get("repo")
2013-08-31 00:49:37 +04:00
authEncoded := r.Header.Get("X-Registry-Auth")
authConfig := &auth.AuthConfig{}
2013-08-31 00:49:37 +04:00
if authEncoded != "" {
authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {
// for a pull it is not an error if no auth was given
// to increase compatibility with the existing api it is defaulting to be empty
authConfig = &auth.AuthConfig{}
}
}
2013-05-25 19:09:46 +04:00
if version > 1.0 {
w.Header().Set("Content-Type", "application/json")
}
sf := utils.NewStreamFormatter(version > 1.0)
if image != "" { //pull
metaHeaders := map[string][]string{}
for k, v := range r.Header {
if strings.HasPrefix(k, "X-Meta-") {
metaHeaders[k] = v
}
}
if err := srv.ImagePull(image, tag, w, sf, authConfig, metaHeaders, version > 1.3); err != nil {
2013-05-25 19:09:46 +04:00
if sf.Used() {
2013-05-27 03:45:45 +04:00
w.Write(sf.FormatError(err))
2013-05-25 19:09:46 +04:00
return nil
}
return err
}
} else { //import
2013-05-25 19:09:46 +04:00
if err := srv.ImageImport(src, repo, tag, r.Body, w, sf); err != nil {
if sf.Used() {
2013-05-27 03:45:45 +04:00
w.Write(sf.FormatError(err))
2013-05-25 19:09:46 +04:00
return nil
}
return err
}
}
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-22 19:29:54 +04:00
func getImagesSearch(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
term := r.Form.Get("term")
outs, err := srv.ImagesSearch(term)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
b, err := json.Marshal(outs)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-22 19:29:54 +04:00
func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
url := r.Form.Get("url")
path := r.Form.Get("path")
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
2013-05-25 19:09:46 +04:00
if version > 1.0 {
w.Header().Set("Content-Type", "application/json")
}
sf := utils.NewStreamFormatter(version > 1.0)
2013-06-04 22:00:22 +04:00
imgID, err := srv.ImageInsert(name, url, path, w, sf)
if err != nil {
2013-05-25 19:09:46 +04:00
if sf.Used() {
2013-05-27 03:45:45 +04:00
w.Write(sf.FormatError(err))
2013-05-25 19:09:46 +04:00
return nil
}
}
2013-06-04 22:00:22 +04:00
b, err := json.Marshal(&APIID{ID: imgID})
if err != nil {
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-07 22:37:35 +04:00
2013-05-22 19:29:54 +04:00
func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
metaHeaders := map[string][]string{}
for k, v := range r.Header {
if strings.HasPrefix(k, "X-Meta-") {
metaHeaders[k] = v
}
}
2013-05-15 23:21:37 +04:00
if err := parseForm(r); err != nil {
return err
}
authConfig := &auth.AuthConfig{}
2013-08-31 00:49:37 +04: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
authConfig = &auth.AuthConfig{}
}
} else {
// the old format is supported for compatibility if there was no authConfig header
if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {
return err
}
}
2013-05-15 23:21:37 +04:00
if vars == nil {
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
2013-05-25 19:09:46 +04:00
if version > 1.0 {
w.Header().Set("Content-Type", "application/json")
}
sf := utils.NewStreamFormatter(version > 1.0)
if err := srv.ImagePush(name, w, sf, authConfig, metaHeaders); err != nil {
2013-05-25 19:09:46 +04:00
if sf.Used() {
2013-05-27 03:45:45 +04:00
w.Write(sf.FormatError(err))
2013-05-25 19:09:46 +04:00
return nil
}
2013-05-15 23:21:37 +04:00
return err
}
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-07 21:23:50 +04:00
2013-05-22 19:29:54 +04:00
func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
config := &Config{}
out := &APIRun{}
if err := json.NewDecoder(r.Body).Decode(config); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
resolvConf, err := utils.GetResolvConf()
if err != nil {
return err
}
if len(config.Dns) == 0 && len(srv.runtime.Dns) == 0 && utils.CheckLocalDns(resolvConf) {
2013-06-15 01:46:08 +04:00
out.Warnings = append(out.Warnings, fmt.Sprintf("Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns))
config.Dns = defaultDns
}
id, err := srv.ContainerCreate(config)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
out.ID = id
if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit {
log.Println("WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.")
out.Warnings = append(out.Warnings, "Your kernel does not support memory limit capabilities. Limitation discarded.")
}
if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit {
log.Println("WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.")
out.Warnings = append(out.Warnings, "Your kernel does not support memory swap capabilities. Limitation discarded.")
}
2013-08-19 16:34:30 +04:00
if srv.runtime.capabilities.IPv4ForwardingDisabled {
log.Println("Warning: IPv4 forwarding is disabled.")
out.Warnings = append(out.Warnings, "IPv4 forwarding is disabled.")
}
b, err := json.Marshal(out)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusCreated)
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-07 21:23:50 +04:00
2013-05-22 19:29:54 +04:00
func postContainersRestart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
t, err := strconv.Atoi(r.Form.Get("t"))
if err != nil || t < 0 {
t = 10
}
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
if err := srv.ContainerRestart(name, t); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusNoContent)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-06 15:34:31 +04:00
2013-05-22 19:29:54 +04:00
func deleteContainers(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
2013-05-16 17:45:29 +04:00
removeVolume, err := getBoolParam(r.Form.Get("v"))
if err != nil {
return err
}
2013-05-08 03:47:43 +04:00
2013-05-10 06:19:55 +04:00
if err := srv.ContainerDestroy(name, removeVolume); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusNoContent)
2013-05-10 22:20:49 +04:00
return nil
}
2013-04-23 01:37:22 +04:00
2013-05-22 19:29:54 +04:00
func deleteImages(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if err := parseForm(r); err != nil {
return err
}
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
2013-06-13 21:58:06 +04:00
imgs, err := srv.ImageDelete(name, version > 1.1)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
if imgs != nil {
if len(imgs) != 0 {
b, err := json.Marshal(imgs)
if err != nil {
return err
}
2013-06-11 01:05:54 +04:00
writeJSON(w, b)
} else {
return fmt.Errorf("Conflict, %s wasn't deleted", name)
}
} else {
w.WriteHeader(http.StatusNoContent)
}
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-22 19:29:54 +04:00
func postContainersStart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
hostConfig := &HostConfig{}
// allow a nil body for backwards compatibility
if r.Body != nil {
2013-08-04 00:55:54 +04:00
if matchesContentType(r.Header.Get("Content-Type"), "application/json") {
2013-06-30 21:46:09 +04:00
if err := json.NewDecoder(r.Body).Decode(hostConfig); err != nil {
return err
}
}
}
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
if err := srv.ContainerStart(name, hostConfig); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusNoContent)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-22 19:29:54 +04:00
func postContainersStop(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
t, err := strconv.Atoi(r.Form.Get("t"))
if err != nil || t < 0 {
t = 10
}
2013-05-10 06:19:24 +04:00
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
if err := srv.ContainerStop(name, t); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-09 23:42:29 +04:00
w.WriteHeader(http.StatusNoContent)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-22 19:29:54 +04:00
func postContainersWait(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
status, err := srv.ContainerWait(name)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
b, err := json.Marshal(&APIWait{StatusCode: status})
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-24 06:33:28 +04:00
func postContainersResize(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if err := 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
}
if vars == nil {
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
if err := srv.ContainerResize(name, height, width); err != nil {
return err
}
return nil
}
2013-05-22 19:29:54 +04:00
func postContainersAttach(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
2013-05-08 20:52:01 +04:00
if err := parseForm(r); err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-05-16 17:45:29 +04:00
logs, err := getBoolParam(r.Form.Get("logs"))
if err != nil {
return err
}
stream, err := getBoolParam(r.Form.Get("stream"))
if err != nil {
return err
}
stdin, err := getBoolParam(r.Form.Get("stdin"))
if err != nil {
return err
}
stdout, err := getBoolParam(r.Form.Get("stdout"))
if err != nil {
return err
}
stderr, err := getBoolParam(r.Form.Get("stderr"))
if err != nil {
return err
}
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
if _, err := srv.ContainerInspect(name); err != nil {
return err
}
in, out, err := hijackServer(w)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
defer func() {
if tcpc, ok := in.(*net.TCPConn); ok {
tcpc.CloseWrite()
} else {
in.Close()
}
}()
defer func() {
if tcpc, ok := out.(*net.TCPConn); ok {
tcpc.CloseWrite()
} else if closer, ok := out.(io.Closer); ok {
closer.Close()
}
}()
2013-04-11 06:48:21 +04:00
fmt.Fprintf(out, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")
if err := srv.ContainerAttach(name, logs, stream, stdin, stdout, stderr, in, out); err != nil {
fmt.Fprintf(out, "Error: %s\n", err)
}
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-02 07:07:06 +04:00
func wsContainersAttach(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if err := parseForm(r); err != nil {
return err
}
logs, err := getBoolParam(r.Form.Get("logs"))
if err != nil {
return err
}
stream, err := getBoolParam(r.Form.Get("stream"))
if err != nil {
return err
}
stdin, err := getBoolParam(r.Form.Get("stdin"))
if err != nil {
return err
}
stdout, err := getBoolParam(r.Form.Get("stdout"))
if err != nil {
return err
}
stderr, err := getBoolParam(r.Form.Get("stderr"))
if err != nil {
return err
}
if vars == nil {
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
if _, err := srv.ContainerInspect(name); err != nil {
return err
}
h := websocket.Handler(func(ws *websocket.Conn) {
defer ws.Close()
if err := srv.ContainerAttach(name, logs, stream, stdin, stdout, stderr, ws, ws); err != nil {
utils.Debugf("Error: %s", err)
}
})
h.ServeHTTP(w, r)
return nil
}
2013-05-22 19:29:54 +04:00
func getContainersByName(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
2013-05-02 07:07:06 +04:00
container, err := srv.ContainerInspect(name)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
_, err = srv.ImageInspect(name)
if err == nil {
return fmt.Errorf("Conflict between containers and images")
}
b, err := json.Marshal(container)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-02 07:07:06 +04:00
2013-05-22 19:29:54 +04:00
func getImagesByName(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
2013-05-10 22:20:49 +04:00
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
image, err := srv.ImageInspect(name)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
_, err = srv.ContainerInspect(name)
if err == nil {
return fmt.Errorf("Conflict between containers and images")
}
b, err := json.Marshal(image)
if err != nil {
2013-05-10 22:20:49 +04:00
return err
}
2013-06-04 22:00:22 +04:00
writeJSON(w, b)
2013-05-10 22:20:49 +04:00
return nil
}
2013-05-29 00:46:52 +04:00
func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if version < 1.3 {
return fmt.Errorf("Multipart upload for build is no longer supported. Please upgrade your docker client.")
}
remoteURL := r.FormValue("remote")
repoName := r.FormValue("t")
rawSuppressOutput := r.FormValue("q")
rawNoCache := r.FormValue("nocache")
2013-07-31 12:01:20 +04:00
repoName, tag := utils.ParseRepositoryTag(repoName)
var context io.Reader
if remoteURL == "" {
context = r.Body
} else if utils.IsGIT(remoteURL) {
if !strings.HasPrefix(remoteURL, "git://") {
remoteURL = "https://" + remoteURL
}
root, err := ioutil.TempDir("", "docker-build-git")
if err != nil {
return err
}
defer os.RemoveAll(root)
if output, err := exec.Command("git", "clone", remoteURL, root).CombinedOutput(); err != nil {
return fmt.Errorf("Error trying to use git: %s (%s)", err, output)
}
c, err := Tar(root, Bzip2)
if err != nil {
return err
}
context = c
} else if utils.IsURL(remoteURL) {
f, err := utils.Download(remoteURL, ioutil.Discard)
if err != nil {
return err
}
defer f.Body.Close()
dockerFile, err := ioutil.ReadAll(f.Body)
if err != nil {
return err
}
c, err := mkBuildContext(string(dockerFile), nil)
if err != nil {
return err
}
context = c
}
suppressOutput, err := getBoolParam(rawSuppressOutput)
if err != nil {
return err
}
noCache, err := getBoolParam(rawNoCache)
if err != nil {
return err
}
b := NewBuildFile(srv, utils.NewWriteFlusher(w), !suppressOutput, !noCache)
id, err := b.Build(context)
if err != nil {
fmt.Fprintf(w, "Error build: %s\n", err)
return err
}
if repoName != "" {
srv.runtime.repositories.Set(repoName, tag, id, false)
}
return nil
}
func postContainersCopy(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if vars == nil {
return fmt.Errorf("Missing parameter")
}
name := vars["name"]
copyData := &APICopy{}
contentType := r.Header.Get("Content-Type")
if contentType == "application/json" {
if err := json.NewDecoder(r.Body).Decode(copyData); err != nil {
return err
}
} else {
return fmt.Errorf("Content-Type not supported: %s", contentType)
}
if copyData.Resource == "" {
return fmt.Errorf("Resource cannot be empty")
}
if copyData.Resource[0] == '/' {
copyData.Resource = copyData.Resource[1:]
}
if err := srv.ContainerCopy(name, copyData.Resource, w); err != nil {
utils.Debugf("%s", err.Error())
return err
}
return nil
}
func optionsHandler(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
w.WriteHeader(http.StatusOK)
return nil
}
func writeCorsHeaders(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Access-Control-Allow-Origin", "*")
w.Header().Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
w.Header().Add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS")
}
func makeHttpHandler(srv *Server, logging bool, localMethod string, localRoute string, handlerFunc HttpApiFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// log the request
utils.Debugf("Calling %s %s", localMethod, localRoute)
if logging {
log.Println(r.Method, r.RequestURI)
}
if strings.Contains(r.Header.Get("User-Agent"), "Docker-Client/") {
userAgent := strings.Split(r.Header.Get("User-Agent"), "/")
if len(userAgent) == 2 && userAgent[1] != VERSION {
utils.Debugf("Warning: client and server don't have the same version (client: %s, server: %s)", userAgent[1], VERSION)
}
}
version, err := strconv.ParseFloat(mux.Vars(r)["version"], 64)
if err != nil {
version = APIVERSION
}
if srv.enableCors {
writeCorsHeaders(w, r)
}
if version == 0 || version > APIVERSION {
w.WriteHeader(http.StatusNotFound)
return
}
if err := handlerFunc(srv, version, w, r, mux.Vars(r)); err != nil {
utils.Debugf("Error: %s", err)
httpError(w, err)
}
}
}
func createRouter(srv *Server, logging bool) (*mux.Router, error) {
r := mux.NewRouter()
2013-07-13 21:19:38 +04:00
m := map[string]map[string]HttpApiFunc{
"GET": {
"/events": getEvents,
"/info": getInfo,
"/version": getVersion,
"/images/json": getImagesJSON,
"/images/viz": getImagesViz,
"/images/search": getImagesSearch,
"/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,
"/containers/{name:.*}/top": getContainersTop,
"/containers/{name:.*}/attach/ws": wsContainersAttach,
},
"POST": {
"/auth": postAuth,
"/commit": postCommit,
"/build": postBuild,
"/images/create": postImagesCreate,
2013-05-10 09:28:52 +04:00
"/images/{name:.*}/insert": postImagesInsert,
"/images/{name:.*}/push": postImagesPush,
"/images/{name:.*}/tag": postImagesTag,
"/containers/create": postContainersCreate,
"/containers/{name:.*}/kill": postContainersKill,
"/containers/{name:.*}/restart": postContainersRestart,
"/containers/{name:.*}/start": postContainersStart,
"/containers/{name:.*}/stop": postContainersStop,
"/containers/{name:.*}/wait": postContainersWait,
2013-05-24 06:33:28 +04:00
"/containers/{name:.*}/resize": postContainersResize,
"/containers/{name:.*}/attach": postContainersAttach,
"/containers/{name:.*}/copy": postContainersCopy,
},
"DELETE": {
"/containers/{name:.*}": deleteContainers,
"/images/{name:.*}": deleteImages,
},
"OPTIONS": {
"": optionsHandler,
},
}
for method, routes := range m {
for route, fct := range routes {
2013-05-15 02:37:35 +04:00
utils.Debugf("Registering %s, %s", method, route)
// NOTE: scope issue, make sure the variables are local and won't be changed
localRoute := route
localFct := fct
localMethod := method
2013-06-21 05:18:36 +04:00
// build the handler function
f := makeHttpHandler(srv, logging, localMethod, localRoute, localFct)
// add the new route
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)
}
}
}
return r, nil
}
2013-06-18 22:59:56 +04:00
func ListenAndServe(proto, addr string, srv *Server, logging bool) error {
log.Printf("Listening for HTTP on %s (%s)\n", addr, proto)
r, err := createRouter(srv, logging)
if err != nil {
return err
}
2013-06-18 22:59:56 +04:00
l, e := net.Listen(proto, addr)
if e != nil {
return e
}
if proto == "unix" {
if err := os.Chmod(addr, 0660); err != nil {
return err
}
groups, err := ioutil.ReadFile("/etc/group")
if err != nil {
return err
}
re := regexp.MustCompile("(^|\n)docker:.*?:([0-9]+)")
if gidMatch := re.FindStringSubmatch(string(groups)); gidMatch != nil {
gid, err := strconv.Atoi(gidMatch[2])
if err != nil {
return err
}
utils.Debugf("docker group found. gid: %d", gid)
if err := os.Chown(addr, 0, gid); err != nil {
return err
}
}
2013-06-18 22:59:56 +04:00
}
httpSrv := http.Server{Addr: addr, Handler: r}
return httpSrv.Serve(l)
2013-04-11 06:48:21 +04:00
}