server.go 47 KB

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