api.go 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986
  1. package docker
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "github.com/dotcloud/docker/auth"
  6. "github.com/dotcloud/docker/utils"
  7. "github.com/gorilla/mux"
  8. "io"
  9. "io/ioutil"
  10. "log"
  11. "net"
  12. "net/http"
  13. "os"
  14. "os/exec"
  15. "strconv"
  16. "strings"
  17. )
  18. const APIVERSION = 1.4
  19. const DEFAULTHTTPHOST = "127.0.0.1"
  20. const DEFAULTHTTPPORT = 4243
  21. const DEFAULTUNIXSOCKET = "/var/run/docker.sock"
  22. func hijackServer(w http.ResponseWriter) (io.ReadCloser, io.Writer, error) {
  23. conn, _, err := w.(http.Hijacker).Hijack()
  24. if err != nil {
  25. return nil, nil, err
  26. }
  27. // Flush the options to make sure the client sets the raw mode
  28. conn.Write([]byte{})
  29. return conn, conn, nil
  30. }
  31. //If we don't do this, POST method without Content-type (even with empty body) will fail
  32. func parseForm(r *http.Request) error {
  33. if err := r.ParseForm(); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
  34. return err
  35. }
  36. return nil
  37. }
  38. func parseMultipartForm(r *http.Request) error {
  39. if err := r.ParseMultipartForm(4096); err != nil && !strings.HasPrefix(err.Error(), "mime:") {
  40. return err
  41. }
  42. return nil
  43. }
  44. func httpError(w http.ResponseWriter, err error) {
  45. statusCode := http.StatusInternalServerError
  46. if strings.HasPrefix(err.Error(), "No such") {
  47. statusCode = http.StatusNotFound
  48. } else if strings.HasPrefix(err.Error(), "Bad parameter") {
  49. statusCode = http.StatusBadRequest
  50. } else if strings.HasPrefix(err.Error(), "Conflict") {
  51. statusCode = http.StatusConflict
  52. } else if strings.HasPrefix(err.Error(), "Impossible") {
  53. statusCode = http.StatusNotAcceptable
  54. } else if strings.HasPrefix(err.Error(), "Wrong login/password") {
  55. statusCode = http.StatusUnauthorized
  56. } else if strings.Contains(err.Error(), "hasn't been activated") {
  57. statusCode = http.StatusForbidden
  58. }
  59. utils.Debugf("[error %d] %s", statusCode, err)
  60. http.Error(w, err.Error(), statusCode)
  61. }
  62. func writeJSON(w http.ResponseWriter, b []byte) {
  63. w.Header().Set("Content-Type", "application/json")
  64. w.Write(b)
  65. }
  66. func getBoolParam(value string) (bool, error) {
  67. if value == "" {
  68. return false, nil
  69. }
  70. ret, err := strconv.ParseBool(value)
  71. if err != nil {
  72. return false, fmt.Errorf("Bad parameter")
  73. }
  74. return ret, nil
  75. }
  76. func postAuth(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  77. authConfig := &auth.AuthConfig{}
  78. err := json.NewDecoder(r.Body).Decode(authConfig)
  79. if err != nil {
  80. return err
  81. }
  82. status, err := auth.Login(authConfig, srv.HTTPRequestFactory())
  83. if err != nil {
  84. return err
  85. }
  86. if status != "" {
  87. b, err := json.Marshal(&APIAuth{Status: status})
  88. if err != nil {
  89. return err
  90. }
  91. writeJSON(w, b)
  92. return nil
  93. }
  94. w.WriteHeader(http.StatusNoContent)
  95. return nil
  96. }
  97. func getVersion(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  98. m := srv.DockerVersion()
  99. b, err := json.Marshal(m)
  100. if err != nil {
  101. return err
  102. }
  103. writeJSON(w, b)
  104. return nil
  105. }
  106. func postContainersKill(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  107. if vars == nil {
  108. return fmt.Errorf("Missing parameter")
  109. }
  110. name := vars["name"]
  111. if err := srv.ContainerKill(name); err != nil {
  112. return err
  113. }
  114. w.WriteHeader(http.StatusNoContent)
  115. return nil
  116. }
  117. func getContainersExport(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  118. if vars == nil {
  119. return fmt.Errorf("Missing parameter")
  120. }
  121. name := vars["name"]
  122. if err := srv.ContainerExport(name, w); err != nil {
  123. utils.Debugf("%s", err)
  124. return err
  125. }
  126. return nil
  127. }
  128. func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  129. if err := parseForm(r); err != nil {
  130. return err
  131. }
  132. all, err := getBoolParam(r.Form.Get("all"))
  133. if err != nil {
  134. return err
  135. }
  136. filter := r.Form.Get("filter")
  137. outs, err := srv.Images(all, filter)
  138. if err != nil {
  139. return err
  140. }
  141. b, err := json.Marshal(outs)
  142. if err != nil {
  143. return err
  144. }
  145. writeJSON(w, b)
  146. return nil
  147. }
  148. func getImagesViz(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  149. if err := srv.ImagesViz(w); err != nil {
  150. return err
  151. }
  152. return nil
  153. }
  154. func getInfo(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  155. out := srv.DockerInfo()
  156. b, err := json.Marshal(out)
  157. if err != nil {
  158. return err
  159. }
  160. writeJSON(w, b)
  161. return nil
  162. }
  163. func getEvents(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  164. sendEvent := func(wf *utils.WriteFlusher, event *utils.JSONMessage) error {
  165. b, err := json.Marshal(event)
  166. if err != nil {
  167. return fmt.Errorf("JSON error")
  168. }
  169. _, err = wf.Write(b)
  170. if err != nil {
  171. // On error, evict the listener
  172. utils.Debugf("%s", err)
  173. srv.Lock()
  174. delete(srv.listeners, r.RemoteAddr)
  175. srv.Unlock()
  176. return err
  177. }
  178. return nil
  179. }
  180. if err := parseForm(r); err != nil {
  181. return err
  182. }
  183. listener := make(chan utils.JSONMessage)
  184. srv.Lock()
  185. srv.listeners[r.RemoteAddr] = listener
  186. srv.Unlock()
  187. since, err := strconv.ParseInt(r.Form.Get("since"), 10, 0)
  188. if err != nil {
  189. since = 0
  190. }
  191. w.Header().Set("Content-Type", "application/json")
  192. wf := utils.NewWriteFlusher(w)
  193. if since != 0 {
  194. // If since, send previous events that happened after the timestamp
  195. for _, event := range srv.events {
  196. if event.Time >= since {
  197. err := sendEvent(wf, &event)
  198. if err != nil && err.Error() == "JSON error" {
  199. continue
  200. }
  201. if err != nil {
  202. return err
  203. }
  204. }
  205. }
  206. }
  207. for {
  208. event := <-listener
  209. err := sendEvent(wf, &event)
  210. if err != nil && err.Error() == "JSON error" {
  211. continue
  212. }
  213. if err != nil {
  214. return err
  215. }
  216. }
  217. return nil
  218. }
  219. func getImagesHistory(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  220. if vars == nil {
  221. return fmt.Errorf("Missing parameter")
  222. }
  223. name := vars["name"]
  224. outs, err := srv.ImageHistory(name)
  225. if err != nil {
  226. return err
  227. }
  228. b, err := json.Marshal(outs)
  229. if err != nil {
  230. return err
  231. }
  232. writeJSON(w, b)
  233. return nil
  234. }
  235. func getContainersChanges(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  236. if vars == nil {
  237. return fmt.Errorf("Missing parameter")
  238. }
  239. name := vars["name"]
  240. changesStr, err := srv.ContainerChanges(name)
  241. if err != nil {
  242. return err
  243. }
  244. b, err := json.Marshal(changesStr)
  245. if err != nil {
  246. return err
  247. }
  248. writeJSON(w, b)
  249. return nil
  250. }
  251. func getContainersTop(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  252. if version < 1.4 {
  253. return fmt.Errorf("top was improved a lot since 1.3, Please upgrade your docker client.")
  254. }
  255. if vars == nil {
  256. return fmt.Errorf("Missing parameter")
  257. }
  258. if err := parseForm(r); err != nil {
  259. return err
  260. }
  261. name := vars["name"]
  262. ps_args := r.Form.Get("ps_args")
  263. procsStr, err := srv.ContainerTop(name, ps_args)
  264. if err != nil {
  265. return err
  266. }
  267. b, err := json.Marshal(procsStr)
  268. if err != nil {
  269. return err
  270. }
  271. writeJSON(w, b)
  272. return nil
  273. }
  274. func getContainersJSON(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  275. if err := parseForm(r); err != nil {
  276. return err
  277. }
  278. all, err := getBoolParam(r.Form.Get("all"))
  279. if err != nil {
  280. return err
  281. }
  282. size, err := getBoolParam(r.Form.Get("size"))
  283. if err != nil {
  284. return err
  285. }
  286. since := r.Form.Get("since")
  287. before := r.Form.Get("before")
  288. n, err := strconv.Atoi(r.Form.Get("limit"))
  289. if err != nil {
  290. n = -1
  291. }
  292. outs := srv.Containers(all, size, n, since, before)
  293. b, err := json.Marshal(outs)
  294. if err != nil {
  295. return err
  296. }
  297. writeJSON(w, b)
  298. return nil
  299. }
  300. func postImagesTag(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  301. if err := parseForm(r); err != nil {
  302. return err
  303. }
  304. repo := r.Form.Get("repo")
  305. tag := r.Form.Get("tag")
  306. if vars == nil {
  307. return fmt.Errorf("Missing parameter")
  308. }
  309. name := vars["name"]
  310. force, err := getBoolParam(r.Form.Get("force"))
  311. if err != nil {
  312. return err
  313. }
  314. if err := srv.ContainerTag(name, repo, tag, force); err != nil {
  315. return err
  316. }
  317. w.WriteHeader(http.StatusCreated)
  318. return nil
  319. }
  320. func postCommit(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  321. if err := parseForm(r); err != nil {
  322. return err
  323. }
  324. config := &Config{}
  325. if err := json.NewDecoder(r.Body).Decode(config); err != nil {
  326. utils.Debugf("%s", err)
  327. }
  328. repo := r.Form.Get("repo")
  329. tag := r.Form.Get("tag")
  330. container := r.Form.Get("container")
  331. author := r.Form.Get("author")
  332. comment := r.Form.Get("comment")
  333. id, err := srv.ContainerCommit(container, repo, tag, author, comment, config)
  334. if err != nil {
  335. return err
  336. }
  337. b, err := json.Marshal(&APIID{id})
  338. if err != nil {
  339. return err
  340. }
  341. w.WriteHeader(http.StatusCreated)
  342. writeJSON(w, b)
  343. return nil
  344. }
  345. // Creates an image from Pull or from Import
  346. func postImagesCreate(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  347. if err := parseForm(r); err != nil {
  348. return err
  349. }
  350. src := r.Form.Get("fromSrc")
  351. image := r.Form.Get("fromImage")
  352. tag := r.Form.Get("tag")
  353. repo := r.Form.Get("repo")
  354. if version > 1.0 {
  355. w.Header().Set("Content-Type", "application/json")
  356. }
  357. sf := utils.NewStreamFormatter(version > 1.0)
  358. if image != "" { //pull
  359. if err := srv.ImagePull(image, tag, w, sf, &auth.AuthConfig{}, version > 1.3); err != nil {
  360. if sf.Used() {
  361. w.Write(sf.FormatError(err))
  362. return nil
  363. }
  364. return err
  365. }
  366. } else { //import
  367. if err := srv.ImageImport(src, repo, tag, r.Body, w, sf); err != nil {
  368. if sf.Used() {
  369. w.Write(sf.FormatError(err))
  370. return nil
  371. }
  372. return err
  373. }
  374. }
  375. return nil
  376. }
  377. func getImagesSearch(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  378. if err := parseForm(r); err != nil {
  379. return err
  380. }
  381. term := r.Form.Get("term")
  382. outs, err := srv.ImagesSearch(term)
  383. if err != nil {
  384. return err
  385. }
  386. b, err := json.Marshal(outs)
  387. if err != nil {
  388. return err
  389. }
  390. writeJSON(w, b)
  391. return nil
  392. }
  393. func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  394. if err := parseForm(r); err != nil {
  395. return err
  396. }
  397. url := r.Form.Get("url")
  398. path := r.Form.Get("path")
  399. if vars == nil {
  400. return fmt.Errorf("Missing parameter")
  401. }
  402. name := vars["name"]
  403. if version > 1.0 {
  404. w.Header().Set("Content-Type", "application/json")
  405. }
  406. sf := utils.NewStreamFormatter(version > 1.0)
  407. imgID, err := srv.ImageInsert(name, url, path, w, sf)
  408. if err != nil {
  409. if sf.Used() {
  410. w.Write(sf.FormatError(err))
  411. return nil
  412. }
  413. }
  414. b, err := json.Marshal(&APIID{ID: imgID})
  415. if err != nil {
  416. return err
  417. }
  418. writeJSON(w, b)
  419. return nil
  420. }
  421. func postImagesPush(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  422. authConfig := &auth.AuthConfig{}
  423. if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {
  424. return err
  425. }
  426. if err := parseForm(r); err != nil {
  427. return err
  428. }
  429. if vars == nil {
  430. return fmt.Errorf("Missing parameter")
  431. }
  432. name := vars["name"]
  433. if version > 1.0 {
  434. w.Header().Set("Content-Type", "application/json")
  435. }
  436. sf := utils.NewStreamFormatter(version > 1.0)
  437. if err := srv.ImagePush(name, w, sf, authConfig); err != nil {
  438. if sf.Used() {
  439. w.Write(sf.FormatError(err))
  440. return nil
  441. }
  442. return err
  443. }
  444. return nil
  445. }
  446. func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  447. config := &Config{}
  448. out := &APIRun{}
  449. if err := json.NewDecoder(r.Body).Decode(config); err != nil {
  450. return err
  451. }
  452. resolvConf, err := utils.GetResolvConf()
  453. if err != nil {
  454. return err
  455. }
  456. if len(config.Dns) == 0 && len(srv.runtime.Dns) == 0 && utils.CheckLocalDns(resolvConf) {
  457. out.Warnings = append(out.Warnings, fmt.Sprintf("Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns))
  458. config.Dns = defaultDns
  459. }
  460. id, err := srv.ContainerCreate(config)
  461. if err != nil {
  462. return err
  463. }
  464. out.ID = id
  465. if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit {
  466. log.Println("WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.")
  467. out.Warnings = append(out.Warnings, "Your kernel does not support memory limit capabilities. Limitation discarded.")
  468. }
  469. if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit {
  470. log.Println("WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.")
  471. out.Warnings = append(out.Warnings, "Your kernel does not support memory swap capabilities. Limitation discarded.")
  472. }
  473. b, err := json.Marshal(out)
  474. if err != nil {
  475. return err
  476. }
  477. w.WriteHeader(http.StatusCreated)
  478. writeJSON(w, b)
  479. return nil
  480. }
  481. func postContainersRestart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  482. if err := parseForm(r); err != nil {
  483. return err
  484. }
  485. t, err := strconv.Atoi(r.Form.Get("t"))
  486. if err != nil || t < 0 {
  487. t = 10
  488. }
  489. if vars == nil {
  490. return fmt.Errorf("Missing parameter")
  491. }
  492. name := vars["name"]
  493. if err := srv.ContainerRestart(name, t); err != nil {
  494. return err
  495. }
  496. w.WriteHeader(http.StatusNoContent)
  497. return nil
  498. }
  499. func deleteContainers(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  500. if err := parseForm(r); err != nil {
  501. return err
  502. }
  503. if vars == nil {
  504. return fmt.Errorf("Missing parameter")
  505. }
  506. name := vars["name"]
  507. removeVolume, err := getBoolParam(r.Form.Get("v"))
  508. if err != nil {
  509. return err
  510. }
  511. if err := srv.ContainerDestroy(name, removeVolume); err != nil {
  512. return err
  513. }
  514. w.WriteHeader(http.StatusNoContent)
  515. return nil
  516. }
  517. func deleteImages(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  518. if err := parseForm(r); err != nil {
  519. return err
  520. }
  521. if vars == nil {
  522. return fmt.Errorf("Missing parameter")
  523. }
  524. name := vars["name"]
  525. imgs, err := srv.ImageDelete(name, version > 1.1)
  526. if err != nil {
  527. return err
  528. }
  529. if imgs != nil {
  530. if len(imgs) != 0 {
  531. b, err := json.Marshal(imgs)
  532. if err != nil {
  533. return err
  534. }
  535. writeJSON(w, b)
  536. } else {
  537. return fmt.Errorf("Conflict, %s wasn't deleted", name)
  538. }
  539. } else {
  540. w.WriteHeader(http.StatusNoContent)
  541. }
  542. return nil
  543. }
  544. func postContainersStart(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  545. hostConfig := &HostConfig{}
  546. // allow a nil body for backwards compatibility
  547. if r.Body != nil {
  548. if r.Header.Get("Content-Type") == "application/json" {
  549. if err := json.NewDecoder(r.Body).Decode(hostConfig); err != nil {
  550. return err
  551. }
  552. }
  553. }
  554. if vars == nil {
  555. return fmt.Errorf("Missing parameter")
  556. }
  557. name := vars["name"]
  558. if err := srv.ContainerStart(name, hostConfig); err != nil {
  559. return err
  560. }
  561. w.WriteHeader(http.StatusNoContent)
  562. return nil
  563. }
  564. func postContainersStop(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  565. if err := parseForm(r); err != nil {
  566. return err
  567. }
  568. t, err := strconv.Atoi(r.Form.Get("t"))
  569. if err != nil || t < 0 {
  570. t = 10
  571. }
  572. if vars == nil {
  573. return fmt.Errorf("Missing parameter")
  574. }
  575. name := vars["name"]
  576. if err := srv.ContainerStop(name, t); err != nil {
  577. return err
  578. }
  579. w.WriteHeader(http.StatusNoContent)
  580. return nil
  581. }
  582. func postContainersWait(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  583. if vars == nil {
  584. return fmt.Errorf("Missing parameter")
  585. }
  586. name := vars["name"]
  587. status, err := srv.ContainerWait(name)
  588. if err != nil {
  589. return err
  590. }
  591. b, err := json.Marshal(&APIWait{StatusCode: status})
  592. if err != nil {
  593. return err
  594. }
  595. writeJSON(w, b)
  596. return nil
  597. }
  598. func postContainersResize(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  599. if err := parseForm(r); err != nil {
  600. return err
  601. }
  602. height, err := strconv.Atoi(r.Form.Get("h"))
  603. if err != nil {
  604. return err
  605. }
  606. width, err := strconv.Atoi(r.Form.Get("w"))
  607. if err != nil {
  608. return err
  609. }
  610. if vars == nil {
  611. return fmt.Errorf("Missing parameter")
  612. }
  613. name := vars["name"]
  614. if err := srv.ContainerResize(name, height, width); err != nil {
  615. return err
  616. }
  617. return nil
  618. }
  619. func postContainersAttach(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  620. if err := parseForm(r); err != nil {
  621. return err
  622. }
  623. logs, err := getBoolParam(r.Form.Get("logs"))
  624. if err != nil {
  625. return err
  626. }
  627. stream, err := getBoolParam(r.Form.Get("stream"))
  628. if err != nil {
  629. return err
  630. }
  631. stdin, err := getBoolParam(r.Form.Get("stdin"))
  632. if err != nil {
  633. return err
  634. }
  635. stdout, err := getBoolParam(r.Form.Get("stdout"))
  636. if err != nil {
  637. return err
  638. }
  639. stderr, err := getBoolParam(r.Form.Get("stderr"))
  640. if err != nil {
  641. return err
  642. }
  643. if vars == nil {
  644. return fmt.Errorf("Missing parameter")
  645. }
  646. name := vars["name"]
  647. if _, err := srv.ContainerInspect(name); err != nil {
  648. return err
  649. }
  650. in, out, err := hijackServer(w)
  651. if err != nil {
  652. return err
  653. }
  654. defer func() {
  655. if tcpc, ok := in.(*net.TCPConn); ok {
  656. tcpc.CloseWrite()
  657. } else {
  658. in.Close()
  659. }
  660. }()
  661. defer func() {
  662. if tcpc, ok := out.(*net.TCPConn); ok {
  663. tcpc.CloseWrite()
  664. } else if closer, ok := out.(io.Closer); ok {
  665. closer.Close()
  666. }
  667. }()
  668. fmt.Fprintf(out, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n")
  669. if err := srv.ContainerAttach(name, logs, stream, stdin, stdout, stderr, in, out); err != nil {
  670. fmt.Fprintf(out, "Error: %s\n", err)
  671. }
  672. return nil
  673. }
  674. func getContainersByName(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  675. if vars == nil {
  676. return fmt.Errorf("Missing parameter")
  677. }
  678. name := vars["name"]
  679. container, err := srv.ContainerInspect(name)
  680. if err != nil {
  681. return err
  682. }
  683. b, err := json.Marshal(container)
  684. if err != nil {
  685. return err
  686. }
  687. writeJSON(w, b)
  688. return nil
  689. }
  690. func getImagesByName(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  691. if vars == nil {
  692. return fmt.Errorf("Missing parameter")
  693. }
  694. name := vars["name"]
  695. image, err := srv.ImageInspect(name)
  696. if err != nil {
  697. return err
  698. }
  699. b, err := json.Marshal(image)
  700. if err != nil {
  701. return err
  702. }
  703. writeJSON(w, b)
  704. return nil
  705. }
  706. func postImagesGetCache(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  707. apiConfig := &APIImageConfig{}
  708. if err := json.NewDecoder(r.Body).Decode(apiConfig); err != nil {
  709. return err
  710. }
  711. image, err := srv.ImageGetCached(apiConfig.ID, apiConfig.Config)
  712. if err != nil {
  713. return err
  714. }
  715. if image == nil {
  716. w.WriteHeader(http.StatusNotFound)
  717. return nil
  718. }
  719. apiID := &APIID{ID: image.ID}
  720. b, err := json.Marshal(apiID)
  721. if err != nil {
  722. return err
  723. }
  724. writeJSON(w, b)
  725. return nil
  726. }
  727. func postBuild(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  728. if version < 1.3 {
  729. return fmt.Errorf("Multipart upload for build is no longer supported. Please upgrade your docker client.")
  730. }
  731. remoteURL := r.FormValue("remote")
  732. repoName := r.FormValue("t")
  733. rawSuppressOutput := r.FormValue("q")
  734. rawNoCache := r.FormValue("nocache")
  735. repoName, tag := utils.ParseRepositoryTag(repoName)
  736. var context io.Reader
  737. if remoteURL == "" {
  738. context = r.Body
  739. } else if utils.IsGIT(remoteURL) {
  740. if !strings.HasPrefix(remoteURL, "git://") {
  741. remoteURL = "https://" + remoteURL
  742. }
  743. root, err := ioutil.TempDir("", "docker-build-git")
  744. if err != nil {
  745. return err
  746. }
  747. defer os.RemoveAll(root)
  748. if output, err := exec.Command("git", "clone", remoteURL, root).CombinedOutput(); err != nil {
  749. return fmt.Errorf("Error trying to use git: %s (%s)", err, output)
  750. }
  751. c, err := Tar(root, Bzip2)
  752. if err != nil {
  753. return err
  754. }
  755. context = c
  756. } else if utils.IsURL(remoteURL) {
  757. f, err := utils.Download(remoteURL, ioutil.Discard)
  758. if err != nil {
  759. return err
  760. }
  761. defer f.Body.Close()
  762. dockerFile, err := ioutil.ReadAll(f.Body)
  763. if err != nil {
  764. return err
  765. }
  766. c, err := mkBuildContext(string(dockerFile), nil)
  767. if err != nil {
  768. return err
  769. }
  770. context = c
  771. }
  772. suppressOutput, err := getBoolParam(rawSuppressOutput)
  773. if err != nil {
  774. return err
  775. }
  776. noCache, err := getBoolParam(rawNoCache)
  777. if err != nil {
  778. return err
  779. }
  780. b := NewBuildFile(srv, utils.NewWriteFlusher(w), !suppressOutput, !noCache)
  781. id, err := b.Build(context)
  782. if err != nil {
  783. fmt.Fprintf(w, "Error build: %s\n", err)
  784. return err
  785. }
  786. if repoName != "" {
  787. srv.runtime.repositories.Set(repoName, tag, id, false)
  788. }
  789. return nil
  790. }
  791. func optionsHandler(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
  792. w.WriteHeader(http.StatusOK)
  793. return nil
  794. }
  795. func writeCorsHeaders(w http.ResponseWriter, r *http.Request) {
  796. w.Header().Add("Access-Control-Allow-Origin", "*")
  797. w.Header().Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
  798. w.Header().Add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS")
  799. }
  800. func createRouter(srv *Server, logging bool) (*mux.Router, error) {
  801. r := mux.NewRouter()
  802. m := map[string]map[string]func(*Server, float64, http.ResponseWriter, *http.Request, map[string]string) error{
  803. "GET": {
  804. "/events": getEvents,
  805. "/info": getInfo,
  806. "/version": getVersion,
  807. "/images/json": getImagesJSON,
  808. "/images/viz": getImagesViz,
  809. "/images/search": getImagesSearch,
  810. "/images/{name:.*}/history": getImagesHistory,
  811. "/images/{name:.*}/json": getImagesByName,
  812. "/containers/ps": getContainersJSON,
  813. "/containers/json": getContainersJSON,
  814. "/containers/{name:.*}/export": getContainersExport,
  815. "/containers/{name:.*}/changes": getContainersChanges,
  816. "/containers/{name:.*}/json": getContainersByName,
  817. "/containers/{name:.*}/top": getContainersTop,
  818. },
  819. "POST": {
  820. "/auth": postAuth,
  821. "/commit": postCommit,
  822. "/build": postBuild,
  823. "/images/create": postImagesCreate,
  824. "/images/{name:.*}/insert": postImagesInsert,
  825. "/images/{name:.*}/push": postImagesPush,
  826. "/images/{name:.*}/tag": postImagesTag,
  827. "/images/getCache": postImagesGetCache,
  828. "/containers/create": postContainersCreate,
  829. "/containers/{name:.*}/kill": postContainersKill,
  830. "/containers/{name:.*}/restart": postContainersRestart,
  831. "/containers/{name:.*}/start": postContainersStart,
  832. "/containers/{name:.*}/stop": postContainersStop,
  833. "/containers/{name:.*}/wait": postContainersWait,
  834. "/containers/{name:.*}/resize": postContainersResize,
  835. "/containers/{name:.*}/attach": postContainersAttach,
  836. },
  837. "DELETE": {
  838. "/containers/{name:.*}": deleteContainers,
  839. "/images/{name:.*}": deleteImages,
  840. },
  841. "OPTIONS": {
  842. "": optionsHandler,
  843. },
  844. }
  845. for method, routes := range m {
  846. for route, fct := range routes {
  847. utils.Debugf("Registering %s, %s", method, route)
  848. // NOTE: scope issue, make sure the variables are local and won't be changed
  849. localRoute := route
  850. localMethod := method
  851. localFct := fct
  852. f := func(w http.ResponseWriter, r *http.Request) {
  853. utils.Debugf("Calling %s %s from %s", localMethod, localRoute, r.RemoteAddr)
  854. if logging {
  855. log.Println(r.Method, r.RequestURI)
  856. }
  857. if strings.Contains(r.Header.Get("User-Agent"), "Docker-Client/") {
  858. userAgent := strings.Split(r.Header.Get("User-Agent"), "/")
  859. if len(userAgent) == 2 && userAgent[1] != VERSION {
  860. utils.Debugf("Warning: client and server don't have the same version (client: %s, server: %s)", userAgent[1], VERSION)
  861. }
  862. }
  863. version, err := strconv.ParseFloat(mux.Vars(r)["version"], 64)
  864. if err != nil {
  865. version = APIVERSION
  866. }
  867. if srv.enableCors {
  868. writeCorsHeaders(w, r)
  869. }
  870. if version == 0 || version > APIVERSION {
  871. w.WriteHeader(http.StatusNotFound)
  872. return
  873. }
  874. if err := localFct(srv, version, w, r, mux.Vars(r)); err != nil {
  875. httpError(w, err)
  876. }
  877. }
  878. if localRoute == "" {
  879. r.Methods(localMethod).HandlerFunc(f)
  880. } else {
  881. r.Path("/v{version:[0-9.]+}" + localRoute).Methods(localMethod).HandlerFunc(f)
  882. r.Path(localRoute).Methods(localMethod).HandlerFunc(f)
  883. }
  884. }
  885. }
  886. return r, nil
  887. }
  888. func ListenAndServe(proto, addr string, srv *Server, logging bool) error {
  889. log.Printf("Listening for HTTP on %s (%s)\n", addr, proto)
  890. r, err := createRouter(srv, logging)
  891. if err != nil {
  892. return err
  893. }
  894. l, e := net.Listen(proto, addr)
  895. if e != nil {
  896. return e
  897. }
  898. if proto == "unix" {
  899. os.Chmod(addr, 0700)
  900. }
  901. httpSrv := http.Server{Addr: addr, Handler: r}
  902. return httpSrv.Serve(l)
  903. }