server.go 44 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552
  1. package server
  2. import (
  3. "bufio"
  4. "bytes"
  5. "time"
  6. "encoding/base64"
  7. "encoding/json"
  8. "fmt"
  9. "io"
  10. "net"
  11. "net/http"
  12. "os"
  13. "strconv"
  14. "strings"
  15. "code.google.com/p/go.net/websocket"
  16. "github.com/gorilla/mux"
  17. "github.com/Sirupsen/logrus"
  18. "github.com/docker/docker/api"
  19. "github.com/docker/docker/api/types"
  20. "github.com/docker/docker/daemon"
  21. "github.com/docker/docker/daemon/networkdriver/bridge"
  22. "github.com/docker/docker/engine"
  23. "github.com/docker/docker/graph"
  24. "github.com/docker/docker/pkg/jsonmessage"
  25. "github.com/docker/docker/pkg/parsers"
  26. "github.com/docker/docker/pkg/parsers/filters"
  27. "github.com/docker/docker/pkg/stdcopy"
  28. "github.com/docker/docker/pkg/streamformatter"
  29. "github.com/docker/docker/pkg/version"
  30. "github.com/docker/docker/registry"
  31. "github.com/docker/docker/utils"
  32. )
  33. var (
  34. activationLock = make(chan struct{})
  35. )
  36. type HttpServer struct {
  37. srv *http.Server
  38. l net.Listener
  39. }
  40. func (s *HttpServer) Serve() error {
  41. return s.srv.Serve(s.l)
  42. }
  43. func (s *HttpServer) Close() error {
  44. return s.l.Close()
  45. }
  46. type HttpApiFunc func(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error
  47. func hijackServer(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {
  48. conn, _, err := w.(http.Hijacker).Hijack()
  49. if err != nil {
  50. return nil, nil, err
  51. }
  52. // Flush the options to make sure the client sets the raw mode
  53. conn.Write([]byte{})
  54. return conn, conn, nil
  55. }
  56. func closeStreams(streams ...interface{}) {
  57. for _, stream := range streams {
  58. if tcpc, ok := stream.(interface {
  59. CloseWrite() error
  60. }); ok {
  61. tcpc.CloseWrite()
  62. } else if closer, ok := stream.(io.Closer); ok {
  63. closer.Close()
  64. }
  65. }
  66. }
  67. // Check to make sure request's Content-Type is application/json
  68. func checkForJson(r *http.Request) error {
  69. ct := r.Header.Get("Content-Type")
  70. // No Content-Type header is ok as long as there's no Body
  71. if ct == "" {
  72. if r.Body == nil || r.ContentLength == 0 {
  73. return nil
  74. }
  75. }
  76. // Otherwise it better be json
  77. if api.MatchesContentType(ct, "application/json") {
  78. return nil
  79. }
  80. return fmt.Errorf("Content-Type specified (%s) must be 'application/json'", ct)
  81. }
  82. //If we don't do this, POST method without Content-type (even with empty body) will fail
  83. func parseForm(r *http.Request) error {
  84. if r == nil {
  85. return nil
  86. }
  87. if err := r.ParseForm(); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
  88. return err
  89. }
  90. return nil
  91. }
  92. func parseMultipartForm(r *http.Request) error {
  93. if err := r.ParseMultipartForm(4096); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
  94. return err
  95. }
  96. return nil
  97. }
  98. func httpError(w http.ResponseWriter, err error) {
  99. statusCode := http.StatusInternalServerError
  100. // FIXME: this is brittle and should not be necessary.
  101. // If we need to differentiate between different possible error types, we should
  102. // create appropriate error types with clearly defined meaning.
  103. errStr := strings.ToLower(err.Error())
  104. if strings.Contains(errStr, "no such") {
  105. statusCode = http.StatusNotFound
  106. } else if strings.Contains(errStr, "bad parameter") {
  107. statusCode = http.StatusBadRequest
  108. } else if strings.Contains(errStr, "conflict") {
  109. statusCode = http.StatusConflict
  110. } else if strings.Contains(errStr, "impossible") {
  111. statusCode = http.StatusNotAcceptable
  112. } else if strings.Contains(errStr, "wrong login/password") {
  113. statusCode = http.StatusUnauthorized
  114. } else if strings.Contains(errStr, "hasn't been activated") {
  115. statusCode = http.StatusForbidden
  116. }
  117. if err != nil {
  118. logrus.Errorf("HTTP Error: statusCode=%d %v", statusCode, err)
  119. http.Error(w, err.Error(), statusCode)
  120. }
  121. }
  122. // writeJSONEnv writes the engine.Env values to the http response stream as a
  123. // json encoded body.
  124. func writeJSONEnv(w http.ResponseWriter, code int, v engine.Env) error {
  125. w.Header().Set("Content-Type", "application/json")
  126. w.WriteHeader(code)
  127. return v.Encode(w)
  128. }
  129. // writeJSON writes the value v to the http response stream as json with standard
  130. // json encoding.
  131. func writeJSON(w http.ResponseWriter, code int, v interface{}) error {
  132. w.Header().Set("Content-Type", "application/json")
  133. w.WriteHeader(code)
  134. return json.NewEncoder(w).Encode(v)
  135. }
  136. func streamJSON(job *engine.Job, w http.ResponseWriter, flush bool) {
  137. w.Header().Set("Content-Type", "application/json")
  138. if flush {
  139. job.Stdout.Add(utils.NewWriteFlusher(w))
  140. } else {
  141. job.Stdout.Add(w)
  142. }
  143. }
  144. func getDaemon(eng *engine.Engine) *daemon.Daemon {
  145. return eng.HackGetGlobalVar("httpapi.daemon").(*daemon.Daemon)
  146. }
  147. func postAuth(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  148. var config *registry.AuthConfig
  149. err := json.NewDecoder(r.Body).Decode(&config)
  150. r.Body.Close()
  151. if err != nil {
  152. return err
  153. }
  154. d := getDaemon(eng)
  155. status, err := d.RegistryService.Auth(config)
  156. if err != nil {
  157. return err
  158. }
  159. return writeJSON(w, http.StatusOK, &types.AuthResponse{
  160. Status: status,
  161. })
  162. }
  163. func getVersion(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  164. w.Header().Set("Content-Type", "application/json")
  165. eng.ServeHTTP(w, r)
  166. return nil
  167. }
  168. func postContainersKill(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  169. if vars == nil {
  170. return fmt.Errorf("Missing parameter")
  171. }
  172. if err := parseForm(r); err != nil {
  173. return err
  174. }
  175. job := eng.Job("kill", vars["name"])
  176. if sig := r.Form.Get("signal"); sig != "" {
  177. job.Args = append(job.Args, sig)
  178. }
  179. if err := job.Run(); err != nil {
  180. return err
  181. }
  182. w.WriteHeader(http.StatusNoContent)
  183. return nil
  184. }
  185. func postContainersPause(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  186. if vars == nil {
  187. return fmt.Errorf("Missing parameter")
  188. }
  189. if err := parseForm(r); err != nil {
  190. return err
  191. }
  192. job := eng.Job("pause", vars["name"])
  193. if err := job.Run(); err != nil {
  194. return err
  195. }
  196. w.WriteHeader(http.StatusNoContent)
  197. return nil
  198. }
  199. func postContainersUnpause(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  200. if vars == nil {
  201. return fmt.Errorf("Missing parameter")
  202. }
  203. if err := parseForm(r); err != nil {
  204. return err
  205. }
  206. job := eng.Job("unpause", vars["name"])
  207. if err := job.Run(); err != nil {
  208. return err
  209. }
  210. w.WriteHeader(http.StatusNoContent)
  211. return nil
  212. }
  213. func getContainersExport(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  214. if vars == nil {
  215. return fmt.Errorf("Missing parameter")
  216. }
  217. job := eng.Job("export", vars["name"])
  218. job.Stdout.Add(w)
  219. if err := job.Run(); err != nil {
  220. return err
  221. }
  222. return nil
  223. }
  224. func getImagesJSON(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  225. if err := parseForm(r); err != nil {
  226. return err
  227. }
  228. imagesConfig := graph.ImagesConfig{
  229. Filters: r.Form.Get("filters"),
  230. // FIXME this parameter could just be a match filter
  231. Filter: r.Form.Get("filter"),
  232. All: toBool(r.Form.Get("all")),
  233. }
  234. images, err := getDaemon(eng).Repositories().Images(&imagesConfig)
  235. if err != nil {
  236. return err
  237. }
  238. if version.GreaterThanOrEqualTo("1.7") {
  239. return writeJSON(w, http.StatusOK, images)
  240. }
  241. legacyImages := []types.LegacyImage{}
  242. for _, image := range images {
  243. for _, repoTag := range image.RepoTags {
  244. repo, tag := parsers.ParseRepositoryTag(repoTag)
  245. legacyImage := types.LegacyImage{
  246. Repository: repo,
  247. Tag: tag,
  248. ID: image.ID,
  249. Created: image.Created,
  250. Size: image.Size,
  251. VirtualSize: image.VirtualSize,
  252. }
  253. legacyImages = append(legacyImages, legacyImage)
  254. }
  255. }
  256. return writeJSON(w, http.StatusOK, legacyImages)
  257. }
  258. func getImagesViz(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  259. if version.GreaterThan("1.6") {
  260. w.WriteHeader(http.StatusNotFound)
  261. return fmt.Errorf("This is now implemented in the client.")
  262. }
  263. eng.ServeHTTP(w, r)
  264. return nil
  265. }
  266. func getInfo(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  267. w.Header().Set("Content-Type", "application/json")
  268. eng.ServeHTTP(w, r)
  269. return nil
  270. }
  271. func getEvents(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  272. if err := parseForm(r); err != nil {
  273. return err
  274. }
  275. var since int64 = -1
  276. if r.Form.Get("since") != "" {
  277. s, err := strconv.ParseInt(r.Form.Get("since"), 10, 64)
  278. if err != nil {
  279. return err
  280. }
  281. since = s
  282. }
  283. var until int64 = -1
  284. if r.Form.Get("until") != "" {
  285. u, err := strconv.ParseInt(r.Form.Get("until"), 10, 64)
  286. if err != nil {
  287. return err
  288. }
  289. until = u
  290. }
  291. timer := time.NewTimer(0)
  292. timer.Stop()
  293. if until > 0 {
  294. dur := time.Unix(until, 0).Sub(time.Now())
  295. timer = time.NewTimer(dur)
  296. }
  297. ef, err := filters.FromParam(r.Form.Get("filters"))
  298. if err != nil {
  299. return err
  300. }
  301. isFiltered := func(field string, filter []string) bool {
  302. if len(filter) == 0 {
  303. return false
  304. }
  305. for _, v := range filter {
  306. if v == field {
  307. return false
  308. }
  309. if strings.Contains(field, ":") {
  310. image := strings.Split(field, ":")
  311. if image[0] == v {
  312. return false
  313. }
  314. }
  315. }
  316. return true
  317. }
  318. d := getDaemon(eng)
  319. es := d.EventsService
  320. w.Header().Set("Content-Type", "application/json")
  321. enc := json.NewEncoder(utils.NewWriteFlusher(w))
  322. getContainerId := func(cn string) string {
  323. c, err := d.Get(cn)
  324. if err != nil {
  325. return ""
  326. }
  327. return c.ID
  328. }
  329. sendEvent := func(ev *jsonmessage.JSONMessage) error {
  330. //incoming container filter can be name,id or partial id, convert and replace as a full container id
  331. for i, cn := range ef["container"] {
  332. ef["container"][i] = getContainerId(cn)
  333. }
  334. if isFiltered(ev.Status, ef["event"]) || isFiltered(ev.From, ef["image"]) ||
  335. isFiltered(ev.ID, ef["container"]) {
  336. return nil
  337. }
  338. return enc.Encode(ev)
  339. }
  340. current, l := es.Subscribe()
  341. defer es.Evict(l)
  342. for _, ev := range current {
  343. if ev.Time < since {
  344. continue
  345. }
  346. if err := sendEvent(ev); err != nil {
  347. return err
  348. }
  349. }
  350. for {
  351. select {
  352. case ev := <-l:
  353. jev, ok := ev.(*jsonmessage.JSONMessage)
  354. if !ok {
  355. continue
  356. }
  357. if err := sendEvent(jev); err != nil {
  358. return err
  359. }
  360. case <-timer.C:
  361. return nil
  362. }
  363. }
  364. }
  365. func getImagesHistory(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  366. if vars == nil {
  367. return fmt.Errorf("Missing parameter")
  368. }
  369. var job = eng.Job("history", vars["name"])
  370. streamJSON(job, w, false)
  371. if err := job.Run(); err != nil {
  372. return err
  373. }
  374. return nil
  375. }
  376. func getContainersChanges(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  377. if vars == nil {
  378. return fmt.Errorf("Missing parameter")
  379. }
  380. name := vars["name"]
  381. if name == "" {
  382. return fmt.Errorf("Container name cannot be empty")
  383. }
  384. d := getDaemon(eng)
  385. cont, err := d.Get(name)
  386. if err != nil {
  387. return err
  388. }
  389. changes, err := cont.Changes()
  390. if err != nil {
  391. return err
  392. }
  393. return writeJSON(w, http.StatusOK, changes)
  394. }
  395. func getContainersTop(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  396. if version.LessThan("1.4") {
  397. return fmt.Errorf("top was improved a lot since 1.3, Please upgrade your docker client.")
  398. }
  399. if vars == nil {
  400. return fmt.Errorf("Missing parameter")
  401. }
  402. if err := parseForm(r); err != nil {
  403. return err
  404. }
  405. job := eng.Job("top", vars["name"], r.Form.Get("ps_args"))
  406. streamJSON(job, w, false)
  407. return job.Run()
  408. }
  409. func getContainersJSON(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  410. var err error
  411. if err = parseForm(r); err != nil {
  412. return err
  413. }
  414. config := &daemon.ContainersConfig{
  415. All: toBool(r.Form.Get("all")),
  416. Size: toBool(r.Form.Get("size")),
  417. Since: r.Form.Get("since"),
  418. Before: r.Form.Get("before"),
  419. Filters: r.Form.Get("filters"),
  420. }
  421. if tmpLimit := r.Form.Get("limit"); tmpLimit != "" {
  422. config.Limit, err = strconv.Atoi(tmpLimit)
  423. if err != nil {
  424. return err
  425. }
  426. }
  427. containers, err := getDaemon(eng).Containers(config)
  428. if err != nil {
  429. return err
  430. }
  431. return writeJSON(w, http.StatusOK, containers)
  432. }
  433. func getContainersStats(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  434. if err := parseForm(r); err != nil {
  435. return err
  436. }
  437. if vars == nil {
  438. return fmt.Errorf("Missing parameter")
  439. }
  440. name := vars["name"]
  441. job := eng.Job("container_stats", name)
  442. streamJSON(job, w, true)
  443. return job.Run()
  444. }
  445. func getContainersLogs(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  446. if err := parseForm(r); err != nil {
  447. return err
  448. }
  449. if vars == nil {
  450. return fmt.Errorf("Missing parameter")
  451. }
  452. var (
  453. inspectJob = eng.Job("container_inspect", vars["name"])
  454. logsJob = eng.Job("logs", vars["name"])
  455. c, err = inspectJob.Stdout.AddEnv()
  456. )
  457. if err != nil {
  458. return err
  459. }
  460. logsJob.Setenv("follow", r.Form.Get("follow"))
  461. logsJob.Setenv("tail", r.Form.Get("tail"))
  462. logsJob.Setenv("stdout", r.Form.Get("stdout"))
  463. logsJob.Setenv("stderr", r.Form.Get("stderr"))
  464. logsJob.Setenv("timestamps", r.Form.Get("timestamps"))
  465. // Validate args here, because we can't return not StatusOK after job.Run() call
  466. stdout, stderr := logsJob.GetenvBool("stdout"), logsJob.GetenvBool("stderr")
  467. if !(stdout || stderr) {
  468. return fmt.Errorf("Bad parameters: you must choose at least one stream")
  469. }
  470. if err = inspectJob.Run(); err != nil {
  471. return err
  472. }
  473. var outStream, errStream io.Writer
  474. outStream = utils.NewWriteFlusher(w)
  475. if c.GetSubEnv("Config") != nil && !c.GetSubEnv("Config").GetBool("Tty") && version.GreaterThanOrEqualTo("1.6") {
  476. errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
  477. outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
  478. } else {
  479. errStream = outStream
  480. }
  481. logsJob.Stdout.Add(outStream)
  482. logsJob.Stderr.Set(errStream)
  483. if err := logsJob.Run(); err != nil {
  484. fmt.Fprintf(outStream, "Error running logs job: %s\n", err)
  485. }
  486. return nil
  487. }
  488. func postImagesTag(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  489. if err := parseForm(r); err != nil {
  490. return err
  491. }
  492. if vars == nil {
  493. return fmt.Errorf("Missing parameter")
  494. }
  495. job := eng.Job("tag", vars["name"], r.Form.Get("repo"), r.Form.Get("tag"))
  496. job.Setenv("force", r.Form.Get("force"))
  497. if err := job.Run(); err != nil {
  498. return err
  499. }
  500. w.WriteHeader(http.StatusCreated)
  501. return nil
  502. }
  503. func postCommit(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  504. if err := parseForm(r); err != nil {
  505. return err
  506. }
  507. var (
  508. config engine.Env
  509. job = eng.Job("commit", r.Form.Get("container"))
  510. stdoutBuffer = bytes.NewBuffer(nil)
  511. )
  512. if err := checkForJson(r); err != nil {
  513. return err
  514. }
  515. if err := config.Decode(r.Body); err != nil {
  516. logrus.Errorf("%s", err)
  517. }
  518. if r.FormValue("pause") == "" && version.GreaterThanOrEqualTo("1.13") {
  519. job.Setenv("pause", "1")
  520. } else {
  521. job.Setenv("pause", r.FormValue("pause"))
  522. }
  523. job.Setenv("repo", r.Form.Get("repo"))
  524. job.Setenv("tag", r.Form.Get("tag"))
  525. job.Setenv("author", r.Form.Get("author"))
  526. job.Setenv("comment", r.Form.Get("comment"))
  527. job.SetenvList("changes", r.Form["changes"])
  528. job.SetenvSubEnv("config", &config)
  529. job.Stdout.Add(stdoutBuffer)
  530. if err := job.Run(); err != nil {
  531. return err
  532. }
  533. return writeJSON(w, http.StatusCreated, &types.ContainerCommitResponse{
  534. ID: engine.Tail(stdoutBuffer, 1),
  535. })
  536. }
  537. // Creates an image from Pull or from Import
  538. func postImagesCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  539. if err := parseForm(r); err != nil {
  540. return err
  541. }
  542. var (
  543. image = r.Form.Get("fromImage")
  544. repo = r.Form.Get("repo")
  545. tag = r.Form.Get("tag")
  546. job *engine.Job
  547. )
  548. authEncoded := r.Header.Get("X-Registry-Auth")
  549. authConfig := &registry.AuthConfig{}
  550. if authEncoded != "" {
  551. authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
  552. if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {
  553. // for a pull it is not an error if no auth was given
  554. // to increase compatibility with the existing api it is defaulting to be empty
  555. authConfig = &registry.AuthConfig{}
  556. }
  557. }
  558. if image != "" { //pull
  559. if tag == "" {
  560. image, tag = parsers.ParseRepositoryTag(image)
  561. }
  562. metaHeaders := map[string][]string{}
  563. for k, v := range r.Header {
  564. if strings.HasPrefix(k, "X-Meta-") {
  565. metaHeaders[k] = v
  566. }
  567. }
  568. job = eng.Job("pull", image, tag)
  569. job.SetenvBool("parallel", version.GreaterThan("1.3"))
  570. job.SetenvJson("metaHeaders", metaHeaders)
  571. job.SetenvJson("authConfig", authConfig)
  572. } else { //import
  573. if tag == "" {
  574. repo, tag = parsers.ParseRepositoryTag(repo)
  575. }
  576. job = eng.Job("import", r.Form.Get("fromSrc"), repo, tag)
  577. job.Stdin.Add(r.Body)
  578. job.SetenvList("changes", r.Form["changes"])
  579. }
  580. if version.GreaterThan("1.0") {
  581. job.SetenvBool("json", true)
  582. streamJSON(job, w, true)
  583. } else {
  584. job.Stdout.Add(utils.NewWriteFlusher(w))
  585. }
  586. if err := job.Run(); err != nil {
  587. if !job.Stdout.Used() {
  588. return err
  589. }
  590. sf := streamformatter.NewStreamFormatter(version.GreaterThan("1.0"))
  591. w.Write(sf.FormatError(err))
  592. }
  593. return nil
  594. }
  595. func getImagesSearch(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  596. if err := parseForm(r); err != nil {
  597. return err
  598. }
  599. var (
  600. config *registry.AuthConfig
  601. authEncoded = r.Header.Get("X-Registry-Auth")
  602. headers = map[string][]string{}
  603. )
  604. if authEncoded != "" {
  605. authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
  606. if err := json.NewDecoder(authJson).Decode(&config); err != nil {
  607. // for a search it is not an error if no auth was given
  608. // to increase compatibility with the existing api it is defaulting to be empty
  609. config = &registry.AuthConfig{}
  610. }
  611. }
  612. for k, v := range r.Header {
  613. if strings.HasPrefix(k, "X-Meta-") {
  614. headers[k] = v
  615. }
  616. }
  617. d := getDaemon(eng)
  618. query, err := d.RegistryService.Search(r.Form.Get("term"), config, headers)
  619. if err != nil {
  620. return err
  621. }
  622. return json.NewEncoder(w).Encode(query.Results)
  623. }
  624. func postImagesPush(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  625. if vars == nil {
  626. return fmt.Errorf("Missing parameter")
  627. }
  628. metaHeaders := map[string][]string{}
  629. for k, v := range r.Header {
  630. if strings.HasPrefix(k, "X-Meta-") {
  631. metaHeaders[k] = v
  632. }
  633. }
  634. if err := parseForm(r); err != nil {
  635. return err
  636. }
  637. authConfig := &registry.AuthConfig{}
  638. authEncoded := r.Header.Get("X-Registry-Auth")
  639. if authEncoded != "" {
  640. // the new format is to handle the authConfig as a header
  641. authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
  642. if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {
  643. // to increase compatibility to existing api it is defaulting to be empty
  644. authConfig = &registry.AuthConfig{}
  645. }
  646. } else {
  647. // the old format is supported for compatibility if there was no authConfig header
  648. if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {
  649. return fmt.Errorf("Bad parameters and missing X-Registry-Auth: %v", err)
  650. }
  651. }
  652. job := eng.Job("push", vars["name"])
  653. job.SetenvJson("metaHeaders", metaHeaders)
  654. job.SetenvJson("authConfig", authConfig)
  655. job.Setenv("tag", r.Form.Get("tag"))
  656. if version.GreaterThan("1.0") {
  657. job.SetenvBool("json", true)
  658. streamJSON(job, w, true)
  659. } else {
  660. job.Stdout.Add(utils.NewWriteFlusher(w))
  661. }
  662. if err := job.Run(); err != nil {
  663. if !job.Stdout.Used() {
  664. return err
  665. }
  666. sf := streamformatter.NewStreamFormatter(version.GreaterThan("1.0"))
  667. w.Write(sf.FormatError(err))
  668. }
  669. return nil
  670. }
  671. func getImagesGet(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  672. if vars == nil {
  673. return fmt.Errorf("Missing parameter")
  674. }
  675. if err := parseForm(r); err != nil {
  676. return err
  677. }
  678. if version.GreaterThan("1.0") {
  679. w.Header().Set("Content-Type", "application/x-tar")
  680. }
  681. var job *engine.Job
  682. if name, ok := vars["name"]; ok {
  683. job = eng.Job("image_export", name)
  684. } else {
  685. job = eng.Job("image_export", r.Form["names"]...)
  686. }
  687. job.Stdout.Add(w)
  688. return job.Run()
  689. }
  690. func postImagesLoad(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  691. job := eng.Job("load")
  692. job.Stdin.Add(r.Body)
  693. job.Stdout.Add(w)
  694. return job.Run()
  695. }
  696. func postContainersCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  697. if err := parseForm(r); err != nil {
  698. return nil
  699. }
  700. if err := checkForJson(r); err != nil {
  701. return err
  702. }
  703. var (
  704. job = eng.Job("create", r.Form.Get("name"))
  705. outWarnings []string
  706. stdoutBuffer = bytes.NewBuffer(nil)
  707. warnings = bytes.NewBuffer(nil)
  708. )
  709. if err := job.DecodeEnv(r.Body); err != nil {
  710. return err
  711. }
  712. // Read container ID from the first line of stdout
  713. job.Stdout.Add(stdoutBuffer)
  714. // Read warnings from stderr
  715. job.Stderr.Add(warnings)
  716. if err := job.Run(); err != nil {
  717. return err
  718. }
  719. // Parse warnings from stderr
  720. scanner := bufio.NewScanner(warnings)
  721. for scanner.Scan() {
  722. outWarnings = append(outWarnings, scanner.Text())
  723. }
  724. return writeJSON(w, http.StatusCreated, &types.ContainerCreateResponse{
  725. ID: engine.Tail(stdoutBuffer, 1),
  726. Warnings: outWarnings,
  727. })
  728. }
  729. func postContainersRestart(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  730. if err := parseForm(r); err != nil {
  731. return err
  732. }
  733. if vars == nil {
  734. return fmt.Errorf("Missing parameter")
  735. }
  736. job := eng.Job("restart", vars["name"])
  737. job.Setenv("t", r.Form.Get("t"))
  738. if err := job.Run(); err != nil {
  739. return err
  740. }
  741. w.WriteHeader(http.StatusNoContent)
  742. return nil
  743. }
  744. func postContainerRename(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  745. if err := parseForm(r); err != nil {
  746. return err
  747. }
  748. if vars == nil {
  749. return fmt.Errorf("Missing parameter")
  750. }
  751. d := getDaemon(eng)
  752. name := vars["name"]
  753. newName := r.Form.Get("name")
  754. if err := d.ContainerRename(name, newName); err != nil {
  755. return err
  756. }
  757. w.WriteHeader(http.StatusNoContent)
  758. return nil
  759. }
  760. func deleteContainers(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  761. if err := parseForm(r); err != nil {
  762. return err
  763. }
  764. if vars == nil {
  765. return fmt.Errorf("Missing parameter")
  766. }
  767. job := eng.Job("rm", vars["name"])
  768. job.Setenv("forceRemove", r.Form.Get("force"))
  769. job.Setenv("removeVolume", r.Form.Get("v"))
  770. job.Setenv("removeLink", r.Form.Get("link"))
  771. if err := job.Run(); err != nil {
  772. return err
  773. }
  774. w.WriteHeader(http.StatusNoContent)
  775. return nil
  776. }
  777. func deleteImages(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  778. if err := parseForm(r); err != nil {
  779. return err
  780. }
  781. if vars == nil {
  782. return fmt.Errorf("Missing parameter")
  783. }
  784. d := getDaemon(eng)
  785. name := vars["name"]
  786. force := toBool(r.Form.Get("force"))
  787. noprune := toBool(r.Form.Get("noprune"))
  788. list, err := d.ImageDelete(name, force, noprune)
  789. if err != nil {
  790. return err
  791. }
  792. return writeJSON(w, http.StatusOK, list)
  793. }
  794. func postContainersStart(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  795. if vars == nil {
  796. return fmt.Errorf("Missing parameter")
  797. }
  798. var (
  799. name = vars["name"]
  800. job = eng.Job("start", name)
  801. )
  802. // If contentLength is -1, we can assumed chunked encoding
  803. // or more technically that the length is unknown
  804. // http://golang.org/src/pkg/net/http/request.go#L139
  805. // net/http otherwise seems to swallow any headers related to chunked encoding
  806. // including r.TransferEncoding
  807. // allow a nil body for backwards compatibility
  808. if r.Body != nil && (r.ContentLength > 0 || r.ContentLength == -1) {
  809. if err := checkForJson(r); err != nil {
  810. return err
  811. }
  812. if err := job.DecodeEnv(r.Body); err != nil {
  813. return err
  814. }
  815. }
  816. if err := job.Run(); err != nil {
  817. if err.Error() == "Container already started" {
  818. w.WriteHeader(http.StatusNotModified)
  819. return nil
  820. }
  821. return err
  822. }
  823. w.WriteHeader(http.StatusNoContent)
  824. return nil
  825. }
  826. func postContainersStop(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  827. if err := parseForm(r); err != nil {
  828. return err
  829. }
  830. if vars == nil {
  831. return fmt.Errorf("Missing parameter")
  832. }
  833. job := eng.Job("stop", vars["name"])
  834. job.Setenv("t", r.Form.Get("t"))
  835. if err := job.Run(); err != nil {
  836. if err.Error() == "Container already stopped" {
  837. w.WriteHeader(http.StatusNotModified)
  838. return nil
  839. }
  840. return err
  841. }
  842. w.WriteHeader(http.StatusNoContent)
  843. return nil
  844. }
  845. func postContainersWait(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  846. if vars == nil {
  847. return fmt.Errorf("Missing parameter")
  848. }
  849. var (
  850. stdoutBuffer = bytes.NewBuffer(nil)
  851. job = eng.Job("wait", vars["name"])
  852. )
  853. job.Stdout.Add(stdoutBuffer)
  854. if err := job.Run(); err != nil {
  855. return err
  856. }
  857. statusCode, err := strconv.Atoi(engine.Tail(stdoutBuffer, 1))
  858. if err != nil {
  859. return err
  860. }
  861. return writeJSON(w, http.StatusOK, &types.ContainerWaitResponse{
  862. StatusCode: statusCode,
  863. })
  864. }
  865. func postContainersResize(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  866. if err := parseForm(r); err != nil {
  867. return err
  868. }
  869. if vars == nil {
  870. return fmt.Errorf("Missing parameter")
  871. }
  872. if err := eng.Job("resize", vars["name"], r.Form.Get("h"), r.Form.Get("w")).Run(); err != nil {
  873. return err
  874. }
  875. return nil
  876. }
  877. func postContainersAttach(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  878. if err := parseForm(r); err != nil {
  879. return err
  880. }
  881. if vars == nil {
  882. return fmt.Errorf("Missing parameter")
  883. }
  884. d := getDaemon(eng)
  885. cont, err := d.Get(vars["name"])
  886. if err != nil {
  887. return err
  888. }
  889. inStream, outStream, err := hijackServer(w)
  890. if err != nil {
  891. return err
  892. }
  893. defer closeStreams(inStream, outStream)
  894. var errStream io.Writer
  895. if _, ok := r.Header["Upgrade"]; ok {
  896. 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")
  897. } else {
  898. fmt.Fprintf(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")
  899. }
  900. if !cont.Config.Tty && version.GreaterThanOrEqualTo("1.6") {
  901. errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
  902. outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
  903. } else {
  904. errStream = outStream
  905. }
  906. logs := r.Form.Get("logs") != ""
  907. stream := r.Form.Get("stream") != ""
  908. if err := cont.AttachWithLogs(inStream, outStream, errStream, logs, stream); err != nil {
  909. fmt.Fprintf(outStream, "Error attaching: %s\n", err)
  910. }
  911. return nil
  912. }
  913. func wsContainersAttach(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  914. if err := parseForm(r); err != nil {
  915. return err
  916. }
  917. if vars == nil {
  918. return fmt.Errorf("Missing parameter")
  919. }
  920. d := getDaemon(eng)
  921. cont, err := d.Get(vars["name"])
  922. if err != nil {
  923. return err
  924. }
  925. h := websocket.Handler(func(ws *websocket.Conn) {
  926. defer ws.Close()
  927. logs := r.Form.Get("logs") != ""
  928. stream := r.Form.Get("stream") != ""
  929. if err := cont.AttachWithLogs(ws, ws, ws, logs, stream); err != nil {
  930. logrus.Errorf("Error attaching websocket: %s", err)
  931. }
  932. })
  933. h.ServeHTTP(w, r)
  934. return nil
  935. }
  936. func getContainersByName(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  937. if vars == nil {
  938. return fmt.Errorf("Missing parameter")
  939. }
  940. var job = eng.Job("container_inspect", vars["name"])
  941. if version.LessThan("1.12") {
  942. job.SetenvBool("raw", true)
  943. }
  944. streamJSON(job, w, false)
  945. return job.Run()
  946. }
  947. func getExecByID(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  948. if vars == nil {
  949. return fmt.Errorf("Missing parameter 'id'")
  950. }
  951. var job = eng.Job("execInspect", vars["id"])
  952. streamJSON(job, w, false)
  953. return job.Run()
  954. }
  955. func getImagesByName(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  956. if vars == nil {
  957. return fmt.Errorf("Missing parameter")
  958. }
  959. var job = eng.Job("image_inspect", vars["name"])
  960. if version.LessThan("1.12") {
  961. job.SetenvBool("raw", true)
  962. }
  963. streamJSON(job, w, false)
  964. return job.Run()
  965. }
  966. func postBuild(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  967. if version.LessThan("1.3") {
  968. return fmt.Errorf("Multipart upload for build is no longer supported. Please upgrade your docker client.")
  969. }
  970. var (
  971. authEncoded = r.Header.Get("X-Registry-Auth")
  972. authConfig = &registry.AuthConfig{}
  973. configFileEncoded = r.Header.Get("X-Registry-Config")
  974. configFile = &registry.ConfigFile{}
  975. job = eng.Job("build")
  976. )
  977. // This block can be removed when API versions prior to 1.9 are deprecated.
  978. // Both headers will be parsed and sent along to the daemon, but if a non-empty
  979. // ConfigFile is present, any value provided as an AuthConfig directly will
  980. // be overridden. See BuildFile::CmdFrom for details.
  981. if version.LessThan("1.9") && authEncoded != "" {
  982. authJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))
  983. if err := json.NewDecoder(authJson).Decode(authConfig); err != nil {
  984. // for a pull it is not an error if no auth was given
  985. // to increase compatibility with the existing api it is defaulting to be empty
  986. authConfig = &registry.AuthConfig{}
  987. }
  988. }
  989. if configFileEncoded != "" {
  990. configFileJson := base64.NewDecoder(base64.URLEncoding, strings.NewReader(configFileEncoded))
  991. if err := json.NewDecoder(configFileJson).Decode(configFile); err != nil {
  992. // for a pull it is not an error if no auth was given
  993. // to increase compatibility with the existing api it is defaulting to be empty
  994. configFile = &registry.ConfigFile{}
  995. }
  996. }
  997. if version.GreaterThanOrEqualTo("1.8") {
  998. job.SetenvBool("json", true)
  999. streamJSON(job, w, true)
  1000. } else {
  1001. job.Stdout.Add(utils.NewWriteFlusher(w))
  1002. }
  1003. if toBool(r.FormValue("forcerm")) && version.GreaterThanOrEqualTo("1.12") {
  1004. job.Setenv("rm", "1")
  1005. } else if r.FormValue("rm") == "" && version.GreaterThanOrEqualTo("1.12") {
  1006. job.Setenv("rm", "1")
  1007. } else {
  1008. job.Setenv("rm", r.FormValue("rm"))
  1009. }
  1010. if toBool(r.FormValue("pull")) && version.GreaterThanOrEqualTo("1.16") {
  1011. job.Setenv("pull", "1")
  1012. }
  1013. job.Stdin.Add(r.Body)
  1014. job.Setenv("remote", r.FormValue("remote"))
  1015. job.Setenv("dockerfile", r.FormValue("dockerfile"))
  1016. job.Setenv("t", r.FormValue("t"))
  1017. job.Setenv("q", r.FormValue("q"))
  1018. job.Setenv("nocache", r.FormValue("nocache"))
  1019. job.Setenv("forcerm", r.FormValue("forcerm"))
  1020. job.SetenvJson("authConfig", authConfig)
  1021. job.SetenvJson("configFile", configFile)
  1022. job.Setenv("memswap", r.FormValue("memswap"))
  1023. job.Setenv("memory", r.FormValue("memory"))
  1024. job.Setenv("cpusetcpus", r.FormValue("cpusetcpus"))
  1025. job.Setenv("cpushares", r.FormValue("cpushares"))
  1026. // Job cancellation. Note: not all job types support this.
  1027. if closeNotifier, ok := w.(http.CloseNotifier); ok {
  1028. finished := make(chan struct{})
  1029. defer close(finished)
  1030. go func() {
  1031. select {
  1032. case <-finished:
  1033. case <-closeNotifier.CloseNotify():
  1034. logrus.Infof("Client disconnected, cancelling job: %s", job.Name)
  1035. job.Cancel()
  1036. }
  1037. }()
  1038. }
  1039. if err := job.Run(); err != nil {
  1040. if !job.Stdout.Used() {
  1041. return err
  1042. }
  1043. sf := streamformatter.NewStreamFormatter(version.GreaterThanOrEqualTo("1.8"))
  1044. w.Write(sf.FormatError(err))
  1045. }
  1046. return nil
  1047. }
  1048. func postContainersCopy(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  1049. if vars == nil {
  1050. return fmt.Errorf("Missing parameter")
  1051. }
  1052. var copyData engine.Env
  1053. if err := checkForJson(r); err != nil {
  1054. return err
  1055. }
  1056. if err := copyData.Decode(r.Body); err != nil {
  1057. return err
  1058. }
  1059. if copyData.Get("Resource") == "" {
  1060. return fmt.Errorf("Path cannot be empty")
  1061. }
  1062. origResource := copyData.Get("Resource")
  1063. if copyData.Get("Resource")[0] == '/' {
  1064. copyData.Set("Resource", copyData.Get("Resource")[1:])
  1065. }
  1066. job := eng.Job("container_copy", vars["name"], copyData.Get("Resource"))
  1067. job.Stdout.Add(w)
  1068. w.Header().Set("Content-Type", "application/x-tar")
  1069. if err := job.Run(); err != nil {
  1070. logrus.Errorf("%v", err)
  1071. if strings.Contains(strings.ToLower(err.Error()), "no such id") {
  1072. w.WriteHeader(http.StatusNotFound)
  1073. } else if strings.Contains(err.Error(), "no such file or directory") {
  1074. return fmt.Errorf("Could not find the file %s in container %s", origResource, vars["name"])
  1075. }
  1076. }
  1077. return nil
  1078. }
  1079. func postContainerExecCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  1080. if err := parseForm(r); err != nil {
  1081. return nil
  1082. }
  1083. var (
  1084. name = vars["name"]
  1085. job = eng.Job("execCreate", name)
  1086. stdoutBuffer = bytes.NewBuffer(nil)
  1087. outWarnings []string
  1088. warnings = bytes.NewBuffer(nil)
  1089. )
  1090. if err := job.DecodeEnv(r.Body); err != nil {
  1091. return err
  1092. }
  1093. job.Stdout.Add(stdoutBuffer)
  1094. // Read warnings from stderr
  1095. job.Stderr.Add(warnings)
  1096. // Register an instance of Exec in container.
  1097. if err := job.Run(); err != nil {
  1098. fmt.Fprintf(os.Stderr, "Error setting up exec command in container %s: %s\n", name, err)
  1099. return err
  1100. }
  1101. // Parse warnings from stderr
  1102. scanner := bufio.NewScanner(warnings)
  1103. for scanner.Scan() {
  1104. outWarnings = append(outWarnings, scanner.Text())
  1105. }
  1106. return writeJSON(w, http.StatusCreated, &types.ContainerExecCreateResponse{
  1107. ID: engine.Tail(stdoutBuffer, 1),
  1108. Warnings: outWarnings,
  1109. })
  1110. }
  1111. // TODO(vishh): Refactor the code to avoid having to specify stream config as part of both create and start.
  1112. func postContainerExecStart(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  1113. if err := parseForm(r); err != nil {
  1114. return nil
  1115. }
  1116. var (
  1117. name = vars["name"]
  1118. job = eng.Job("execStart", name)
  1119. errOut io.Writer = os.Stderr
  1120. )
  1121. if err := job.DecodeEnv(r.Body); err != nil {
  1122. return err
  1123. }
  1124. if !job.GetenvBool("Detach") {
  1125. // Setting up the streaming http interface.
  1126. inStream, outStream, err := hijackServer(w)
  1127. if err != nil {
  1128. return err
  1129. }
  1130. defer closeStreams(inStream, outStream)
  1131. var errStream io.Writer
  1132. if _, ok := r.Header["Upgrade"]; ok {
  1133. 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")
  1134. } else {
  1135. fmt.Fprintf(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")
  1136. }
  1137. if !job.GetenvBool("Tty") && version.GreaterThanOrEqualTo("1.6") {
  1138. errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr)
  1139. outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
  1140. } else {
  1141. errStream = outStream
  1142. }
  1143. job.Stdin.Add(inStream)
  1144. job.Stdout.Add(outStream)
  1145. job.Stderr.Set(errStream)
  1146. errOut = outStream
  1147. }
  1148. // Now run the user process in container.
  1149. job.SetCloseIO(false)
  1150. if err := job.Run(); err != nil {
  1151. fmt.Fprintf(errOut, "Error starting exec command in container %s: %s\n", name, err)
  1152. return err
  1153. }
  1154. w.WriteHeader(http.StatusNoContent)
  1155. return nil
  1156. }
  1157. func postContainerExecResize(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  1158. if err := parseForm(r); err != nil {
  1159. return err
  1160. }
  1161. if vars == nil {
  1162. return fmt.Errorf("Missing parameter")
  1163. }
  1164. if err := eng.Job("execResize", vars["name"], r.Form.Get("h"), r.Form.Get("w")).Run(); err != nil {
  1165. return err
  1166. }
  1167. return nil
  1168. }
  1169. func optionsHandler(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  1170. w.WriteHeader(http.StatusOK)
  1171. return nil
  1172. }
  1173. func writeCorsHeaders(w http.ResponseWriter, r *http.Request, corsHeaders string) {
  1174. logrus.Debugf("CORS header is enabled and set to: %s", corsHeaders)
  1175. w.Header().Add("Access-Control-Allow-Origin", corsHeaders)
  1176. w.Header().Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, X-Registry-Auth")
  1177. w.Header().Add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS")
  1178. }
  1179. func ping(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  1180. _, err := w.Write([]byte{'O', 'K'})
  1181. return err
  1182. }
  1183. func makeHttpHandler(eng *engine.Engine, logging bool, localMethod string, localRoute string, handlerFunc HttpApiFunc, corsHeaders string, dockerVersion version.Version) http.HandlerFunc {
  1184. return func(w http.ResponseWriter, r *http.Request) {
  1185. // log the request
  1186. logrus.Debugf("Calling %s %s", localMethod, localRoute)
  1187. if logging {
  1188. logrus.Infof("%s %s", r.Method, r.RequestURI)
  1189. }
  1190. if strings.Contains(r.Header.Get("User-Agent"), "Docker-Client/") {
  1191. userAgent := strings.Split(r.Header.Get("User-Agent"), "/")
  1192. if len(userAgent) == 2 && !dockerVersion.Equal(version.Version(userAgent[1])) {
  1193. logrus.Debugf("Warning: client and server don't have the same version (client: %s, server: %s)", userAgent[1], dockerVersion)
  1194. }
  1195. }
  1196. version := version.Version(mux.Vars(r)["version"])
  1197. if version == "" {
  1198. version = api.APIVERSION
  1199. }
  1200. if corsHeaders != "" {
  1201. writeCorsHeaders(w, r, corsHeaders)
  1202. }
  1203. if version.GreaterThan(api.APIVERSION) {
  1204. 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)
  1205. return
  1206. }
  1207. if err := handlerFunc(eng, version, w, r, mux.Vars(r)); err != nil {
  1208. logrus.Errorf("Handler for %s %s returned error: %s", localMethod, localRoute, err)
  1209. httpError(w, err)
  1210. }
  1211. }
  1212. }
  1213. // we keep enableCors just for legacy usage, need to be removed in the future
  1214. func createRouter(eng *engine.Engine, logging, enableCors bool, corsHeaders string, dockerVersion string) *mux.Router {
  1215. r := mux.NewRouter()
  1216. if os.Getenv("DEBUG") != "" {
  1217. ProfilerSetup(r, "/debug/")
  1218. }
  1219. m := map[string]map[string]HttpApiFunc{
  1220. "GET": {
  1221. "/_ping": ping,
  1222. "/events": getEvents,
  1223. "/info": getInfo,
  1224. "/version": getVersion,
  1225. "/images/json": getImagesJSON,
  1226. "/images/viz": getImagesViz,
  1227. "/images/search": getImagesSearch,
  1228. "/images/get": getImagesGet,
  1229. "/images/{name:.*}/get": getImagesGet,
  1230. "/images/{name:.*}/history": getImagesHistory,
  1231. "/images/{name:.*}/json": getImagesByName,
  1232. "/containers/ps": getContainersJSON,
  1233. "/containers/json": getContainersJSON,
  1234. "/containers/{name:.*}/export": getContainersExport,
  1235. "/containers/{name:.*}/changes": getContainersChanges,
  1236. "/containers/{name:.*}/json": getContainersByName,
  1237. "/containers/{name:.*}/top": getContainersTop,
  1238. "/containers/{name:.*}/logs": getContainersLogs,
  1239. "/containers/{name:.*}/stats": getContainersStats,
  1240. "/containers/{name:.*}/attach/ws": wsContainersAttach,
  1241. "/exec/{id:.*}/json": getExecByID,
  1242. },
  1243. "POST": {
  1244. "/auth": postAuth,
  1245. "/commit": postCommit,
  1246. "/build": postBuild,
  1247. "/images/create": postImagesCreate,
  1248. "/images/load": postImagesLoad,
  1249. "/images/{name:.*}/push": postImagesPush,
  1250. "/images/{name:.*}/tag": postImagesTag,
  1251. "/containers/create": postContainersCreate,
  1252. "/containers/{name:.*}/kill": postContainersKill,
  1253. "/containers/{name:.*}/pause": postContainersPause,
  1254. "/containers/{name:.*}/unpause": postContainersUnpause,
  1255. "/containers/{name:.*}/restart": postContainersRestart,
  1256. "/containers/{name:.*}/start": postContainersStart,
  1257. "/containers/{name:.*}/stop": postContainersStop,
  1258. "/containers/{name:.*}/wait": postContainersWait,
  1259. "/containers/{name:.*}/resize": postContainersResize,
  1260. "/containers/{name:.*}/attach": postContainersAttach,
  1261. "/containers/{name:.*}/copy": postContainersCopy,
  1262. "/containers/{name:.*}/exec": postContainerExecCreate,
  1263. "/exec/{name:.*}/start": postContainerExecStart,
  1264. "/exec/{name:.*}/resize": postContainerExecResize,
  1265. "/containers/{name:.*}/rename": postContainerRename,
  1266. },
  1267. "DELETE": {
  1268. "/containers/{name:.*}": deleteContainers,
  1269. "/images/{name:.*}": deleteImages,
  1270. },
  1271. "OPTIONS": {
  1272. "": optionsHandler,
  1273. },
  1274. }
  1275. // If "api-cors-header" is not given, but "api-enable-cors" is true, we set cors to "*"
  1276. // otherwise, all head values will be passed to HTTP handler
  1277. if corsHeaders == "" && enableCors {
  1278. corsHeaders = "*"
  1279. }
  1280. for method, routes := range m {
  1281. for route, fct := range routes {
  1282. logrus.Debugf("Registering %s, %s", method, route)
  1283. // NOTE: scope issue, make sure the variables are local and won't be changed
  1284. localRoute := route
  1285. localFct := fct
  1286. localMethod := method
  1287. // build the handler function
  1288. f := makeHttpHandler(eng, logging, localMethod, localRoute, localFct, corsHeaders, version.Version(dockerVersion))
  1289. // add the new route
  1290. if localRoute == "" {
  1291. r.Methods(localMethod).HandlerFunc(f)
  1292. } else {
  1293. r.Path("/v{version:[0-9.]+}" + localRoute).Methods(localMethod).HandlerFunc(f)
  1294. r.Path(localRoute).Methods(localMethod).HandlerFunc(f)
  1295. }
  1296. }
  1297. }
  1298. return r
  1299. }
  1300. // ServeRequest processes a single http request to the docker remote api.
  1301. // FIXME: refactor this to be part of Server and not require re-creating a new
  1302. // router each time. This requires first moving ListenAndServe into Server.
  1303. func ServeRequest(eng *engine.Engine, apiversion version.Version, w http.ResponseWriter, req *http.Request) {
  1304. router := createRouter(eng, false, true, "", "")
  1305. // Insert APIVERSION into the request as a convenience
  1306. req.URL.Path = fmt.Sprintf("/v%s%s", apiversion, req.URL.Path)
  1307. router.ServeHTTP(w, req)
  1308. }
  1309. func allocateDaemonPort(addr string) error {
  1310. host, port, err := net.SplitHostPort(addr)
  1311. if err != nil {
  1312. return err
  1313. }
  1314. intPort, err := strconv.Atoi(port)
  1315. if err != nil {
  1316. return err
  1317. }
  1318. var hostIPs []net.IP
  1319. if parsedIP := net.ParseIP(host); parsedIP != nil {
  1320. hostIPs = append(hostIPs, parsedIP)
  1321. } else if hostIPs, err = net.LookupIP(host); err != nil {
  1322. return fmt.Errorf("failed to lookup %s address in host specification", host)
  1323. }
  1324. for _, hostIP := range hostIPs {
  1325. if _, err := bridge.RequestPort(hostIP, "tcp", intPort); err != nil {
  1326. return fmt.Errorf("failed to allocate daemon listening port %d (err: %v)", intPort, err)
  1327. }
  1328. }
  1329. return nil
  1330. }
  1331. type Server interface {
  1332. Serve() error
  1333. Close() error
  1334. }
  1335. // ServeApi loops through all of the protocols sent in to docker and spawns
  1336. // off a go routine to setup a serving http.Server for each.
  1337. func ServeApi(job *engine.Job) error {
  1338. if len(job.Args) == 0 {
  1339. return fmt.Errorf("usage: %s PROTO://ADDR [PROTO://ADDR ...]", job.Name)
  1340. }
  1341. var (
  1342. protoAddrs = job.Args
  1343. chErrors = make(chan error, len(protoAddrs))
  1344. )
  1345. for _, protoAddr := range protoAddrs {
  1346. protoAddrParts := strings.SplitN(protoAddr, "://", 2)
  1347. if len(protoAddrParts) != 2 {
  1348. return fmt.Errorf("usage: %s PROTO://ADDR [PROTO://ADDR ...]", job.Name)
  1349. }
  1350. go func() {
  1351. logrus.Infof("Listening for HTTP on %s (%s)", protoAddrParts[0], protoAddrParts[1])
  1352. srv, err := NewServer(protoAddrParts[0], protoAddrParts[1], job)
  1353. if err != nil {
  1354. chErrors <- err
  1355. return
  1356. }
  1357. job.Eng.OnShutdown(func() {
  1358. if err := srv.Close(); err != nil {
  1359. logrus.Error(err)
  1360. }
  1361. })
  1362. if err = srv.Serve(); err != nil && strings.Contains(err.Error(), "use of closed network connection") {
  1363. err = nil
  1364. }
  1365. chErrors <- err
  1366. }()
  1367. }
  1368. for i := 0; i < len(protoAddrs); i++ {
  1369. err := <-chErrors
  1370. if err != nil {
  1371. return err
  1372. }
  1373. }
  1374. return nil
  1375. }
  1376. func toBool(s string) bool {
  1377. s = strings.ToLower(strings.TrimSpace(s))
  1378. return !(s == "" || s == "0" || s == "no" || s == "false" || s == "none")
  1379. }