internals.go 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676
  1. package dockerfile
  2. // internals for handling commands. Covers many areas and a lot of
  3. // non-contiguous functionality. Please read the comments.
  4. import (
  5. "crypto/sha256"
  6. "encoding/hex"
  7. "errors"
  8. "fmt"
  9. "io"
  10. "io/ioutil"
  11. "net/http"
  12. "net/url"
  13. "os"
  14. "path/filepath"
  15. "sort"
  16. "strings"
  17. "time"
  18. "github.com/Sirupsen/logrus"
  19. "github.com/docker/docker/api/types"
  20. "github.com/docker/docker/api/types/backend"
  21. "github.com/docker/docker/api/types/container"
  22. "github.com/docker/docker/api/types/strslice"
  23. "github.com/docker/docker/builder"
  24. "github.com/docker/docker/builder/dockerfile/parser"
  25. "github.com/docker/docker/pkg/archive"
  26. "github.com/docker/docker/pkg/httputils"
  27. "github.com/docker/docker/pkg/ioutils"
  28. "github.com/docker/docker/pkg/jsonmessage"
  29. "github.com/docker/docker/pkg/progress"
  30. "github.com/docker/docker/pkg/streamformatter"
  31. "github.com/docker/docker/pkg/stringid"
  32. "github.com/docker/docker/pkg/system"
  33. "github.com/docker/docker/pkg/tarsum"
  34. "github.com/docker/docker/pkg/urlutil"
  35. "github.com/docker/docker/runconfig/opts"
  36. )
  37. func (b *Builder) commit(id string, autoCmd strslice.StrSlice, comment string) error {
  38. if b.disableCommit {
  39. return nil
  40. }
  41. if b.image == "" && !b.noBaseImage {
  42. return errors.New("Please provide a source image with `from` prior to commit")
  43. }
  44. b.runConfig.Image = b.image
  45. if id == "" {
  46. cmd := b.runConfig.Cmd
  47. b.runConfig.Cmd = strslice.StrSlice(append(getShell(b.runConfig), "#(nop) ", comment))
  48. defer func(cmd strslice.StrSlice) { b.runConfig.Cmd = cmd }(cmd)
  49. hit, err := b.probeCache()
  50. if err != nil {
  51. return err
  52. } else if hit {
  53. return nil
  54. }
  55. id, err = b.create()
  56. if err != nil {
  57. return err
  58. }
  59. }
  60. // Note: Actually copy the struct
  61. autoConfig := *b.runConfig
  62. autoConfig.Cmd = autoCmd
  63. commitCfg := &backend.ContainerCommitConfig{
  64. ContainerCommitConfig: types.ContainerCommitConfig{
  65. Author: b.maintainer,
  66. Pause: true,
  67. Config: &autoConfig,
  68. },
  69. }
  70. // Commit the container
  71. imageID, err := b.docker.Commit(id, commitCfg)
  72. if err != nil {
  73. return err
  74. }
  75. b.image = imageID
  76. return nil
  77. }
  78. type copyInfo struct {
  79. builder.FileInfo
  80. decompress bool
  81. }
  82. func (b *Builder) runContextCommand(args []string, allowRemote bool, allowLocalDecompression bool, cmdName string) error {
  83. if b.context == nil {
  84. return fmt.Errorf("No context given. Impossible to use %s", cmdName)
  85. }
  86. if len(args) < 2 {
  87. return fmt.Errorf("Invalid %s format - at least two arguments required", cmdName)
  88. }
  89. // Work in daemon-specific filepath semantics
  90. dest := filepath.FromSlash(args[len(args)-1]) // last one is always the dest
  91. b.runConfig.Image = b.image
  92. var infos []copyInfo
  93. // Loop through each src file and calculate the info we need to
  94. // do the copy (e.g. hash value if cached). Don't actually do
  95. // the copy until we've looked at all src files
  96. var err error
  97. for _, orig := range args[0 : len(args)-1] {
  98. var fi builder.FileInfo
  99. if urlutil.IsURL(orig) {
  100. if !allowRemote {
  101. return fmt.Errorf("Source can't be a URL for %s", cmdName)
  102. }
  103. fi, err = b.download(orig)
  104. if err != nil {
  105. return err
  106. }
  107. defer os.RemoveAll(filepath.Dir(fi.Path()))
  108. infos = append(infos, copyInfo{
  109. FileInfo: fi,
  110. decompress: false,
  111. })
  112. continue
  113. }
  114. // not a URL
  115. subInfos, err := b.calcCopyInfo(cmdName, orig, allowLocalDecompression, true)
  116. if err != nil {
  117. return err
  118. }
  119. infos = append(infos, subInfos...)
  120. }
  121. if len(infos) == 0 {
  122. return errors.New("No source files were specified")
  123. }
  124. if len(infos) > 1 && !strings.HasSuffix(dest, string(os.PathSeparator)) {
  125. return fmt.Errorf("When using %s with more than one source file, the destination must be a directory and end with a /", cmdName)
  126. }
  127. // For backwards compat, if there's just one info then use it as the
  128. // cache look-up string, otherwise hash 'em all into one
  129. var srcHash string
  130. var origPaths string
  131. if len(infos) == 1 {
  132. fi := infos[0].FileInfo
  133. origPaths = fi.Name()
  134. if hfi, ok := fi.(builder.Hashed); ok {
  135. srcHash = hfi.Hash()
  136. }
  137. } else {
  138. var hashs []string
  139. var origs []string
  140. for _, info := range infos {
  141. fi := info.FileInfo
  142. origs = append(origs, fi.Name())
  143. if hfi, ok := fi.(builder.Hashed); ok {
  144. hashs = append(hashs, hfi.Hash())
  145. }
  146. }
  147. hasher := sha256.New()
  148. hasher.Write([]byte(strings.Join(hashs, ",")))
  149. srcHash = "multi:" + hex.EncodeToString(hasher.Sum(nil))
  150. origPaths = strings.Join(origs, " ")
  151. }
  152. cmd := b.runConfig.Cmd
  153. b.runConfig.Cmd = strslice.StrSlice(append(getShell(b.runConfig), fmt.Sprintf("#(nop) %s %s in %s ", cmdName, srcHash, dest)))
  154. defer func(cmd strslice.StrSlice) { b.runConfig.Cmd = cmd }(cmd)
  155. if hit, err := b.probeCache(); err != nil {
  156. return err
  157. } else if hit {
  158. return nil
  159. }
  160. container, err := b.docker.ContainerCreate(types.ContainerCreateConfig{
  161. Config: b.runConfig,
  162. // Set a log config to override any default value set on the daemon
  163. HostConfig: &container.HostConfig{LogConfig: defaultLogConfig},
  164. })
  165. if err != nil {
  166. return err
  167. }
  168. b.tmpContainers[container.ID] = struct{}{}
  169. comment := fmt.Sprintf("%s %s in %s", cmdName, origPaths, dest)
  170. // Twiddle the destination when it's a relative path - meaning, make it
  171. // relative to the WORKINGDIR
  172. if dest, err = normaliseDest(cmdName, b.runConfig.WorkingDir, dest); err != nil {
  173. return err
  174. }
  175. for _, info := range infos {
  176. if err := b.docker.CopyOnBuild(container.ID, dest, info.FileInfo, info.decompress); err != nil {
  177. return err
  178. }
  179. }
  180. return b.commit(container.ID, cmd, comment)
  181. }
  182. func (b *Builder) download(srcURL string) (fi builder.FileInfo, err error) {
  183. // get filename from URL
  184. u, err := url.Parse(srcURL)
  185. if err != nil {
  186. return
  187. }
  188. path := filepath.FromSlash(u.Path) // Ensure in platform semantics
  189. if strings.HasSuffix(path, string(os.PathSeparator)) {
  190. path = path[:len(path)-1]
  191. }
  192. parts := strings.Split(path, string(os.PathSeparator))
  193. filename := parts[len(parts)-1]
  194. if filename == "" {
  195. err = fmt.Errorf("cannot determine filename from url: %s", u)
  196. return
  197. }
  198. // Initiate the download
  199. resp, err := httputils.Download(srcURL)
  200. if err != nil {
  201. return
  202. }
  203. // Prepare file in a tmp dir
  204. tmpDir, err := ioutils.TempDir("", "docker-remote")
  205. if err != nil {
  206. return
  207. }
  208. defer func() {
  209. if err != nil {
  210. os.RemoveAll(tmpDir)
  211. }
  212. }()
  213. tmpFileName := filepath.Join(tmpDir, filename)
  214. tmpFile, err := os.OpenFile(tmpFileName, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
  215. if err != nil {
  216. return
  217. }
  218. stdoutFormatter := b.Stdout.(*streamformatter.StdoutFormatter)
  219. progressOutput := stdoutFormatter.StreamFormatter.NewProgressOutput(stdoutFormatter.Writer, true)
  220. progressReader := progress.NewProgressReader(resp.Body, progressOutput, resp.ContentLength, "", "Downloading")
  221. // Download and dump result to tmp file
  222. if _, err = io.Copy(tmpFile, progressReader); err != nil {
  223. tmpFile.Close()
  224. return
  225. }
  226. fmt.Fprintln(b.Stdout)
  227. // ignoring error because the file was already opened successfully
  228. tmpFileSt, err := tmpFile.Stat()
  229. if err != nil {
  230. tmpFile.Close()
  231. return
  232. }
  233. // Set the mtime to the Last-Modified header value if present
  234. // Otherwise just remove atime and mtime
  235. mTime := time.Time{}
  236. lastMod := resp.Header.Get("Last-Modified")
  237. if lastMod != "" {
  238. // If we can't parse it then just let it default to 'zero'
  239. // otherwise use the parsed time value
  240. if parsedMTime, err := http.ParseTime(lastMod); err == nil {
  241. mTime = parsedMTime
  242. }
  243. }
  244. tmpFile.Close()
  245. if err = system.Chtimes(tmpFileName, mTime, mTime); err != nil {
  246. return
  247. }
  248. // Calc the checksum, even if we're using the cache
  249. r, err := archive.Tar(tmpFileName, archive.Uncompressed)
  250. if err != nil {
  251. return
  252. }
  253. tarSum, err := tarsum.NewTarSum(r, true, tarsum.Version1)
  254. if err != nil {
  255. return
  256. }
  257. if _, err = io.Copy(ioutil.Discard, tarSum); err != nil {
  258. return
  259. }
  260. hash := tarSum.Sum(nil)
  261. r.Close()
  262. return &builder.HashedFileInfo{FileInfo: builder.PathFileInfo{FileInfo: tmpFileSt, FilePath: tmpFileName}, FileHash: hash}, nil
  263. }
  264. func (b *Builder) calcCopyInfo(cmdName, origPath string, allowLocalDecompression, allowWildcards bool) ([]copyInfo, error) {
  265. // Work in daemon-specific OS filepath semantics
  266. origPath = filepath.FromSlash(origPath)
  267. if origPath != "" && origPath[0] == os.PathSeparator && len(origPath) > 1 {
  268. origPath = origPath[1:]
  269. }
  270. origPath = strings.TrimPrefix(origPath, "."+string(os.PathSeparator))
  271. // Deal with wildcards
  272. if allowWildcards && containsWildcards(origPath) {
  273. var copyInfos []copyInfo
  274. if err := b.context.Walk("", func(path string, info builder.FileInfo, err error) error {
  275. if err != nil {
  276. return err
  277. }
  278. if info.Name() == "" {
  279. // Why are we doing this check?
  280. return nil
  281. }
  282. if match, _ := filepath.Match(origPath, path); !match {
  283. return nil
  284. }
  285. // Note we set allowWildcards to false in case the name has
  286. // a * in it
  287. subInfos, err := b.calcCopyInfo(cmdName, path, allowLocalDecompression, false)
  288. if err != nil {
  289. return err
  290. }
  291. copyInfos = append(copyInfos, subInfos...)
  292. return nil
  293. }); err != nil {
  294. return nil, err
  295. }
  296. return copyInfos, nil
  297. }
  298. // Must be a dir or a file
  299. statPath, fi, err := b.context.Stat(origPath)
  300. if err != nil {
  301. return nil, err
  302. }
  303. copyInfos := []copyInfo{{FileInfo: fi, decompress: allowLocalDecompression}}
  304. hfi, handleHash := fi.(builder.Hashed)
  305. if !handleHash {
  306. return copyInfos, nil
  307. }
  308. // Deal with the single file case
  309. if !fi.IsDir() {
  310. hfi.SetHash("file:" + hfi.Hash())
  311. return copyInfos, nil
  312. }
  313. // Must be a dir
  314. var subfiles []string
  315. err = b.context.Walk(statPath, func(path string, info builder.FileInfo, err error) error {
  316. if err != nil {
  317. return err
  318. }
  319. // we already checked handleHash above
  320. subfiles = append(subfiles, info.(builder.Hashed).Hash())
  321. return nil
  322. })
  323. if err != nil {
  324. return nil, err
  325. }
  326. sort.Strings(subfiles)
  327. hasher := sha256.New()
  328. hasher.Write([]byte(strings.Join(subfiles, ",")))
  329. hfi.SetHash("dir:" + hex.EncodeToString(hasher.Sum(nil)))
  330. return copyInfos, nil
  331. }
  332. func (b *Builder) processImageFrom(img builder.Image) error {
  333. if img != nil {
  334. b.image = img.ImageID()
  335. if img.RunConfig() != nil {
  336. b.runConfig = img.RunConfig()
  337. }
  338. }
  339. // Check to see if we have a default PATH, note that windows won't
  340. // have one as it's set by HCS
  341. if system.DefaultPathEnv != "" {
  342. // Convert the slice of strings that represent the current list
  343. // of env vars into a map so we can see if PATH is already set.
  344. // If it's not set then go ahead and give it our default value
  345. configEnv := opts.ConvertKVStringsToMap(b.runConfig.Env)
  346. if _, ok := configEnv["PATH"]; !ok {
  347. b.runConfig.Env = append(b.runConfig.Env,
  348. "PATH="+system.DefaultPathEnv)
  349. }
  350. }
  351. if img == nil {
  352. // Typically this means they used "FROM scratch"
  353. return nil
  354. }
  355. // Process ONBUILD triggers if they exist
  356. if nTriggers := len(b.runConfig.OnBuild); nTriggers != 0 {
  357. word := "trigger"
  358. if nTriggers > 1 {
  359. word = "triggers"
  360. }
  361. fmt.Fprintf(b.Stderr, "# Executing %d build %s...\n", nTriggers, word)
  362. }
  363. // Copy the ONBUILD triggers, and remove them from the config, since the config will be committed.
  364. onBuildTriggers := b.runConfig.OnBuild
  365. b.runConfig.OnBuild = []string{}
  366. // parse the ONBUILD triggers by invoking the parser
  367. for _, step := range onBuildTriggers {
  368. ast, err := parser.Parse(strings.NewReader(step), &b.directive)
  369. if err != nil {
  370. return err
  371. }
  372. total := len(ast.Children)
  373. for _, n := range ast.Children {
  374. if err := b.checkDispatch(n, true); err != nil {
  375. return err
  376. }
  377. }
  378. for i, n := range ast.Children {
  379. if err := b.dispatch(i, total, n); err != nil {
  380. return err
  381. }
  382. }
  383. }
  384. return nil
  385. }
  386. // probeCache checks if cache match can be found for current build instruction.
  387. // If an image is found, probeCache returns `(true, nil)`.
  388. // If no image is found, it returns `(false, nil)`.
  389. // If there is any error, it returns `(false, err)`.
  390. func (b *Builder) probeCache() (bool, error) {
  391. c := b.imageCache
  392. if c == nil || b.options.NoCache || b.cacheBusted {
  393. return false, nil
  394. }
  395. cache, err := c.GetCache(b.image, b.runConfig)
  396. if err != nil {
  397. return false, err
  398. }
  399. if len(cache) == 0 {
  400. logrus.Debugf("[BUILDER] Cache miss: %s", b.runConfig.Cmd)
  401. b.cacheBusted = true
  402. return false, nil
  403. }
  404. fmt.Fprint(b.Stdout, " ---> Using cache\n")
  405. logrus.Debugf("[BUILDER] Use cached version: %s", b.runConfig.Cmd)
  406. b.image = string(cache)
  407. return true, nil
  408. }
  409. func (b *Builder) create() (string, error) {
  410. if b.image == "" && !b.noBaseImage {
  411. return "", errors.New("Please provide a source image with `from` prior to run")
  412. }
  413. b.runConfig.Image = b.image
  414. resources := container.Resources{
  415. CgroupParent: b.options.CgroupParent,
  416. CPUShares: b.options.CPUShares,
  417. CPUPeriod: b.options.CPUPeriod,
  418. CPUQuota: b.options.CPUQuota,
  419. CpusetCpus: b.options.CPUSetCPUs,
  420. CpusetMems: b.options.CPUSetMems,
  421. Memory: b.options.Memory,
  422. MemorySwap: b.options.MemorySwap,
  423. Ulimits: b.options.Ulimits,
  424. }
  425. // TODO: why not embed a hostconfig in builder?
  426. hostConfig := &container.HostConfig{
  427. SecurityOpt: b.options.SecurityOpt,
  428. Isolation: b.options.Isolation,
  429. ShmSize: b.options.ShmSize,
  430. Resources: resources,
  431. NetworkMode: container.NetworkMode(b.options.NetworkMode),
  432. // Set a log config to override any default value set on the daemon
  433. LogConfig: defaultLogConfig,
  434. }
  435. config := *b.runConfig
  436. // Create the container
  437. c, err := b.docker.ContainerCreate(types.ContainerCreateConfig{
  438. Config: b.runConfig,
  439. HostConfig: hostConfig,
  440. })
  441. if err != nil {
  442. return "", err
  443. }
  444. for _, warning := range c.Warnings {
  445. fmt.Fprintf(b.Stdout, " ---> [Warning] %s\n", warning)
  446. }
  447. b.tmpContainers[c.ID] = struct{}{}
  448. fmt.Fprintf(b.Stdout, " ---> Running in %s\n", stringid.TruncateID(c.ID))
  449. // override the entry point that may have been picked up from the base image
  450. if err := b.docker.ContainerUpdateCmdOnBuild(c.ID, config.Cmd); err != nil {
  451. return "", err
  452. }
  453. return c.ID, nil
  454. }
  455. var errCancelled = errors.New("build cancelled")
  456. func (b *Builder) run(cID string) (err error) {
  457. errCh := make(chan error)
  458. go func() {
  459. errCh <- b.docker.ContainerAttachRaw(cID, nil, b.Stdout, b.Stderr, true)
  460. }()
  461. finished := make(chan struct{})
  462. cancelErrCh := make(chan error, 1)
  463. go func() {
  464. select {
  465. case <-b.clientCtx.Done():
  466. logrus.Debugln("Build cancelled, killing and removing container:", cID)
  467. b.docker.ContainerKill(cID, 0)
  468. b.removeContainer(cID)
  469. cancelErrCh <- errCancelled
  470. case <-finished:
  471. cancelErrCh <- nil
  472. }
  473. }()
  474. if err := b.docker.ContainerStart(cID, nil, "", ""); err != nil {
  475. close(finished)
  476. if cancelErr := <-cancelErrCh; cancelErr != nil {
  477. logrus.Debugf("Build cancelled (%v) and got an error from ContainerStart: %v",
  478. cancelErr, err)
  479. }
  480. return err
  481. }
  482. // Block on reading output from container, stop on err or chan closed
  483. if err := <-errCh; err != nil {
  484. close(finished)
  485. if cancelErr := <-cancelErrCh; cancelErr != nil {
  486. logrus.Debugf("Build cancelled (%v) and got an error from errCh: %v",
  487. cancelErr, err)
  488. }
  489. return err
  490. }
  491. if ret, _ := b.docker.ContainerWait(cID, -1); ret != 0 {
  492. close(finished)
  493. if cancelErr := <-cancelErrCh; cancelErr != nil {
  494. logrus.Debugf("Build cancelled (%v) and got a non-zero code from ContainerWait: %d",
  495. cancelErr, ret)
  496. }
  497. // TODO: change error type, because jsonmessage.JSONError assumes HTTP
  498. return &jsonmessage.JSONError{
  499. Message: fmt.Sprintf("The command '%s' returned a non-zero code: %d", strings.Join(b.runConfig.Cmd, " "), ret),
  500. Code: ret,
  501. }
  502. }
  503. close(finished)
  504. return <-cancelErrCh
  505. }
  506. func (b *Builder) removeContainer(c string) error {
  507. rmConfig := &types.ContainerRmConfig{
  508. ForceRemove: true,
  509. RemoveVolume: true,
  510. }
  511. if err := b.docker.ContainerRm(c, rmConfig); err != nil {
  512. fmt.Fprintf(b.Stdout, "Error removing intermediate container %s: %v\n", stringid.TruncateID(c), err)
  513. return err
  514. }
  515. return nil
  516. }
  517. func (b *Builder) clearTmp() {
  518. for c := range b.tmpContainers {
  519. if err := b.removeContainer(c); err != nil {
  520. return
  521. }
  522. delete(b.tmpContainers, c)
  523. fmt.Fprintf(b.Stdout, "Removing intermediate container %s\n", stringid.TruncateID(c))
  524. }
  525. }
  526. // readDockerfile reads a Dockerfile from the current context.
  527. func (b *Builder) readDockerfile() error {
  528. // If no -f was specified then look for 'Dockerfile'. If we can't find
  529. // that then look for 'dockerfile'. If neither are found then default
  530. // back to 'Dockerfile' and use that in the error message.
  531. if b.options.Dockerfile == "" {
  532. b.options.Dockerfile = builder.DefaultDockerfileName
  533. if _, _, err := b.context.Stat(b.options.Dockerfile); os.IsNotExist(err) {
  534. lowercase := strings.ToLower(b.options.Dockerfile)
  535. if _, _, err := b.context.Stat(lowercase); err == nil {
  536. b.options.Dockerfile = lowercase
  537. }
  538. }
  539. }
  540. err := b.parseDockerfile()
  541. if err != nil {
  542. return err
  543. }
  544. // After the Dockerfile has been parsed, we need to check the .dockerignore
  545. // file for either "Dockerfile" or ".dockerignore", and if either are
  546. // present then erase them from the build context. These files should never
  547. // have been sent from the client but we did send them to make sure that
  548. // we had the Dockerfile to actually parse, and then we also need the
  549. // .dockerignore file to know whether either file should be removed.
  550. // Note that this assumes the Dockerfile has been read into memory and
  551. // is now safe to be removed.
  552. if dockerIgnore, ok := b.context.(builder.DockerIgnoreContext); ok {
  553. dockerIgnore.Process([]string{b.options.Dockerfile})
  554. }
  555. return nil
  556. }
  557. func (b *Builder) parseDockerfile() error {
  558. f, err := b.context.Open(b.options.Dockerfile)
  559. if err != nil {
  560. if os.IsNotExist(err) {
  561. return fmt.Errorf("Cannot locate specified Dockerfile: %s", b.options.Dockerfile)
  562. }
  563. return err
  564. }
  565. defer f.Close()
  566. if f, ok := f.(*os.File); ok {
  567. // ignoring error because Open already succeeded
  568. fi, err := f.Stat()
  569. if err != nil {
  570. return fmt.Errorf("Unexpected error reading Dockerfile: %v", err)
  571. }
  572. if fi.Size() == 0 {
  573. return fmt.Errorf("The Dockerfile (%s) cannot be empty", b.options.Dockerfile)
  574. }
  575. }
  576. b.dockerfile, err = parser.Parse(f, &b.directive)
  577. if err != nil {
  578. return err
  579. }
  580. return nil
  581. }
  582. // determine if build arg is part of built-in args or user
  583. // defined args in Dockerfile at any point in time.
  584. func (b *Builder) isBuildArgAllowed(arg string) bool {
  585. if _, ok := BuiltinAllowedBuildArgs[arg]; ok {
  586. return true
  587. }
  588. if _, ok := b.allowedBuildArgs[arg]; ok {
  589. return true
  590. }
  591. return false
  592. }