detect.go 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179
  1. package remotecontext
  2. import (
  3. "bufio"
  4. "fmt"
  5. "io"
  6. "os"
  7. "path/filepath"
  8. "strings"
  9. "github.com/Sirupsen/logrus"
  10. "github.com/docker/docker/api/types/backend"
  11. "github.com/docker/docker/builder"
  12. "github.com/docker/docker/builder/dockerfile/parser"
  13. "github.com/docker/docker/builder/dockerignore"
  14. "github.com/docker/docker/pkg/fileutils"
  15. "github.com/docker/docker/pkg/httputils"
  16. "github.com/docker/docker/pkg/symlink"
  17. "github.com/docker/docker/pkg/urlutil"
  18. "github.com/pkg/errors"
  19. )
  20. // Detect returns a context and dockerfile from remote location or local
  21. // archive. progressReader is only used if remoteURL is actually a URL
  22. // (not empty, and not a Git endpoint).
  23. func Detect(config backend.BuildConfig) (remote builder.Source, dockerfile *parser.Result, err error) {
  24. remoteURL := config.Options.RemoteContext
  25. dockerfilePath := config.Options.Dockerfile
  26. switch {
  27. case remoteURL == "":
  28. remote, dockerfile, err = newArchiveRemote(config.Source, dockerfilePath)
  29. case urlutil.IsGitURL(remoteURL):
  30. remote, dockerfile, err = newGitRemote(remoteURL, dockerfilePath)
  31. case urlutil.IsURL(remoteURL):
  32. remote, dockerfile, err = newURLRemote(remoteURL, dockerfilePath, config.ProgressWriter.ProgressReaderFunc)
  33. default:
  34. err = fmt.Errorf("remoteURL (%s) could not be recognized as URL", remoteURL)
  35. }
  36. return
  37. }
  38. func newArchiveRemote(rc io.ReadCloser, dockerfilePath string) (builder.Source, *parser.Result, error) {
  39. defer rc.Close()
  40. c, err := MakeTarSumContext(rc)
  41. if err != nil {
  42. return nil, nil, err
  43. }
  44. return withDockerfileFromContext(c.(modifiableContext), dockerfilePath)
  45. }
  46. func withDockerfileFromContext(c modifiableContext, dockerfilePath string) (builder.Source, *parser.Result, error) {
  47. df, err := openAt(c, dockerfilePath)
  48. if err != nil {
  49. if os.IsNotExist(err) {
  50. if dockerfilePath == builder.DefaultDockerfileName {
  51. lowercase := strings.ToLower(dockerfilePath)
  52. if _, err := StatAt(c, lowercase); err == nil {
  53. return withDockerfileFromContext(c, lowercase)
  54. }
  55. }
  56. return nil, nil, errors.Errorf("Cannot locate specified Dockerfile: %s", dockerfilePath) // backwards compatible error
  57. }
  58. c.Close()
  59. return nil, nil, err
  60. }
  61. res, err := readAndParseDockerfile(dockerfilePath, df)
  62. if err != nil {
  63. return nil, nil, err
  64. }
  65. df.Close()
  66. if err := removeDockerfile(c, dockerfilePath); err != nil {
  67. c.Close()
  68. return nil, nil, err
  69. }
  70. return c, res, nil
  71. }
  72. func newGitRemote(gitURL string, dockerfilePath string) (builder.Source, *parser.Result, error) {
  73. c, err := MakeGitContext(gitURL) // TODO: change this to NewLazyContext
  74. if err != nil {
  75. return nil, nil, err
  76. }
  77. return withDockerfileFromContext(c.(modifiableContext), dockerfilePath)
  78. }
  79. func newURLRemote(url string, dockerfilePath string, progressReader func(in io.ReadCloser) io.ReadCloser) (builder.Source, *parser.Result, error) {
  80. var dockerfile io.ReadCloser
  81. dockerfileFoundErr := errors.New("found-dockerfile")
  82. c, err := MakeRemoteContext(url, map[string]func(io.ReadCloser) (io.ReadCloser, error){
  83. httputils.MimeTypes.TextPlain: func(rc io.ReadCloser) (io.ReadCloser, error) {
  84. dockerfile = rc
  85. return nil, dockerfileFoundErr
  86. },
  87. // fallback handler (tar context)
  88. "": func(rc io.ReadCloser) (io.ReadCloser, error) {
  89. return progressReader(rc), nil
  90. },
  91. })
  92. if err != nil {
  93. if err == dockerfileFoundErr {
  94. res, err := parser.Parse(dockerfile)
  95. if err != nil {
  96. return nil, nil, err
  97. }
  98. return nil, res, nil
  99. }
  100. return nil, nil, err
  101. }
  102. return withDockerfileFromContext(c.(modifiableContext), dockerfilePath)
  103. }
  104. func removeDockerfile(c modifiableContext, filesToRemove ...string) error {
  105. f, err := openAt(c, ".dockerignore")
  106. // Note that a missing .dockerignore file isn't treated as an error
  107. switch {
  108. case os.IsNotExist(err):
  109. return nil
  110. case err != nil:
  111. return err
  112. }
  113. excludes, err := dockerignore.ReadAll(f)
  114. if err != nil {
  115. return err
  116. }
  117. f.Close()
  118. filesToRemove = append([]string{".dockerignore"}, filesToRemove...)
  119. for _, fileToRemove := range filesToRemove {
  120. if rm, _ := fileutils.Matches(fileToRemove, excludes); rm {
  121. if err := c.Remove(fileToRemove); err != nil {
  122. logrus.Errorf("failed to remove %s: %v", fileToRemove, err)
  123. }
  124. }
  125. }
  126. return nil
  127. }
  128. func readAndParseDockerfile(name string, rc io.Reader) (*parser.Result, error) {
  129. br := bufio.NewReader(rc)
  130. if _, err := br.Peek(1); err != nil {
  131. if err == io.EOF {
  132. return nil, errors.Errorf("the Dockerfile (%s) cannot be empty", name)
  133. }
  134. return nil, errors.Wrap(err, "unexpected error reading Dockerfile")
  135. }
  136. return parser.Parse(br)
  137. }
  138. func openAt(remote builder.Source, path string) (*os.File, error) {
  139. fullPath, err := FullPath(remote, path)
  140. if err != nil {
  141. return nil, err
  142. }
  143. return os.Open(fullPath)
  144. }
  145. // StatAt is a helper for calling Stat on a path from a source
  146. func StatAt(remote builder.Source, path string) (os.FileInfo, error) {
  147. fullPath, err := FullPath(remote, path)
  148. if err != nil {
  149. return nil, err
  150. }
  151. return os.Stat(fullPath)
  152. }
  153. // FullPath is a helper for getting a full path for a path from a source
  154. func FullPath(remote builder.Source, path string) (string, error) {
  155. fullPath, err := symlink.FollowSymlinkInScope(filepath.Join(remote.Root(), path), remote.Root())
  156. if err != nil {
  157. return "", fmt.Errorf("Forbidden path outside the build context: %s (%s)", path, fullPath) // backwards compat with old error
  158. }
  159. return fullPath, nil
  160. }