1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552 |
- package server
- import (
- "bufio"
- "bytes"
- "time"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "io"
- "net"
- "net/http"
- "os"
- "strconv"
- "strings"
- "code.google.com/p/go.net/websocket"
- "github.com/gorilla/mux"
- "github.com/Sirupsen/logrus"
- "github.com/docker/docker/api"
- "github.com/docker/docker/api/types"
- "github.com/docker/docker/daemon"
- "github.com/docker/docker/daemon/networkdriver/bridge"
- "github.com/docker/docker/engine"
- "github.com/docker/docker/graph"
- "github.com/docker/docker/pkg/jsonmessage"
- "github.com/docker/docker/pkg/parsers"
- "github.com/docker/docker/pkg/parsers/filters"
- "github.com/docker/docker/pkg/stdcopy"
- "github.com/docker/docker/pkg/streamformatter"
- "github.com/docker/docker/pkg/version"
- "github.com/docker/docker/registry"
- "github.com/docker/docker/utils"
- )
- var (
- activationLock = make(chan struct{})
- )
- 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()
- }
- type HttpApiFunc func(eng *engine.Engine, version version.Version, 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
- }
- 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()
- }
- }
- }
- // 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)
- }
- //If we don't do this, POST method without Content-type (even with empty body) will fail
- func parseForm(r *http.Request) error {
- if r == nil {
- return nil
- }
- 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) {
- statusCode := http.StatusInternalServerError
- // 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.
- errStr := strings.ToLower(err.Error())
- if strings.Contains(errStr, "no such") {
- statusCode = http.StatusNotFound
- } else if strings.Contains(errStr, "bad parameter") {
- statusCode = http.StatusBadRequest
- } else if strings.Contains(errStr, "conflict") {
- statusCode = http.StatusConflict
- } else if strings.Contains(errStr, "impossible") {
- statusCode = http.StatusNotAcceptable
- } else if strings.Contains(errStr, "wrong login/password") {
- statusCode = http.StatusUnauthorized
- } else if strings.Contains(errStr, "hasn't been activated") {
- statusCode = http.StatusForbidden
- }
- if err != nil {
- logrus.Errorf("HTTP Error: statusCode=%d %v", statusCode, err)
- http.Error(w, err.Error(), statusCode)
- }
- }
- // writeJSONEnv writes the engine.Env values to the http response stream as a
- // json encoded body.
- func writeJSONEnv(w http.ResponseWriter, code int, v engine.Env) error {
- w.Header().Set("Content-Type", "application/json")
- w.WriteHeader(code)
- return v.Encode(w)
- }
- // writeJSON writes the value v to the http response stream as json with standard
- // json encoding.
- func writeJSON(w http.ResponseWriter, code int, v interface{}) error {
- w.Header().Set("Content-Type", "application/json")
- w.WriteHeader(code)
- return json.NewEncoder(w).Encode(v)
- }
- 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)
- }
- }
- func getDaemon(eng *engine.Engine) *daemon.Daemon {
- return eng.HackGetGlobalVar("httpapi.daemon").(*daemon.Daemon)
- }
- func postAuth(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- var config *registry.AuthConfig
- err := json.NewDecoder(r.Body).Decode(&config)
- r.Body.Close()
- if err != nil {
- return err
- }
- d := getDaemon(eng)
- status, err := d.RegistryService.Auth(config)
- if err != nil {
- return err
- }
- return writeJSON(w, http.StatusOK, &types.AuthResponse{
- Status: status,
- })
- }
- func getVersion(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- w.Header().Set("Content-Type", "application/json")
- eng.ServeHTTP(w, r)
- return nil
- }
- func postContainersKill(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("kill", vars["name"])
- if sig := r.Form.Get("signal"); sig != "" {
- job.Args = append(job.Args, sig)
- }
- if err := job.Run(); err != nil {
- return err
- }
- w.WriteHeader(http.StatusNoContent)
- return nil
- }
- 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
- }
- func getContainersExport(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")
- }
- job := eng.Job("export", vars["name"])
- job.Stdout.Add(w)
- if err := job.Run(); err != nil {
- return err
- }
- return nil
- }
- func getImagesJSON(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
- }
- imagesConfig := graph.ImagesConfig{
- Filters: r.Form.Get("filters"),
- // FIXME this parameter could just be a match filter
- Filter: r.Form.Get("filter"),
- All: toBool(r.Form.Get("all")),
- }
- images, err := getDaemon(eng).Repositories().Images(&imagesConfig)
- if err != nil {
- return err
- }
- if version.GreaterThanOrEqualTo("1.7") {
- return writeJSON(w, http.StatusOK, images)
- }
- legacyImages := []types.LegacyImage{}
- for _, image := range images {
- for _, repoTag := range image.RepoTags {
- repo, tag := parsers.ParseRepositoryTag(repoTag)
- legacyImage := types.LegacyImage{
- Repository: repo,
- Tag: tag,
- ID: image.ID,
- Created: image.Created,
- Size: image.Size,
- VirtualSize: image.VirtualSize,
- }
- legacyImages = append(legacyImages, legacyImage)
- }
- }
- return writeJSON(w, http.StatusOK, legacyImages)
- }
- func getImagesViz(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- if version.GreaterThan("1.6") {
- w.WriteHeader(http.StatusNotFound)
- return fmt.Errorf("This is now implemented in the client.")
- }
- eng.ServeHTTP(w, r)
- return nil
- }
- func getInfo(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- w.Header().Set("Content-Type", "application/json")
- eng.ServeHTTP(w, r)
- return nil
- }
- func getEvents(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
- }
- var since int64 = -1
- if r.Form.Get("since") != "" {
- s, err := strconv.ParseInt(r.Form.Get("since"), 10, 64)
- if err != nil {
- return err
- }
- since = s
- }
- var until int64 = -1
- if r.Form.Get("until") != "" {
- u, err := strconv.ParseInt(r.Form.Get("until"), 10, 64)
- if err != nil {
- return err
- }
- until = u
- }
- timer := time.NewTimer(0)
- timer.Stop()
- if until > 0 {
- dur := time.Unix(until, 0).Sub(time.Now())
- timer = time.NewTimer(dur)
- }
- ef, err := filters.FromParam(r.Form.Get("filters"))
- if err != nil {
- return err
- }
- isFiltered := func(field string, filter []string) bool {
- if len(filter) == 0 {
- return false
- }
- for _, v := range filter {
- if v == field {
- return false
- }
- if strings.Contains(field, ":") {
- image := strings.Split(field, ":")
- if image[0] == v {
- return false
- }
- }
- }
- return true
- }
- d := getDaemon(eng)
- es := d.EventsService
- w.Header().Set("Content-Type", "application/json")
- enc := json.NewEncoder(utils.NewWriteFlusher(w))
- getContainerId := func(cn string) string {
- c, err := d.Get(cn)
- if err != nil {
- return ""
- }
- return c.ID
- }
- sendEvent := func(ev *jsonmessage.JSONMessage) error {
- //incoming container filter can be name,id or partial id, convert and replace as a full container id
- for i, cn := range ef["container"] {
- ef["container"][i] = getContainerId(cn)
- }
- if isFiltered(ev.Status, ef["event"]) || isFiltered(ev.From, ef["image"]) ||
- isFiltered(ev.ID, ef["container"]) {
- return nil
- }
- return enc.Encode(ev)
- }
- current, l := es.Subscribe()
- defer es.Evict(l)
- for _, ev := range current {
- if ev.Time < since {
- continue
- }
- if err := sendEvent(ev); err != nil {
- return err
- }
- }
- for {
- select {
- case ev := <-l:
- jev, ok := ev.(*jsonmessage.JSONMessage)
- if !ok {
- continue
- }
- if err := sendEvent(jev); err != nil {
- return err
- }
- case <-timer.C:
- return nil
- }
- }
- }
- func getImagesHistory(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")
- }
- var job = eng.Job("history", vars["name"])
- streamJSON(job, w, false)
- if err := job.Run(); err != nil {
- return err
- }
- return nil
- }
- func getContainersChanges(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")
- }
- name := vars["name"]
- if name == "" {
- return fmt.Errorf("Container name cannot be empty")
- }
- d := getDaemon(eng)
- cont, err := d.Get(name)
- if err != nil {
- return err
- }
- changes, err := cont.Changes()
- if err != nil {
- return err
- }
- return writeJSON(w, http.StatusOK, changes)
- }
- func getContainersTop(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- if version.LessThan("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")
- }
- if err := parseForm(r); err != nil {
- return err
- }
- job := eng.Job("top", vars["name"], r.Form.Get("ps_args"))
- streamJSON(job, w, false)
- return job.Run()
- }
- func getContainersJSON(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- var err error
- if err = parseForm(r); err != nil {
- return err
- }
- config := &daemon.ContainersConfig{
- All: toBool(r.Form.Get("all")),
- Size: toBool(r.Form.Get("size")),
- Since: r.Form.Get("since"),
- Before: r.Form.Get("before"),
- Filters: r.Form.Get("filters"),
- }
- if tmpLimit := r.Form.Get("limit"); tmpLimit != "" {
- config.Limit, err = strconv.Atoi(tmpLimit)
- if err != nil {
- return err
- }
- }
- containers, err := getDaemon(eng).Containers(config)
- if err != nil {
- return err
- }
- return writeJSON(w, http.StatusOK, containers)
- }
- 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()
- }
- 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 (
- inspectJob = eng.Job("container_inspect", vars["name"])
- logsJob = eng.Job("logs", vars["name"])
- c, err = inspectJob.Stdout.AddEnv()
- )
- if err != nil {
- return err
- }
- logsJob.Setenv("follow", r.Form.Get("follow"))
- logsJob.Setenv("tail", r.Form.Get("tail"))
- 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 {
- 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") {
- errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
- outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
- } else {
- errStream = outStream
- }
- logsJob.Stdout.Add(outStream)
- logsJob.Stderr.Set(errStream)
- if err := logsJob.Run(); err != nil {
- fmt.Fprintf(outStream, "Error running logs job: %s\n", err)
- }
- return nil
- }
- func postImagesTag(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")
- }
- job := eng.Job("tag", vars["name"], r.Form.Get("repo"), r.Form.Get("tag"))
- job.Setenv("force", r.Form.Get("force"))
- if err := job.Run(); err != nil {
- return err
- }
- w.WriteHeader(http.StatusCreated)
- return nil
- }
- func postCommit(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
- }
- var (
- config engine.Env
- job = eng.Job("commit", r.Form.Get("container"))
- stdoutBuffer = bytes.NewBuffer(nil)
- )
- if err := checkForJson(r); err != nil {
- return err
- }
- if err := config.Decode(r.Body); err != nil {
- logrus.Errorf("%s", err)
- }
- if r.FormValue("pause") == "" && version.GreaterThanOrEqualTo("1.13") {
- job.Setenv("pause", "1")
- } else {
- job.Setenv("pause", r.FormValue("pause"))
- }
- 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"))
- job.SetenvList("changes", r.Form["changes"])
- job.SetenvSubEnv("config", &config)
- job.Stdout.Add(stdoutBuffer)
- if err := job.Run(); err != nil {
- return err
- }
- return writeJSON(w, http.StatusCreated, &types.ContainerCommitResponse{
- ID: engine.Tail(stdoutBuffer, 1),
- })
- }
- // Creates an image from Pull or from Import
- func postImagesCreate(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
- }
- var (
- image = r.Form.Get("fromImage")
- repo = r.Form.Get("repo")
- tag = r.Form.Get("tag")
- job *engine.Job
- )
- authEncoded := r.Header.Get("X-Registry-Auth")
- authConfig := ®istry.AuthConfig{}
- 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 = ®istry.AuthConfig{}
- }
- }
- if image != "" { //pull
- if tag == "" {
- image, tag = parsers.ParseRepositoryTag(image)
- }
- metaHeaders := map[string][]string{}
- for k, v := range r.Header {
- if strings.HasPrefix(k, "X-Meta-") {
- metaHeaders[k] = v
- }
- }
- job = eng.Job("pull", image, tag)
- job.SetenvBool("parallel", version.GreaterThan("1.3"))
- job.SetenvJson("metaHeaders", metaHeaders)
- job.SetenvJson("authConfig", authConfig)
- } else { //import
- if tag == "" {
- repo, tag = parsers.ParseRepositoryTag(repo)
- }
- job = eng.Job("import", r.Form.Get("fromSrc"), repo, tag)
- job.Stdin.Add(r.Body)
- job.SetenvList("changes", r.Form["changes"])
- }
- if version.GreaterThan("1.0") {
- job.SetenvBool("json", true)
- streamJSON(job, w, true)
- } else {
- job.Stdout.Add(utils.NewWriteFlusher(w))
- }
- if err := job.Run(); err != nil {
- if !job.Stdout.Used() {
- return err
- }
- sf := streamformatter.NewStreamFormatter(version.GreaterThan("1.0"))
- w.Write(sf.FormatError(err))
- }
- return nil
- }
- func getImagesSearch(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
- }
- var (
- config *registry.AuthConfig
- authEncoded = r.Header.Get("X-Registry-Auth")
- headers = map[string][]string{}
- )
- if authEncoded != "" {
- authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
- if err := json.NewDecoder(authJson).Decode(&config); 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
- config = ®istry.AuthConfig{}
- }
- }
- for k, v := range r.Header {
- if strings.HasPrefix(k, "X-Meta-") {
- headers[k] = v
- }
- }
- d := getDaemon(eng)
- query, err := d.RegistryService.Search(r.Form.Get("term"), config, headers)
- if err != nil {
- return err
- }
- return json.NewEncoder(w).Encode(query.Results)
- }
- func postImagesPush(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")
- }
- metaHeaders := map[string][]string{}
- for k, v := range r.Header {
- if strings.HasPrefix(k, "X-Meta-") {
- metaHeaders[k] = v
- }
- }
- if err := parseForm(r); err != nil {
- return err
- }
- authConfig := ®istry.AuthConfig{}
- 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 = ®istry.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 fmt.Errorf("Bad parameters and missing X-Registry-Auth: %v", err)
- }
- }
- job := eng.Job("push", vars["name"])
- job.SetenvJson("metaHeaders", metaHeaders)
- job.SetenvJson("authConfig", authConfig)
- job.Setenv("tag", r.Form.Get("tag"))
- if version.GreaterThan("1.0") {
- job.SetenvBool("json", true)
- streamJSON(job, w, true)
- } else {
- job.Stdout.Add(utils.NewWriteFlusher(w))
- }
- if err := job.Run(); err != nil {
- if !job.Stdout.Used() {
- return err
- }
- sf := streamformatter.NewStreamFormatter(version.GreaterThan("1.0"))
- w.Write(sf.FormatError(err))
- }
- return nil
- }
- func getImagesGet(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
- }
- if version.GreaterThan("1.0") {
- w.Header().Set("Content-Type", "application/x-tar")
- }
- 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"]...)
- }
- job.Stdout.Add(w)
- return job.Run()
- }
- func postImagesLoad(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- job := eng.Job("load")
- job.Stdin.Add(r.Body)
- job.Stdout.Add(w)
- return job.Run()
- }
- func postContainersCreate(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
- }
- if err := checkForJson(r); err != nil {
- return err
- }
- var (
- job = eng.Job("create", r.Form.Get("name"))
- outWarnings []string
- stdoutBuffer = bytes.NewBuffer(nil)
- warnings = bytes.NewBuffer(nil)
- )
- if err := job.DecodeEnv(r.Body); err != nil {
- return err
- }
- // Read container ID from the first line of stdout
- job.Stdout.Add(stdoutBuffer)
- // Read warnings from stderr
- job.Stderr.Add(warnings)
- if err := job.Run(); err != nil {
- return err
- }
- // Parse warnings from stderr
- scanner := bufio.NewScanner(warnings)
- for scanner.Scan() {
- outWarnings = append(outWarnings, scanner.Text())
- }
- return writeJSON(w, http.StatusCreated, &types.ContainerCreateResponse{
- ID: engine.Tail(stdoutBuffer, 1),
- Warnings: outWarnings,
- })
- }
- func postContainersRestart(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")
- }
- job := eng.Job("restart", vars["name"])
- job.Setenv("t", r.Form.Get("t"))
- if err := job.Run(); err != nil {
- return err
- }
- w.WriteHeader(http.StatusNoContent)
- return nil
- }
- 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")
- }
- d := getDaemon(eng)
- name := vars["name"]
- newName := r.Form.Get("name")
- if err := d.ContainerRename(name, newName); err != nil {
- return err
- }
- w.WriteHeader(http.StatusNoContent)
- return nil
- }
- func deleteContainers(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")
- }
- job := eng.Job("rm", vars["name"])
- job.Setenv("forceRemove", r.Form.Get("force"))
- job.Setenv("removeVolume", r.Form.Get("v"))
- job.Setenv("removeLink", r.Form.Get("link"))
- if err := job.Run(); err != nil {
- return err
- }
- w.WriteHeader(http.StatusNoContent)
- return nil
- }
- func deleteImages(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")
- }
- d := getDaemon(eng)
- name := vars["name"]
- force := toBool(r.Form.Get("force"))
- noprune := toBool(r.Form.Get("noprune"))
- list, err := d.ImageDelete(name, force, noprune)
- if err != nil {
- return err
- }
- return writeJSON(w, http.StatusOK, list)
- }
- func postContainersStart(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")
- }
- var (
- name = vars["name"]
- job = eng.Job("start", name)
- )
- // 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
- // allow a nil body for backwards compatibility
- if r.Body != nil && (r.ContentLength > 0 || r.ContentLength == -1) {
- if err := checkForJson(r); err != nil {
- return err
- }
- if err := job.DecodeEnv(r.Body); err != nil {
- return err
- }
- }
- if err := job.Run(); err != nil {
- if err.Error() == "Container already started" {
- w.WriteHeader(http.StatusNotModified)
- return nil
- }
- return err
- }
- w.WriteHeader(http.StatusNoContent)
- return nil
- }
- func postContainersStop(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")
- }
- job := eng.Job("stop", vars["name"])
- job.Setenv("t", r.Form.Get("t"))
- if err := job.Run(); err != nil {
- if err.Error() == "Container already stopped" {
- w.WriteHeader(http.StatusNotModified)
- return nil
- }
- return err
- }
- w.WriteHeader(http.StatusNoContent)
- return nil
- }
- func postContainersWait(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")
- }
- var (
- stdoutBuffer = bytes.NewBuffer(nil)
- job = eng.Job("wait", vars["name"])
- )
- job.Stdout.Add(stdoutBuffer)
- if err := job.Run(); err != nil {
- return err
- }
- statusCode, err := strconv.Atoi(engine.Tail(stdoutBuffer, 1))
- if err != nil {
- return err
- }
- return writeJSON(w, http.StatusOK, &types.ContainerWaitResponse{
- StatusCode: statusCode,
- })
- }
- func postContainersResize(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("resize", vars["name"], r.Form.Get("h"), r.Form.Get("w")).Run(); err != nil {
- return err
- }
- return nil
- }
- func postContainersAttach(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")
- }
- d := getDaemon(eng)
- cont, err := d.Get(vars["name"])
- if err != nil {
- return err
- }
- inStream, outStream, err := hijackServer(w)
- if err != nil {
- return err
- }
- defer closeStreams(inStream, outStream)
- var errStream io.Writer
- 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")
- }
- if !cont.Config.Tty && version.GreaterThanOrEqualTo("1.6") {
- errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
- outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
- } else {
- errStream = outStream
- }
- logs := r.Form.Get("logs") != ""
- stream := r.Form.Get("stream") != ""
- if err := cont.AttachWithLogs(inStream, outStream, errStream, logs, stream); err != nil {
- fmt.Fprintf(outStream, "Error attaching: %s\n", err)
- }
- return nil
- }
- func wsContainersAttach(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")
- }
- d := getDaemon(eng)
- cont, err := d.Get(vars["name"])
- if err != nil {
- return err
- }
- h := websocket.Handler(func(ws *websocket.Conn) {
- defer ws.Close()
- logs := r.Form.Get("logs") != ""
- stream := r.Form.Get("stream") != ""
- if err := cont.AttachWithLogs(ws, ws, ws, logs, stream); err != nil {
- logrus.Errorf("Error attaching websocket: %s", err)
- }
- })
- h.ServeHTTP(w, r)
- return nil
- }
- func getContainersByName(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")
- }
- var job = eng.Job("container_inspect", vars["name"])
- if version.LessThan("1.12") {
- job.SetenvBool("raw", true)
- }
- streamJSON(job, w, false)
- return job.Run()
- }
- 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()
- }
- func getImagesByName(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")
- }
- var job = eng.Job("image_inspect", vars["name"])
- if version.LessThan("1.12") {
- job.SetenvBool("raw", true)
- }
- streamJSON(job, w, false)
- return job.Run()
- }
- func postBuild(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- if version.LessThan("1.3") {
- return fmt.Errorf("Multipart upload for build is no longer supported. Please upgrade your docker client.")
- }
- var (
- authEncoded = r.Header.Get("X-Registry-Auth")
- authConfig = ®istry.AuthConfig{}
- configFileEncoded = r.Header.Get("X-Registry-Config")
- configFile = ®istry.ConfigFile{}
- job = eng.Job("build")
- )
- // 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.
- if version.LessThan("1.9") && 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 = ®istry.AuthConfig{}
- }
- }
- 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
- configFile = ®istry.ConfigFile{}
- }
- }
- if version.GreaterThanOrEqualTo("1.8") {
- job.SetenvBool("json", true)
- streamJSON(job, w, true)
- } else {
- job.Stdout.Add(utils.NewWriteFlusher(w))
- }
- if toBool(r.FormValue("forcerm")) && version.GreaterThanOrEqualTo("1.12") {
- job.Setenv("rm", "1")
- } else if r.FormValue("rm") == "" && version.GreaterThanOrEqualTo("1.12") {
- job.Setenv("rm", "1")
- } else {
- job.Setenv("rm", r.FormValue("rm"))
- }
- if toBool(r.FormValue("pull")) && version.GreaterThanOrEqualTo("1.16") {
- job.Setenv("pull", "1")
- }
- job.Stdin.Add(r.Body)
- job.Setenv("remote", r.FormValue("remote"))
- job.Setenv("dockerfile", r.FormValue("dockerfile"))
- job.Setenv("t", r.FormValue("t"))
- job.Setenv("q", r.FormValue("q"))
- job.Setenv("nocache", r.FormValue("nocache"))
- job.Setenv("forcerm", r.FormValue("forcerm"))
- job.SetenvJson("authConfig", authConfig)
- job.SetenvJson("configFile", configFile)
- job.Setenv("memswap", r.FormValue("memswap"))
- job.Setenv("memory", r.FormValue("memory"))
- job.Setenv("cpusetcpus", r.FormValue("cpusetcpus"))
- job.Setenv("cpushares", r.FormValue("cpushares"))
- // Job cancellation. Note: not all job types support this.
- if closeNotifier, ok := w.(http.CloseNotifier); ok {
- finished := make(chan struct{})
- defer close(finished)
- go func() {
- select {
- case <-finished:
- case <-closeNotifier.CloseNotify():
- logrus.Infof("Client disconnected, cancelling job: %s", job.Name)
- job.Cancel()
- }
- }()
- }
- if err := job.Run(); err != nil {
- if !job.Stdout.Used() {
- return err
- }
- sf := streamformatter.NewStreamFormatter(version.GreaterThanOrEqualTo("1.8"))
- w.Write(sf.FormatError(err))
- }
- return nil
- }
- func postContainersCopy(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")
- }
- var copyData engine.Env
- if err := checkForJson(r); err != nil {
- return err
- }
- if err := copyData.Decode(r.Body); err != nil {
- return err
- }
- if copyData.Get("Resource") == "" {
- return fmt.Errorf("Path cannot be empty")
- }
- origResource := copyData.Get("Resource")
- if copyData.Get("Resource")[0] == '/' {
- copyData.Set("Resource", copyData.Get("Resource")[1:])
- }
- job := eng.Job("container_copy", vars["name"], copyData.Get("Resource"))
- job.Stdout.Add(w)
- w.Header().Set("Content-Type", "application/x-tar")
- if err := job.Run(); err != nil {
- logrus.Errorf("%v", err)
- if strings.Contains(strings.ToLower(err.Error()), "no such id") {
- w.WriteHeader(http.StatusNotFound)
- } 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"])
- }
- }
- return nil
- }
- func postContainerExecCreate(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("execCreate", name)
- stdoutBuffer = bytes.NewBuffer(nil)
- outWarnings []string
- warnings = bytes.NewBuffer(nil)
- )
- if err := job.DecodeEnv(r.Body); err != nil {
- return err
- }
- job.Stdout.Add(stdoutBuffer)
- // Read warnings from stderr
- job.Stderr.Add(warnings)
- // 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
- }
- // Parse warnings from stderr
- scanner := bufio.NewScanner(warnings)
- for scanner.Scan() {
- outWarnings = append(outWarnings, scanner.Text())
- }
- return writeJSON(w, http.StatusCreated, &types.ContainerExecCreateResponse{
- ID: engine.Tail(stdoutBuffer, 1),
- Warnings: outWarnings,
- })
- }
- // TODO(vishh): Refactor the code to avoid having to specify stream config as part of both create and start.
- 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
- )
- 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
- }
- defer closeStreams(inStream, outStream)
- var errStream io.Writer
- 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")
- }
- if !job.GetenvBool("Tty") && version.GreaterThanOrEqualTo("1.6") {
- errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
- outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
- } else {
- errStream = outStream
- }
- job.Stdin.Add(inStream)
- job.Stdout.Add(outStream)
- job.Stderr.Set(errStream)
- errOut = outStream
- }
- // Now run the user process in container.
- job.SetCloseIO(false)
- if err := job.Run(); err != nil {
- fmt.Fprintf(errOut, "Error starting exec command in container %s: %s\n", name, err)
- return err
- }
- w.WriteHeader(http.StatusNoContent)
- return nil
- }
- 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
- }
- func optionsHandler(eng *engine.Engine, version version.Version, 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, corsHeaders string) {
- logrus.Debugf("CORS header is enabled and set to: %s", corsHeaders)
- w.Header().Add("Access-Control-Allow-Origin", corsHeaders)
- w.Header().Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, X-Registry-Auth")
- w.Header().Add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS")
- }
- func ping(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
- _, err := w.Write([]byte{'O', 'K'})
- return err
- }
- func makeHttpHandler(eng *engine.Engine, logging bool, localMethod string, localRoute string, handlerFunc HttpApiFunc, corsHeaders string, dockerVersion version.Version) http.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) {
- // log the request
- logrus.Debugf("Calling %s %s", localMethod, localRoute)
- if logging {
- logrus.Infof("%s %s", 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 && !dockerVersion.Equal(version.Version(userAgent[1])) {
- logrus.Debugf("Warning: client and server don't have the same version (client: %s, server: %s)", userAgent[1], dockerVersion)
- }
- }
- version := version.Version(mux.Vars(r)["version"])
- if version == "" {
- version = api.APIVERSION
- }
- if corsHeaders != "" {
- writeCorsHeaders(w, r, corsHeaders)
- }
- if version.GreaterThan(api.APIVERSION) {
- http.Error(w, fmt.Errorf("client and server don't have same version (client API version: %s, server API version: %s)", version, api.APIVERSION).Error(), http.StatusNotFound)
- return
- }
- if err := handlerFunc(eng, version, w, r, mux.Vars(r)); err != nil {
- logrus.Errorf("Handler for %s %s returned error: %s", localMethod, localRoute, err)
- httpError(w, err)
- }
- }
- }
- // we keep enableCors just for legacy usage, need to be removed in the future
- func createRouter(eng *engine.Engine, logging, enableCors bool, corsHeaders string, dockerVersion string) *mux.Router {
- r := mux.NewRouter()
- if os.Getenv("DEBUG") != "" {
- ProfilerSetup(r, "/debug/")
- }
- m := map[string]map[string]HttpApiFunc{
- "GET": {
- "/_ping": ping,
- "/events": getEvents,
- "/info": getInfo,
- "/version": getVersion,
- "/images/json": getImagesJSON,
- "/images/viz": getImagesViz,
- "/images/search": getImagesSearch,
- "/images/get": getImagesGet,
- "/images/{name:.*}/get": getImagesGet,
- "/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:.*}/logs": getContainersLogs,
- "/containers/{name:.*}/stats": getContainersStats,
- "/containers/{name:.*}/attach/ws": wsContainersAttach,
- "/exec/{id:.*}/json": getExecByID,
- },
- "POST": {
- "/auth": postAuth,
- "/commit": postCommit,
- "/build": postBuild,
- "/images/create": postImagesCreate,
- "/images/load": postImagesLoad,
- "/images/{name:.*}/push": postImagesPush,
- "/images/{name:.*}/tag": postImagesTag,
- "/containers/create": postContainersCreate,
- "/containers/{name:.*}/kill": postContainersKill,
- "/containers/{name:.*}/pause": postContainersPause,
- "/containers/{name:.*}/unpause": postContainersUnpause,
- "/containers/{name:.*}/restart": postContainersRestart,
- "/containers/{name:.*}/start": postContainersStart,
- "/containers/{name:.*}/stop": postContainersStop,
- "/containers/{name:.*}/wait": postContainersWait,
- "/containers/{name:.*}/resize": postContainersResize,
- "/containers/{name:.*}/attach": postContainersAttach,
- "/containers/{name:.*}/copy": postContainersCopy,
- "/containers/{name:.*}/exec": postContainerExecCreate,
- "/exec/{name:.*}/start": postContainerExecStart,
- "/exec/{name:.*}/resize": postContainerExecResize,
- "/containers/{name:.*}/rename": postContainerRename,
- },
- "DELETE": {
- "/containers/{name:.*}": deleteContainers,
- "/images/{name:.*}": deleteImages,
- },
- "OPTIONS": {
- "": optionsHandler,
- },
- }
- // If "api-cors-header" is not given, but "api-enable-cors" is true, we set cors to "*"
- // otherwise, all head values will be passed to HTTP handler
- if corsHeaders == "" && enableCors {
- corsHeaders = "*"
- }
- for method, routes := range m {
- for route, fct := range routes {
- logrus.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
- // build the handler function
- f := makeHttpHandler(eng, logging, localMethod, localRoute, localFct, corsHeaders, version.Version(dockerVersion))
- // 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
- }
- // 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.
- func ServeRequest(eng *engine.Engine, apiversion version.Version, w http.ResponseWriter, req *http.Request) {
- router := createRouter(eng, false, true, "", "")
- // Insert APIVERSION into the request as a convenience
- req.URL.Path = fmt.Sprintf("/v%s%s", apiversion, req.URL.Path)
- router.ServeHTTP(w, req)
- }
- 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 := bridge.RequestPort(hostIP, "tcp", intPort); err != nil {
- return fmt.Errorf("failed to allocate daemon listening port %d (err: %v)", intPort, err)
- }
- }
- return nil
- }
- type Server interface {
- Serve() error
- Close() error
- }
- // 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) error {
- if len(job.Args) == 0 {
- return fmt.Errorf("usage: %s PROTO://ADDR [PROTO://ADDR ...]", job.Name)
- }
- var (
- protoAddrs = job.Args
- chErrors = make(chan error, len(protoAddrs))
- )
- for _, protoAddr := range protoAddrs {
- protoAddrParts := strings.SplitN(protoAddr, "://", 2)
- if len(protoAddrParts) != 2 {
- return fmt.Errorf("usage: %s PROTO://ADDR [PROTO://ADDR ...]", job.Name)
- }
- go func() {
- logrus.Infof("Listening for HTTP on %s (%s)", protoAddrParts[0], protoAddrParts[1])
- srv, err := NewServer(protoAddrParts[0], protoAddrParts[1], job)
- if err != nil {
- chErrors <- err
- return
- }
- job.Eng.OnShutdown(func() {
- if err := srv.Close(); err != nil {
- logrus.Error(err)
- }
- })
- if err = srv.Serve(); err != nil && strings.Contains(err.Error(), "use of closed network connection") {
- err = nil
- }
- chErrors <- err
- }()
- }
- for i := 0; i < len(protoAddrs); i++ {
- err := <-chErrors
- if err != nil {
- return err
- }
- }
- return nil
- }
- func toBool(s string) bool {
- s = strings.ToLower(strings.TrimSpace(s))
- return !(s == "" || s == "0" || s == "no" || s == "false" || s == "none")
- }
|