start.go 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163
  1. package client
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "io"
  6. "net/url"
  7. "os"
  8. "github.com/Sirupsen/logrus"
  9. "github.com/docker/docker/api/types"
  10. flag "github.com/docker/docker/pkg/mflag"
  11. "github.com/docker/docker/pkg/promise"
  12. "github.com/docker/docker/pkg/signal"
  13. )
  14. func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {
  15. sigc := make(chan os.Signal, 128)
  16. signal.CatchAll(sigc)
  17. go func() {
  18. for s := range sigc {
  19. if s == signal.SIGCHLD {
  20. continue
  21. }
  22. var sig string
  23. for sigStr, sigN := range signal.SignalMap {
  24. if sigN == s {
  25. sig = sigStr
  26. break
  27. }
  28. }
  29. if sig == "" {
  30. logrus.Errorf("Unsupported signal: %v. Discarding.", s)
  31. }
  32. if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%s", cid, sig), nil, nil)); err != nil {
  33. logrus.Debugf("Error sending signal: %s", err)
  34. }
  35. }
  36. }()
  37. return sigc
  38. }
  39. // CmdStart starts one or more stopped containers.
  40. //
  41. // Usage: docker start [OPTIONS] CONTAINER [CONTAINER...]
  42. func (cli *DockerCli) CmdStart(args ...string) error {
  43. var (
  44. cErr chan error
  45. tty bool
  46. cmd = cli.Subcmd("start", "CONTAINER [CONTAINER...]", "Start one or more stopped containers", true)
  47. attach = cmd.Bool([]string{"a", "-attach"}, false, "Attach STDOUT/STDERR and forward signals")
  48. openStdin = cmd.Bool([]string{"i", "-interactive"}, false, "Attach container's STDIN")
  49. )
  50. cmd.Require(flag.Min, 1)
  51. cmd.ParseFlags(args, true)
  52. if *attach || *openStdin {
  53. if cmd.NArg() > 1 {
  54. return fmt.Errorf("You cannot start and attach multiple containers at once.")
  55. }
  56. stream, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil, nil)
  57. if err != nil {
  58. return err
  59. }
  60. var c types.ContainerJSON
  61. if err := json.NewDecoder(stream).Decode(&c); err != nil {
  62. return err
  63. }
  64. tty = c.Config.Tty
  65. if !tty {
  66. sigc := cli.forwardAllSignals(cmd.Arg(0))
  67. defer signal.StopCatch(sigc)
  68. }
  69. var in io.ReadCloser
  70. v := url.Values{}
  71. v.Set("stream", "1")
  72. if *openStdin && c.Config.OpenStdin {
  73. v.Set("stdin", "1")
  74. in = cli.in
  75. }
  76. v.Set("stdout", "1")
  77. v.Set("stderr", "1")
  78. hijacked := make(chan io.Closer)
  79. // Block the return until the chan gets closed
  80. defer func() {
  81. logrus.Debugf("CmdStart() returned, defer waiting for hijack to finish.")
  82. if _, ok := <-hijacked; ok {
  83. logrus.Errorf("Hijack did not finish (chan still open)")
  84. }
  85. cli.in.Close()
  86. }()
  87. cErr = promise.Go(func() error {
  88. return cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), tty, in, cli.out, cli.err, hijacked, nil)
  89. })
  90. // Acknowledge the hijack before starting
  91. select {
  92. case closer := <-hijacked:
  93. // Make sure that the hijack gets closed when returning (results
  94. // in closing the hijack chan and freeing server's goroutines)
  95. if closer != nil {
  96. defer closer.Close()
  97. }
  98. case err := <-cErr:
  99. if err != nil {
  100. return err
  101. }
  102. }
  103. }
  104. var encounteredError error
  105. for _, name := range cmd.Args() {
  106. _, _, err := readBody(cli.call("POST", "/containers/"+name+"/start", nil, nil))
  107. if err != nil {
  108. if !*attach && !*openStdin {
  109. // attach and openStdin is false means it could be starting multiple containers
  110. // when a container start failed, show the error message and start next
  111. fmt.Fprintf(cli.err, "%s\n", err)
  112. encounteredError = fmt.Errorf("Error: failed to start one or more containers")
  113. } else {
  114. encounteredError = err
  115. }
  116. } else {
  117. if !*attach && !*openStdin {
  118. fmt.Fprintf(cli.out, "%s\n", name)
  119. }
  120. }
  121. }
  122. if encounteredError != nil {
  123. return encounteredError
  124. }
  125. if *openStdin || *attach {
  126. if tty && cli.isTerminalOut {
  127. if err := cli.monitorTtySize(cmd.Arg(0), false); err != nil {
  128. logrus.Errorf("Error monitoring TTY size: %s", err)
  129. }
  130. }
  131. if attchErr := <-cErr; attchErr != nil {
  132. return attchErr
  133. }
  134. _, status, err := getExitCode(cli, cmd.Arg(0))
  135. if err != nil {
  136. return err
  137. }
  138. if status != 0 {
  139. return StatusError{StatusCode: status}
  140. }
  141. }
  142. return nil
  143. }