builder.go 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386
  1. package dockerfile
  2. import (
  3. "bytes"
  4. "errors"
  5. "fmt"
  6. "io"
  7. "io/ioutil"
  8. "os"
  9. "sort"
  10. "strings"
  11. "github.com/Sirupsen/logrus"
  12. "github.com/docker/distribution/reference"
  13. apierrors "github.com/docker/docker/api/errors"
  14. "github.com/docker/docker/api/types"
  15. "github.com/docker/docker/api/types/backend"
  16. "github.com/docker/docker/api/types/container"
  17. "github.com/docker/docker/builder"
  18. "github.com/docker/docker/builder/dockerfile/parser"
  19. "github.com/docker/docker/image"
  20. "github.com/docker/docker/pkg/stringid"
  21. perrors "github.com/pkg/errors"
  22. "golang.org/x/net/context"
  23. )
  24. var validCommitCommands = map[string]bool{
  25. "cmd": true,
  26. "entrypoint": true,
  27. "healthcheck": true,
  28. "env": true,
  29. "expose": true,
  30. "label": true,
  31. "onbuild": true,
  32. "user": true,
  33. "volume": true,
  34. "workdir": true,
  35. }
  36. // BuiltinAllowedBuildArgs is list of built-in allowed build args
  37. // these args are considered transparent and are excluded from the image history.
  38. // Filtering from history is implemented in dispatchers.go
  39. var BuiltinAllowedBuildArgs = map[string]bool{
  40. "HTTP_PROXY": true,
  41. "http_proxy": true,
  42. "HTTPS_PROXY": true,
  43. "https_proxy": true,
  44. "FTP_PROXY": true,
  45. "ftp_proxy": true,
  46. "NO_PROXY": true,
  47. "no_proxy": true,
  48. }
  49. var defaultLogConfig = container.LogConfig{Type: "none"}
  50. // Builder is a Dockerfile builder
  51. // It implements the builder.Backend interface.
  52. type Builder struct {
  53. options *types.ImageBuildOptions
  54. Stdout io.Writer
  55. Stderr io.Writer
  56. Output io.Writer
  57. docker builder.Backend
  58. context builder.Context
  59. clientCtx context.Context
  60. cancel context.CancelFunc
  61. dockerfile *parser.Node
  62. runConfig *container.Config // runconfig for cmd, run, entrypoint etc.
  63. flags *BFlags
  64. tmpContainers map[string]struct{}
  65. image string // imageID
  66. noBaseImage bool
  67. maintainer string
  68. cmdSet bool
  69. disableCommit bool
  70. cacheBusted bool
  71. allowedBuildArgs map[string]bool // list of build-time args that are allowed for expansion/substitution and passing to commands in 'run'.
  72. directive parser.Directive
  73. // TODO: remove once docker.Commit can receive a tag
  74. id string
  75. imageCache builder.ImageCache
  76. from builder.Image
  77. }
  78. // BuildManager implements builder.Backend and is shared across all Builder objects.
  79. type BuildManager struct {
  80. backend builder.Backend
  81. }
  82. // NewBuildManager creates a BuildManager.
  83. func NewBuildManager(b builder.Backend) (bm *BuildManager) {
  84. return &BuildManager{backend: b}
  85. }
  86. // BuildFromContext builds a new image from a given context.
  87. func (bm *BuildManager) BuildFromContext(ctx context.Context, src io.ReadCloser, remote string, buildOptions *types.ImageBuildOptions, pg backend.ProgressWriter) (string, error) {
  88. if buildOptions.Squash && !bm.backend.HasExperimental() {
  89. return "", apierrors.NewBadRequestError(errors.New("squash is only supported with experimental mode"))
  90. }
  91. buildContext, dockerfileName, err := builder.DetectContextFromRemoteURL(src, remote, pg.ProgressReaderFunc)
  92. if err != nil {
  93. return "", err
  94. }
  95. defer func() {
  96. if err := buildContext.Close(); err != nil {
  97. logrus.Debugf("[BUILDER] failed to remove temporary context: %v", err)
  98. }
  99. }()
  100. if len(dockerfileName) > 0 {
  101. buildOptions.Dockerfile = dockerfileName
  102. }
  103. b, err := NewBuilder(ctx, buildOptions, bm.backend, builder.DockerIgnoreContext{ModifiableContext: buildContext}, nil)
  104. if err != nil {
  105. return "", err
  106. }
  107. return b.build(pg.StdoutFormatter, pg.StderrFormatter, pg.Output)
  108. }
  109. // NewBuilder creates a new Dockerfile builder from an optional dockerfile and a Config.
  110. // If dockerfile is nil, the Dockerfile specified by Config.DockerfileName,
  111. // will be read from the Context passed to Build().
  112. func NewBuilder(clientCtx context.Context, config *types.ImageBuildOptions, backend builder.Backend, buildContext builder.Context, dockerfile io.ReadCloser) (b *Builder, err error) {
  113. if config == nil {
  114. config = new(types.ImageBuildOptions)
  115. }
  116. if config.BuildArgs == nil {
  117. config.BuildArgs = make(map[string]*string)
  118. }
  119. ctx, cancel := context.WithCancel(clientCtx)
  120. b = &Builder{
  121. clientCtx: ctx,
  122. cancel: cancel,
  123. options: config,
  124. Stdout: os.Stdout,
  125. Stderr: os.Stderr,
  126. docker: backend,
  127. context: buildContext,
  128. runConfig: new(container.Config),
  129. tmpContainers: map[string]struct{}{},
  130. id: stringid.GenerateNonCryptoID(),
  131. allowedBuildArgs: make(map[string]bool),
  132. directive: parser.Directive{
  133. EscapeSeen: false,
  134. LookingForDirectives: true,
  135. },
  136. }
  137. if icb, ok := backend.(builder.ImageCacheBuilder); ok {
  138. b.imageCache = icb.MakeImageCache(config.CacheFrom)
  139. }
  140. parser.SetEscapeToken(parser.DefaultEscapeToken, &b.directive) // Assume the default token for escape
  141. if dockerfile != nil {
  142. b.dockerfile, err = parser.Parse(dockerfile, &b.directive)
  143. if err != nil {
  144. return nil, err
  145. }
  146. }
  147. return b, nil
  148. }
  149. // sanitizeRepoAndTags parses the raw "t" parameter received from the client
  150. // to a slice of repoAndTag.
  151. // It also validates each repoName and tag.
  152. func sanitizeRepoAndTags(names []string) ([]reference.Named, error) {
  153. var (
  154. repoAndTags []reference.Named
  155. // This map is used for deduplicating the "-t" parameter.
  156. uniqNames = make(map[string]struct{})
  157. )
  158. for _, repo := range names {
  159. if repo == "" {
  160. continue
  161. }
  162. ref, err := reference.ParseNormalizedNamed(repo)
  163. if err != nil {
  164. return nil, err
  165. }
  166. if _, isCanonical := ref.(reference.Canonical); isCanonical {
  167. return nil, errors.New("build tag cannot contain a digest")
  168. }
  169. ref = reference.TagNameOnly(ref)
  170. nameWithTag := ref.String()
  171. if _, exists := uniqNames[nameWithTag]; !exists {
  172. uniqNames[nameWithTag] = struct{}{}
  173. repoAndTags = append(repoAndTags, ref)
  174. }
  175. }
  176. return repoAndTags, nil
  177. }
  178. func (b *Builder) processLabels() error {
  179. if len(b.options.Labels) == 0 {
  180. return nil
  181. }
  182. var labels []string
  183. for k, v := range b.options.Labels {
  184. labels = append(labels, fmt.Sprintf("%q='%s'", k, v))
  185. }
  186. // Sort the label to have a repeatable order
  187. sort.Strings(labels)
  188. line := "LABEL " + strings.Join(labels, " ")
  189. _, node, err := parser.ParseLine(line, &b.directive, false)
  190. if err != nil {
  191. return err
  192. }
  193. b.dockerfile.Children = append(b.dockerfile.Children, node)
  194. return nil
  195. }
  196. // build runs the Dockerfile builder from a context and a docker object that allows to make calls
  197. // to Docker.
  198. //
  199. // This will (barring errors):
  200. //
  201. // * read the dockerfile from context
  202. // * parse the dockerfile if not already parsed
  203. // * walk the AST and execute it by dispatching to handlers. If Remove
  204. // or ForceRemove is set, additional cleanup around containers happens after
  205. // processing.
  206. // * Tag image, if applicable.
  207. // * Print a happy message and return the image ID.
  208. //
  209. func (b *Builder) build(stdout io.Writer, stderr io.Writer, out io.Writer) (string, error) {
  210. b.Stdout = stdout
  211. b.Stderr = stderr
  212. b.Output = out
  213. // If Dockerfile was not parsed yet, extract it from the Context
  214. if b.dockerfile == nil {
  215. if err := b.readDockerfile(); err != nil {
  216. return "", err
  217. }
  218. }
  219. repoAndTags, err := sanitizeRepoAndTags(b.options.Tags)
  220. if err != nil {
  221. return "", err
  222. }
  223. if err := b.processLabels(); err != nil {
  224. return "", err
  225. }
  226. var shortImgID string
  227. total := len(b.dockerfile.Children)
  228. for _, n := range b.dockerfile.Children {
  229. if err := b.checkDispatch(n, false); err != nil {
  230. return "", perrors.Wrapf(err, "Dockerfile parse error line %d", n.StartLine)
  231. }
  232. }
  233. for i, n := range b.dockerfile.Children {
  234. select {
  235. case <-b.clientCtx.Done():
  236. logrus.Debug("Builder: build cancelled!")
  237. fmt.Fprint(b.Stdout, "Build cancelled")
  238. return "", errors.New("Build cancelled")
  239. default:
  240. // Not cancelled yet, keep going...
  241. }
  242. if err := b.dispatch(i, total, n); err != nil {
  243. if b.options.ForceRemove {
  244. b.clearTmp()
  245. }
  246. return "", err
  247. }
  248. shortImgID = stringid.TruncateID(b.image)
  249. fmt.Fprintf(b.Stdout, " ---> %s\n", shortImgID)
  250. if b.options.Remove {
  251. b.clearTmp()
  252. }
  253. }
  254. b.warnOnUnusedBuildArgs()
  255. if b.image == "" {
  256. return "", errors.New("No image was generated. Is your Dockerfile empty?")
  257. }
  258. if b.options.Squash {
  259. var fromID string
  260. if b.from != nil {
  261. fromID = b.from.ImageID()
  262. }
  263. b.image, err = b.docker.SquashImage(b.image, fromID)
  264. if err != nil {
  265. return "", perrors.Wrap(err, "error squashing image")
  266. }
  267. }
  268. imageID := image.ID(b.image)
  269. for _, rt := range repoAndTags {
  270. if err := b.docker.TagImageWithReference(imageID, rt); err != nil {
  271. return "", err
  272. }
  273. }
  274. fmt.Fprintf(b.Stdout, "Successfully built %s\n", shortImgID)
  275. return b.image, nil
  276. }
  277. // check if there are any leftover build-args that were passed but not
  278. // consumed during build. Print a warning, if there are any.
  279. func (b *Builder) warnOnUnusedBuildArgs() {
  280. leftoverArgs := []string{}
  281. for arg := range b.options.BuildArgs {
  282. if !b.isBuildArgAllowed(arg) {
  283. leftoverArgs = append(leftoverArgs, arg)
  284. }
  285. }
  286. if len(leftoverArgs) > 0 {
  287. fmt.Fprintf(b.Stderr, "[Warning] One or more build-args %v were not consumed\n", leftoverArgs)
  288. }
  289. }
  290. // Cancel cancels an ongoing Dockerfile build.
  291. func (b *Builder) Cancel() {
  292. b.cancel()
  293. }
  294. // BuildFromConfig builds directly from `changes`, treating it as if it were the contents of a Dockerfile
  295. // It will:
  296. // - Call parse.Parse() to get an AST root for the concatenated Dockerfile entries.
  297. // - Do build by calling builder.dispatch() to call all entries' handling routines
  298. //
  299. // BuildFromConfig is used by the /commit endpoint, with the changes
  300. // coming from the query parameter of the same name.
  301. //
  302. // TODO: Remove?
  303. func BuildFromConfig(config *container.Config, changes []string) (*container.Config, error) {
  304. b, err := NewBuilder(context.Background(), nil, nil, nil, nil)
  305. if err != nil {
  306. return nil, err
  307. }
  308. ast, err := parser.Parse(bytes.NewBufferString(strings.Join(changes, "\n")), &b.directive)
  309. if err != nil {
  310. return nil, err
  311. }
  312. // ensure that the commands are valid
  313. for _, n := range ast.Children {
  314. if !validCommitCommands[n.Value] {
  315. return nil, fmt.Errorf("%s is not a valid change command", n.Value)
  316. }
  317. }
  318. b.runConfig = config
  319. b.Stdout = ioutil.Discard
  320. b.Stderr = ioutil.Discard
  321. b.disableCommit = true
  322. total := len(ast.Children)
  323. for _, n := range ast.Children {
  324. if err := b.checkDispatch(n, false); err != nil {
  325. return nil, err
  326. }
  327. }
  328. for i, n := range ast.Children {
  329. if err := b.dispatch(i, total, n); err != nil {
  330. return nil, err
  331. }
  332. }
  333. return b.runConfig, nil
  334. }