create.go 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220
  1. package container
  2. import (
  3. "fmt"
  4. "io"
  5. "os"
  6. "github.com/docker/distribution/reference"
  7. "github.com/docker/docker/api/types"
  8. "github.com/docker/docker/api/types/container"
  9. networktypes "github.com/docker/docker/api/types/network"
  10. "github.com/docker/docker/cli"
  11. "github.com/docker/docker/cli/command"
  12. "github.com/docker/docker/cli/command/image"
  13. apiclient "github.com/docker/docker/client"
  14. "github.com/docker/docker/pkg/jsonmessage"
  15. "github.com/docker/docker/registry"
  16. "github.com/spf13/cobra"
  17. "github.com/spf13/pflag"
  18. "golang.org/x/net/context"
  19. )
  20. type createOptions struct {
  21. name string
  22. }
  23. // NewCreateCommand creates a new cobra.Command for `docker create`
  24. func NewCreateCommand(dockerCli *command.DockerCli) *cobra.Command {
  25. var opts createOptions
  26. var copts *containerOptions
  27. cmd := &cobra.Command{
  28. Use: "create [OPTIONS] IMAGE [COMMAND] [ARG...]",
  29. Short: "Create a new container",
  30. Args: cli.RequiresMinArgs(1),
  31. RunE: func(cmd *cobra.Command, args []string) error {
  32. copts.Image = args[0]
  33. if len(args) > 1 {
  34. copts.Args = args[1:]
  35. }
  36. return runCreate(dockerCli, cmd.Flags(), &opts, copts)
  37. },
  38. }
  39. flags := cmd.Flags()
  40. flags.SetInterspersed(false)
  41. flags.StringVar(&opts.name, "name", "", "Assign a name to the container")
  42. // Add an explicit help that doesn't have a `-h` to prevent the conflict
  43. // with hostname
  44. flags.Bool("help", false, "Print usage")
  45. command.AddTrustVerificationFlags(flags)
  46. copts = addFlags(flags)
  47. return cmd
  48. }
  49. func runCreate(dockerCli *command.DockerCli, flags *pflag.FlagSet, opts *createOptions, copts *containerOptions) error {
  50. config, hostConfig, networkingConfig, err := parse(flags, copts)
  51. if err != nil {
  52. reportError(dockerCli.Err(), "create", err.Error(), true)
  53. return cli.StatusError{StatusCode: 125}
  54. }
  55. response, err := createContainer(context.Background(), dockerCli, config, hostConfig, networkingConfig, hostConfig.ContainerIDFile, opts.name)
  56. if err != nil {
  57. return err
  58. }
  59. fmt.Fprintln(dockerCli.Out(), response.ID)
  60. return nil
  61. }
  62. func pullImage(ctx context.Context, dockerCli *command.DockerCli, image string, out io.Writer) error {
  63. ref, err := reference.ParseNormalizedNamed(image)
  64. if err != nil {
  65. return err
  66. }
  67. // Resolve the Repository name from fqn to RepositoryInfo
  68. repoInfo, err := registry.ParseRepositoryInfo(ref)
  69. if err != nil {
  70. return err
  71. }
  72. authConfig := command.ResolveAuthConfig(ctx, dockerCli, repoInfo.Index)
  73. encodedAuth, err := command.EncodeAuthToBase64(authConfig)
  74. if err != nil {
  75. return err
  76. }
  77. options := types.ImageCreateOptions{
  78. RegistryAuth: encodedAuth,
  79. }
  80. responseBody, err := dockerCli.Client().ImageCreate(ctx, image, options)
  81. if err != nil {
  82. return err
  83. }
  84. defer responseBody.Close()
  85. return jsonmessage.DisplayJSONMessagesStream(
  86. responseBody,
  87. out,
  88. dockerCli.Out().FD(),
  89. dockerCli.Out().IsTerminal(),
  90. nil)
  91. }
  92. type cidFile struct {
  93. path string
  94. file *os.File
  95. written bool
  96. }
  97. func (cid *cidFile) Close() error {
  98. cid.file.Close()
  99. if cid.written {
  100. return nil
  101. }
  102. if err := os.Remove(cid.path); err != nil {
  103. return fmt.Errorf("failed to remove the CID file '%s': %s \n", cid.path, err)
  104. }
  105. return nil
  106. }
  107. func (cid *cidFile) Write(id string) error {
  108. if _, err := cid.file.Write([]byte(id)); err != nil {
  109. return fmt.Errorf("Failed to write the container ID to the file: %s", err)
  110. }
  111. cid.written = true
  112. return nil
  113. }
  114. func newCIDFile(path string) (*cidFile, error) {
  115. if _, err := os.Stat(path); err == nil {
  116. return nil, fmt.Errorf("Container ID file found, make sure the other container isn't running or delete %s", path)
  117. }
  118. f, err := os.Create(path)
  119. if err != nil {
  120. return nil, fmt.Errorf("Failed to create the container ID file: %s", err)
  121. }
  122. return &cidFile{path: path, file: f}, nil
  123. }
  124. func createContainer(ctx context.Context, dockerCli *command.DockerCli, config *container.Config, hostConfig *container.HostConfig, networkingConfig *networktypes.NetworkingConfig, cidfile, name string) (*container.ContainerCreateCreatedBody, error) {
  125. stderr := dockerCli.Err()
  126. var (
  127. containerIDFile *cidFile
  128. trustedRef reference.Canonical
  129. namedRef reference.Named
  130. )
  131. if cidfile != "" {
  132. var err error
  133. if containerIDFile, err = newCIDFile(cidfile); err != nil {
  134. return nil, err
  135. }
  136. defer containerIDFile.Close()
  137. }
  138. ref, err := reference.ParseAnyReference(config.Image)
  139. if err != nil {
  140. return nil, err
  141. }
  142. if named, ok := ref.(reference.Named); ok {
  143. namedRef = reference.TagNameOnly(named)
  144. if taggedRef, ok := namedRef.(reference.NamedTagged); ok && command.IsTrusted() {
  145. var err error
  146. trustedRef, err = image.TrustedReference(ctx, dockerCli, taggedRef, nil)
  147. if err != nil {
  148. return nil, err
  149. }
  150. config.Image = reference.FamiliarString(trustedRef)
  151. }
  152. }
  153. //create the container
  154. response, err := dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)
  155. //if image not found try to pull it
  156. if err != nil {
  157. if apiclient.IsErrImageNotFound(err) && namedRef != nil {
  158. fmt.Fprintf(stderr, "Unable to find image '%s' locally\n", reference.FamiliarString(namedRef))
  159. // we don't want to write to stdout anything apart from container.ID
  160. if err = pullImage(ctx, dockerCli, config.Image, stderr); err != nil {
  161. return nil, err
  162. }
  163. if taggedRef, ok := namedRef.(reference.NamedTagged); ok && trustedRef != nil {
  164. if err := image.TagTrusted(ctx, dockerCli, trustedRef, taggedRef); err != nil {
  165. return nil, err
  166. }
  167. }
  168. // Retry
  169. var retryErr error
  170. response, retryErr = dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)
  171. if retryErr != nil {
  172. return nil, retryErr
  173. }
  174. } else {
  175. return nil, err
  176. }
  177. }
  178. for _, warning := range response.Warnings {
  179. fmt.Fprintf(stderr, "WARNING: %s\n", warning)
  180. }
  181. if containerIDFile != nil {
  182. if err = containerIDFile.Write(response.ID); err != nil {
  183. return nil, err
  184. }
  185. }
  186. return &response, nil
  187. }