commands.go 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814
  1. package docker
  2. import (
  3. "bytes"
  4. "encoding/json"
  5. "errors"
  6. "fmt"
  7. "github.com/dotcloud/docker/auth"
  8. "github.com/dotcloud/docker/future"
  9. "github.com/dotcloud/docker/rcli"
  10. "io"
  11. "net/http"
  12. "net/url"
  13. "path"
  14. "strconv"
  15. "strings"
  16. "sync"
  17. "text/tabwriter"
  18. "time"
  19. )
  20. const VERSION = "0.0.3"
  21. func (srv *Server) Name() string {
  22. return "docker"
  23. }
  24. // FIXME: Stop violating DRY by repeating usage here and in Subcmd declarations
  25. func (srv *Server) Help() string {
  26. help := "Usage: docker COMMAND [arg...]\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n"
  27. for _, cmd := range [][]interface{}{
  28. {"run", "Run a command in a container"},
  29. {"ps", "Display a list of containers"},
  30. {"import", "Create a new filesystem image from the contents of a tarball"},
  31. {"attach", "Attach to a running container"},
  32. {"commit", "Create a new image from a container's changes"},
  33. {"diff", "Inspect changes on a container's filesystem"},
  34. {"images", "List images"},
  35. {"info", "Display system-wide information"},
  36. {"inspect", "Return low-level information on a container"},
  37. {"kill", "Kill a running container"},
  38. {"login", "Register or Login to the docker registry server"},
  39. {"logs", "Fetch the logs of a container"},
  40. {"port", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT"},
  41. {"ps", "List containers"},
  42. {"restart", "Restart a running container"},
  43. {"rm", "Remove a container"},
  44. {"rmi", "Remove an image"},
  45. {"run", "Run a command in a new container"},
  46. {"start", "Start a stopped container"},
  47. {"stop", "Stop a running container"},
  48. {"tar", "Stream the contents of a container as a tar archive"},
  49. {"version", "Show the docker version information"},
  50. {"wait", "Block until a container stops, then print its exit code"},
  51. } {
  52. help += fmt.Sprintf(" %-10.10s%s\n", cmd[0], cmd[1])
  53. }
  54. return help
  55. }
  56. // 'docker login': login / register a user to registry service.
  57. func (srv *Server) CmdLogin(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  58. cmd := rcli.Subcmd(stdout, "login", "", "Register or Login to the docker registry server")
  59. if err := cmd.Parse(args); err != nil {
  60. return nil
  61. }
  62. var username string
  63. var password string
  64. var email string
  65. authConfig, err := auth.LoadConfig()
  66. if err != nil {
  67. fmt.Fprintf(stdout, "Error : %s\n", err)
  68. }
  69. fmt.Fprint(stdout, "Username (", authConfig.Username, "): ")
  70. fmt.Fscanf(stdin, "%s", &username)
  71. if username == "" {
  72. username = authConfig.Username
  73. }
  74. if username != authConfig.Username {
  75. fmt.Fprint(stdout, "Password: ")
  76. fmt.Fscanf(stdin, "%s", &password)
  77. if password == "" {
  78. return errors.New("Error : Password Required\n")
  79. }
  80. fmt.Fprint(stdout, "Email (", authConfig.Email, "): ")
  81. fmt.Fscanf(stdin, "%s", &email)
  82. if email == "" {
  83. email = authConfig.Email
  84. }
  85. } else {
  86. password = authConfig.Password
  87. email = authConfig.Email
  88. }
  89. newAuthConfig := auth.AuthConfig{Username: username, Password: password, Email: email}
  90. status, err := auth.Login(newAuthConfig)
  91. if err != nil {
  92. fmt.Fprintf(stdout, "Error : %s\n", err)
  93. }
  94. if status != "" {
  95. fmt.Fprintf(stdout, status)
  96. }
  97. return nil
  98. }
  99. // 'docker wait': block until a container stops
  100. func (srv *Server) CmdWait(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  101. cmd := rcli.Subcmd(stdout, "wait", "[OPTIONS] NAME", "Block until a container stops, then print its exit code.")
  102. if err := cmd.Parse(args); err != nil {
  103. return nil
  104. }
  105. if cmd.NArg() < 1 {
  106. cmd.Usage()
  107. return nil
  108. }
  109. for _, name := range cmd.Args() {
  110. if container := srv.runtime.Get(name); container != nil {
  111. fmt.Fprintln(stdout, container.Wait())
  112. } else {
  113. return errors.New("No such container: " + name)
  114. }
  115. }
  116. return nil
  117. }
  118. // 'docker version': show version information
  119. func (srv *Server) CmdVersion(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  120. fmt.Fprintf(stdout, "Version:%s\n", VERSION)
  121. return nil
  122. }
  123. // 'docker info': display system-wide information.
  124. func (srv *Server) CmdInfo(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  125. images, _ := srv.runtime.graph.All()
  126. var imgcount int
  127. if images == nil {
  128. imgcount = 0
  129. } else {
  130. imgcount = len(images)
  131. }
  132. cmd := rcli.Subcmd(stdout, "info", "", "Display system-wide information.")
  133. if err := cmd.Parse(args); err != nil {
  134. return nil
  135. }
  136. if cmd.NArg() > 0 {
  137. cmd.Usage()
  138. return nil
  139. }
  140. fmt.Fprintf(stdout, "containers: %d\nversion: %s\nimages: %d\n",
  141. len(srv.runtime.List()),
  142. VERSION,
  143. imgcount)
  144. return nil
  145. }
  146. func (srv *Server) CmdStop(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  147. cmd := rcli.Subcmd(stdout, "stop", "[OPTIONS] NAME", "Stop a running container")
  148. if err := cmd.Parse(args); err != nil {
  149. return nil
  150. }
  151. if cmd.NArg() < 1 {
  152. cmd.Usage()
  153. return nil
  154. }
  155. for _, name := range cmd.Args() {
  156. if container := srv.runtime.Get(name); container != nil {
  157. if err := container.Stop(); err != nil {
  158. return err
  159. }
  160. fmt.Fprintln(stdout, container.Id)
  161. } else {
  162. return errors.New("No such container: " + name)
  163. }
  164. }
  165. return nil
  166. }
  167. func (srv *Server) CmdRestart(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  168. cmd := rcli.Subcmd(stdout, "restart", "[OPTIONS] NAME", "Restart a running container")
  169. if err := cmd.Parse(args); err != nil {
  170. return nil
  171. }
  172. if cmd.NArg() < 1 {
  173. cmd.Usage()
  174. return nil
  175. }
  176. for _, name := range cmd.Args() {
  177. if container := srv.runtime.Get(name); container != nil {
  178. if err := container.Restart(); err != nil {
  179. return err
  180. }
  181. fmt.Fprintln(stdout, container.Id)
  182. } else {
  183. return errors.New("No such container: " + name)
  184. }
  185. }
  186. return nil
  187. }
  188. func (srv *Server) CmdStart(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  189. cmd := rcli.Subcmd(stdout, "start", "[OPTIONS] NAME", "Start a stopped container")
  190. if err := cmd.Parse(args); err != nil {
  191. return nil
  192. }
  193. if cmd.NArg() < 1 {
  194. cmd.Usage()
  195. return nil
  196. }
  197. for _, name := range cmd.Args() {
  198. if container := srv.runtime.Get(name); container != nil {
  199. if err := container.Start(); err != nil {
  200. return err
  201. }
  202. fmt.Fprintln(stdout, container.Id)
  203. } else {
  204. return errors.New("No such container: " + name)
  205. }
  206. }
  207. return nil
  208. }
  209. func (srv *Server) CmdMount(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  210. cmd := rcli.Subcmd(stdout, "umount", "[OPTIONS] NAME", "mount a container's filesystem (debug only)")
  211. if err := cmd.Parse(args); err != nil {
  212. return nil
  213. }
  214. if cmd.NArg() < 1 {
  215. cmd.Usage()
  216. return nil
  217. }
  218. for _, name := range cmd.Args() {
  219. if container := srv.runtime.Get(name); container != nil {
  220. if err := container.EnsureMounted(); err != nil {
  221. return err
  222. }
  223. fmt.Fprintln(stdout, container.Id)
  224. } else {
  225. return errors.New("No such container: " + name)
  226. }
  227. }
  228. return nil
  229. }
  230. func (srv *Server) CmdInspect(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  231. cmd := rcli.Subcmd(stdout, "inspect", "[OPTIONS] CONTAINER", "Return low-level information on a container")
  232. if err := cmd.Parse(args); err != nil {
  233. return nil
  234. }
  235. if cmd.NArg() < 1 {
  236. cmd.Usage()
  237. return nil
  238. }
  239. name := cmd.Arg(0)
  240. var obj interface{}
  241. if container := srv.runtime.Get(name); container != nil {
  242. obj = container
  243. } else if image, err := srv.runtime.graph.Get(name); err != nil {
  244. return err
  245. } else if image != nil {
  246. obj = image
  247. } else {
  248. // No output means the object does not exist
  249. // (easier to script since stdout and stderr are not differentiated atm)
  250. return nil
  251. }
  252. data, err := json.Marshal(obj)
  253. if err != nil {
  254. return err
  255. }
  256. indented := new(bytes.Buffer)
  257. if err = json.Indent(indented, data, "", " "); err != nil {
  258. return err
  259. }
  260. if _, err := io.Copy(stdout, indented); err != nil {
  261. return err
  262. }
  263. stdout.Write([]byte{'\n'})
  264. return nil
  265. }
  266. func (srv *Server) CmdPort(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  267. cmd := rcli.Subcmd(stdout, "port", "[OPTIONS] CONTAINER PRIVATE_PORT", "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT")
  268. if err := cmd.Parse(args); err != nil {
  269. return nil
  270. }
  271. if cmd.NArg() != 2 {
  272. cmd.Usage()
  273. return nil
  274. }
  275. name := cmd.Arg(0)
  276. privatePort := cmd.Arg(1)
  277. if container := srv.runtime.Get(name); container == nil {
  278. return errors.New("No such container: " + name)
  279. } else {
  280. if frontend, exists := container.NetworkSettings.PortMapping[privatePort]; !exists {
  281. return fmt.Errorf("No private port '%s' allocated on %s", privatePort, name)
  282. } else {
  283. fmt.Fprintln(stdout, frontend)
  284. }
  285. }
  286. return nil
  287. }
  288. // 'docker rmi NAME' removes all images with the name NAME
  289. func (srv *Server) CmdRmi(stdin io.ReadCloser, stdout io.Writer, args ...string) (err error) {
  290. cmd := rcli.Subcmd(stdout, "rmimage", "[OPTIONS] IMAGE", "Remove an image")
  291. if cmd.Parse(args) != nil || cmd.NArg() < 1 {
  292. cmd.Usage()
  293. return nil
  294. }
  295. for _, name := range cmd.Args() {
  296. if err := srv.runtime.graph.Delete(name); err != nil {
  297. return err
  298. }
  299. }
  300. return nil
  301. }
  302. func (srv *Server) CmdRm(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  303. cmd := rcli.Subcmd(stdout, "rm", "[OPTIONS] CONTAINER", "Remove a container")
  304. if err := cmd.Parse(args); err != nil {
  305. return nil
  306. }
  307. for _, name := range cmd.Args() {
  308. container := srv.runtime.Get(name)
  309. if container == nil {
  310. return errors.New("No such container: " + name)
  311. }
  312. if err := srv.runtime.Destroy(container); err != nil {
  313. fmt.Fprintln(stdout, "Error destroying container "+name+": "+err.Error())
  314. }
  315. }
  316. return nil
  317. }
  318. // 'docker kill NAME' kills a running container
  319. func (srv *Server) CmdKill(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  320. cmd := rcli.Subcmd(stdout, "kill", "[OPTIONS] CONTAINER [CONTAINER...]", "Kill a running container")
  321. if err := cmd.Parse(args); err != nil {
  322. return nil
  323. }
  324. for _, name := range cmd.Args() {
  325. container := srv.runtime.Get(name)
  326. if container == nil {
  327. return errors.New("No such container: " + name)
  328. }
  329. if err := container.Kill(); err != nil {
  330. fmt.Fprintln(stdout, "Error killing container "+name+": "+err.Error())
  331. }
  332. }
  333. return nil
  334. }
  335. func (srv *Server) CmdImport(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  336. cmd := rcli.Subcmd(stdout, "import", "[OPTIONS] NAME", "Create a new filesystem image from the contents of a tarball")
  337. fl_stdin := cmd.Bool("stdin", false, "Read tarball from stdin")
  338. var archive io.Reader
  339. var resp *http.Response
  340. if err := cmd.Parse(args); err != nil {
  341. return nil
  342. }
  343. name := cmd.Arg(0)
  344. if name == "" {
  345. return errors.New("Not enough arguments")
  346. }
  347. if *fl_stdin {
  348. archive = stdin
  349. } else {
  350. u, err := url.Parse(name)
  351. if err != nil {
  352. return err
  353. }
  354. if u.Scheme == "" {
  355. u.Scheme = "http"
  356. }
  357. if u.Host == "" {
  358. u.Host = "get.docker.io"
  359. u.Path = path.Join("/images", u.Path)
  360. }
  361. fmt.Fprintf(stdout, "Downloading from %s\n", u.String())
  362. // Download with curl (pretty progress bar)
  363. // If curl is not available, fallback to http.Get()
  364. resp, err = future.Download(u.String(), stdout)
  365. if err != nil {
  366. return err
  367. }
  368. archive = future.ProgressReader(resp.Body, int(resp.ContentLength), stdout)
  369. }
  370. fmt.Fprintf(stdout, "Unpacking to %s\n", name)
  371. img, err := srv.runtime.graph.Create(archive, "", "")
  372. if err != nil {
  373. return err
  374. }
  375. fmt.Fprintln(stdout, img.Id)
  376. return nil
  377. }
  378. func (srv *Server) CmdImages(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  379. cmd := rcli.Subcmd(stdout, "images", "[OPTIONS] [NAME]", "List images")
  380. //limit := cmd.Int("l", 0, "Only show the N most recent versions of each image")
  381. quiet := cmd.Bool("q", false, "only show numeric IDs")
  382. if err := cmd.Parse(args); err != nil {
  383. return nil
  384. }
  385. if cmd.NArg() > 1 {
  386. cmd.Usage()
  387. return nil
  388. }
  389. /*
  390. var nameFilter string
  391. if cmd.NArg() == 1 {
  392. nameFilter = cmd.Arg(0)
  393. }
  394. */
  395. w := tabwriter.NewWriter(stdout, 20, 1, 3, ' ', 0)
  396. if !*quiet {
  397. fmt.Fprintf(w, "NAME\tID\tCREATED\tPARENT\n")
  398. }
  399. if *quiet {
  400. images, err := srv.runtime.graph.All()
  401. if err != nil {
  402. return err
  403. }
  404. for _, image := range images {
  405. fmt.Fprintln(stdout, image.Id)
  406. }
  407. } else {
  408. // FIXME:
  409. // paths, err := srv.images.Paths()
  410. // if err != nil {
  411. // return err
  412. // }
  413. // for _, name := range paths {
  414. // if nameFilter != "" && nameFilter != name {
  415. // continue
  416. // }
  417. // ids, err := srv.images.List(name)
  418. // if err != nil {
  419. // return err
  420. // }
  421. // for idx, img := range ids {
  422. // if *limit > 0 && idx >= *limit {
  423. // break
  424. // }
  425. // if !*quiet {
  426. // for idx, field := range []string{
  427. // /* NAME */ name,
  428. // /* ID */ img.Id,
  429. // /* CREATED */ future.HumanDuration(time.Now().Sub(time.Unix(img.Created, 0))) + " ago",
  430. // /* PARENT */ img.Parent,
  431. // } {
  432. // if idx == 0 {
  433. // w.Write([]byte(field))
  434. // } else {
  435. // w.Write([]byte("\t" + field))
  436. // }
  437. // }
  438. // w.Write([]byte{'\n'})
  439. // } else {
  440. // stdout.Write([]byte(img.Id + "\n"))
  441. // }
  442. // }
  443. // }
  444. // if !*quiet {
  445. // w.Flush()
  446. // }
  447. //
  448. }
  449. return nil
  450. }
  451. func (srv *Server) CmdPs(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  452. cmd := rcli.Subcmd(stdout,
  453. "ps", "[OPTIONS]", "List containers")
  454. quiet := cmd.Bool("q", false, "Only display numeric IDs")
  455. fl_all := cmd.Bool("a", false, "Show all containers. Only running containers are shown by default.")
  456. fl_full := cmd.Bool("notrunc", false, "Don't truncate output")
  457. if err := cmd.Parse(args); err != nil {
  458. return nil
  459. }
  460. w := tabwriter.NewWriter(stdout, 12, 1, 3, ' ', 0)
  461. if !*quiet {
  462. fmt.Fprintf(w, "ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tCOMMENT\n")
  463. }
  464. for _, container := range srv.runtime.List() {
  465. if !container.State.Running && !*fl_all {
  466. continue
  467. }
  468. if !*quiet {
  469. command := fmt.Sprintf("%s %s", container.Path, strings.Join(container.Args, " "))
  470. if !*fl_full {
  471. command = Trunc(command, 20)
  472. }
  473. for idx, field := range []string{
  474. /* ID */ container.Id,
  475. /* IMAGE */ container.Image,
  476. /* COMMAND */ command,
  477. /* CREATED */ future.HumanDuration(time.Now().Sub(container.Created)) + " ago",
  478. /* STATUS */ container.State.String(),
  479. /* COMMENT */ "",
  480. } {
  481. if idx == 0 {
  482. w.Write([]byte(field))
  483. } else {
  484. w.Write([]byte("\t" + field))
  485. }
  486. }
  487. w.Write([]byte{'\n'})
  488. } else {
  489. stdout.Write([]byte(container.Id + "\n"))
  490. }
  491. }
  492. if !*quiet {
  493. w.Flush()
  494. }
  495. return nil
  496. }
  497. func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  498. cmd := rcli.Subcmd(stdout,
  499. "commit", "[OPTIONS] CONTAINER [DEST]",
  500. "Create a new image from a container's changes")
  501. if err := cmd.Parse(args); err != nil {
  502. return nil
  503. }
  504. containerName, imgName := cmd.Arg(0), cmd.Arg(1)
  505. if containerName == "" || imgName == "" {
  506. cmd.Usage()
  507. return nil
  508. }
  509. if container := srv.runtime.Get(containerName); container != nil {
  510. // FIXME: freeze the container before copying it to avoid data corruption?
  511. // FIXME: this shouldn't be in commands.
  512. rwTar, err := container.ExportRw()
  513. if err != nil {
  514. return err
  515. }
  516. // Create a new image from the container's base layers + a new layer from container changes
  517. img, err := srv.runtime.graph.Create(rwTar, container.Image, "")
  518. if err != nil {
  519. return err
  520. }
  521. fmt.Fprintln(stdout, img.Id)
  522. return nil
  523. }
  524. return errors.New("No such container: " + containerName)
  525. }
  526. func (srv *Server) CmdTar(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  527. cmd := rcli.Subcmd(stdout,
  528. "tar", "CONTAINER",
  529. "Stream the contents of a container as a tar archive")
  530. fl_sparse := cmd.Bool("s", false, "Generate a sparse tar stream (top layer + reference to bottom layers)")
  531. if err := cmd.Parse(args); err != nil {
  532. return nil
  533. }
  534. if *fl_sparse {
  535. return errors.New("Sparse mode not yet implemented") // FIXME
  536. }
  537. name := cmd.Arg(0)
  538. if container := srv.runtime.Get(name); container != nil {
  539. if err := container.EnsureMounted(); err != nil {
  540. return err
  541. }
  542. data, err := container.Export()
  543. if err != nil {
  544. return err
  545. }
  546. // Stream the entire contents of the container (basically a volatile snapshot)
  547. if _, err := io.Copy(stdout, data); err != nil {
  548. return err
  549. }
  550. return nil
  551. }
  552. return errors.New("No such container: " + name)
  553. }
  554. func (srv *Server) CmdDiff(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  555. cmd := rcli.Subcmd(stdout,
  556. "diff", "CONTAINER [OPTIONS]",
  557. "Inspect changes on a container's filesystem")
  558. if err := cmd.Parse(args); err != nil {
  559. return nil
  560. }
  561. if cmd.NArg() < 1 {
  562. return errors.New("Not enough arguments")
  563. }
  564. if container := srv.runtime.Get(cmd.Arg(0)); container == nil {
  565. return errors.New("No such container")
  566. } else {
  567. changes, err := container.Changes()
  568. if err != nil {
  569. return err
  570. }
  571. for _, change := range changes {
  572. fmt.Fprintln(stdout, change.String())
  573. }
  574. }
  575. return nil
  576. }
  577. func (srv *Server) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  578. cmd := rcli.Subcmd(stdout, "logs", "[OPTIONS] CONTAINER", "Fetch the logs of a container")
  579. if err := cmd.Parse(args); err != nil {
  580. return nil
  581. }
  582. if cmd.NArg() != 1 {
  583. cmd.Usage()
  584. return nil
  585. }
  586. name := cmd.Arg(0)
  587. if container := srv.runtime.Get(name); container != nil {
  588. log_stdout, err := container.ReadLog("stdout")
  589. if err != nil {
  590. return err
  591. }
  592. log_stderr, err := container.ReadLog("stderr")
  593. if err != nil {
  594. return err
  595. }
  596. // FIXME: Interpolate stdout and stderr instead of concatenating them
  597. // FIXME: Differentiate stdout and stderr in the remote protocol
  598. if _, err := io.Copy(stdout, log_stdout); err != nil {
  599. return err
  600. }
  601. if _, err := io.Copy(stdout, log_stderr); err != nil {
  602. return err
  603. }
  604. return nil
  605. }
  606. return errors.New("No such container: " + cmd.Arg(0))
  607. }
  608. func (srv *Server) CmdAttach(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  609. cmd := rcli.Subcmd(stdout, "attach", "[OPTIONS]", "Attach to a running container")
  610. fl_i := cmd.Bool("i", false, "Attach to stdin")
  611. fl_o := cmd.Bool("o", true, "Attach to stdout")
  612. fl_e := cmd.Bool("e", true, "Attach to stderr")
  613. if err := cmd.Parse(args); err != nil {
  614. return nil
  615. }
  616. if cmd.NArg() != 1 {
  617. cmd.Usage()
  618. return nil
  619. }
  620. name := cmd.Arg(0)
  621. container := srv.runtime.Get(name)
  622. if container == nil {
  623. return errors.New("No such container: " + name)
  624. }
  625. var wg sync.WaitGroup
  626. if *fl_i {
  627. c_stdin, err := container.StdinPipe()
  628. if err != nil {
  629. return err
  630. }
  631. wg.Add(1)
  632. go func() { io.Copy(c_stdin, stdin); wg.Add(-1) }()
  633. }
  634. if *fl_o {
  635. c_stdout, err := container.StdoutPipe()
  636. if err != nil {
  637. return err
  638. }
  639. wg.Add(1)
  640. go func() { io.Copy(stdout, c_stdout); wg.Add(-1) }()
  641. }
  642. if *fl_e {
  643. c_stderr, err := container.StderrPipe()
  644. if err != nil {
  645. return err
  646. }
  647. wg.Add(1)
  648. go func() { io.Copy(stdout, c_stderr); wg.Add(-1) }()
  649. }
  650. wg.Wait()
  651. return nil
  652. }
  653. // Ports type - Used to parse multiple -p flags
  654. type ports []int
  655. func (p *ports) String() string {
  656. return fmt.Sprint(*p)
  657. }
  658. func (p *ports) Set(value string) error {
  659. port, err := strconv.Atoi(value)
  660. if err != nil {
  661. return fmt.Errorf("Invalid port: %v", value)
  662. }
  663. *p = append(*p, port)
  664. return nil
  665. }
  666. func (srv *Server) CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
  667. cmd := rcli.Subcmd(stdout, "run", "[OPTIONS] IMAGE COMMAND [ARG...]", "Run a command in a new container")
  668. fl_user := cmd.String("u", "", "Username or UID")
  669. fl_attach := cmd.Bool("a", false, "Attach stdin and stdout")
  670. fl_stdin := cmd.Bool("i", false, "Keep stdin open even if not attached")
  671. fl_tty := cmd.Bool("t", false, "Allocate a pseudo-tty")
  672. fl_memory := cmd.Int64("m", 0, "Memory limit (in bytes)")
  673. var fl_ports ports
  674. cmd.Var(&fl_ports, "p", "Map a network port to the container")
  675. if err := cmd.Parse(args); err != nil {
  676. return nil
  677. }
  678. name := cmd.Arg(0)
  679. var cmdline []string
  680. if len(cmd.Args()) >= 2 {
  681. cmdline = cmd.Args()[1:]
  682. }
  683. // Choose a default image if needed
  684. if name == "" {
  685. name = "base"
  686. }
  687. // Choose a default command if needed
  688. if len(cmdline) == 0 {
  689. *fl_stdin = true
  690. *fl_tty = true
  691. *fl_attach = true
  692. cmdline = []string{"/bin/bash", "-i"}
  693. }
  694. // Create new container
  695. container, err := srv.runtime.Create(cmdline[0], cmdline[1:], name,
  696. &Config{
  697. Ports: fl_ports,
  698. User: *fl_user,
  699. Tty: *fl_tty,
  700. OpenStdin: *fl_stdin,
  701. Memory: *fl_memory,
  702. })
  703. if err != nil {
  704. return errors.New("Error creating container: " + err.Error())
  705. }
  706. if *fl_stdin {
  707. cmd_stdin, err := container.StdinPipe()
  708. if err != nil {
  709. return err
  710. }
  711. if *fl_attach {
  712. future.Go(func() error {
  713. _, err := io.Copy(cmd_stdin, stdin)
  714. cmd_stdin.Close()
  715. return err
  716. })
  717. }
  718. }
  719. // Run the container
  720. if *fl_attach {
  721. cmd_stderr, err := container.StderrPipe()
  722. if err != nil {
  723. return err
  724. }
  725. cmd_stdout, err := container.StdoutPipe()
  726. if err != nil {
  727. return err
  728. }
  729. if err := container.Start(); err != nil {
  730. return err
  731. }
  732. sending_stdout := future.Go(func() error {
  733. _, err := io.Copy(stdout, cmd_stdout)
  734. return err
  735. })
  736. sending_stderr := future.Go(func() error {
  737. _, err := io.Copy(stdout, cmd_stderr)
  738. return err
  739. })
  740. err_sending_stdout := <-sending_stdout
  741. err_sending_stderr := <-sending_stderr
  742. if err_sending_stdout != nil {
  743. return err_sending_stdout
  744. }
  745. if err_sending_stderr != nil {
  746. return err_sending_stderr
  747. }
  748. container.Wait()
  749. } else {
  750. if err := container.Start(); err != nil {
  751. return err
  752. }
  753. fmt.Fprintln(stdout, container.Id)
  754. }
  755. return nil
  756. }
  757. func NewServer() (*Server, error) {
  758. future.Seed()
  759. // if err != nil {
  760. // return nil, err
  761. // }
  762. runtime, err := New()
  763. if err != nil {
  764. return nil, err
  765. }
  766. srv := &Server{
  767. runtime: runtime,
  768. }
  769. return srv, nil
  770. }
  771. type Server struct {
  772. runtime *Runtime
  773. }