docker_api_build_test.go 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345
  1. package main
  2. import (
  3. "archive/tar"
  4. "bytes"
  5. "encoding/json"
  6. "io/ioutil"
  7. "net/http"
  8. "regexp"
  9. "strings"
  10. "github.com/docker/docker/integration-cli/checker"
  11. "github.com/docker/docker/integration-cli/cli/build/fakecontext"
  12. "github.com/docker/docker/integration-cli/cli/build/fakegit"
  13. "github.com/docker/docker/integration-cli/cli/build/fakestorage"
  14. "github.com/docker/docker/integration-cli/request"
  15. "github.com/docker/docker/pkg/testutil"
  16. "github.com/go-check/check"
  17. "github.com/stretchr/testify/assert"
  18. "github.com/stretchr/testify/require"
  19. "golang.org/x/net/context"
  20. )
  21. func (s *DockerSuite) TestBuildAPIDockerFileRemote(c *check.C) {
  22. testRequires(c, NotUserNamespace)
  23. var testD string
  24. if testEnv.DaemonPlatform() == "windows" {
  25. testD = `FROM busybox
  26. RUN find / -name ba*
  27. RUN find /tmp/`
  28. } else {
  29. // -xdev is required because sysfs can cause EPERM
  30. testD = `FROM busybox
  31. RUN find / -xdev -name ba*
  32. RUN find /tmp/`
  33. }
  34. server := fakestorage.New(c, "", fakecontext.WithFiles(map[string]string{"testD": testD}))
  35. defer server.Close()
  36. res, body, err := request.Post("/build?dockerfile=baz&remote="+server.URL()+"/testD", request.JSON)
  37. c.Assert(err, checker.IsNil)
  38. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  39. buf, err := testutil.ReadBody(body)
  40. c.Assert(err, checker.IsNil)
  41. // Make sure Dockerfile exists.
  42. // Make sure 'baz' doesn't exist ANYWHERE despite being mentioned in the URL
  43. out := string(buf)
  44. c.Assert(out, checker.Contains, "RUN find /tmp")
  45. c.Assert(out, checker.Not(checker.Contains), "baz")
  46. }
  47. func (s *DockerSuite) TestBuildAPIRemoteTarballContext(c *check.C) {
  48. buffer := new(bytes.Buffer)
  49. tw := tar.NewWriter(buffer)
  50. defer tw.Close()
  51. dockerfile := []byte("FROM busybox")
  52. err := tw.WriteHeader(&tar.Header{
  53. Name: "Dockerfile",
  54. Size: int64(len(dockerfile)),
  55. })
  56. // failed to write tar file header
  57. c.Assert(err, checker.IsNil)
  58. _, err = tw.Write(dockerfile)
  59. // failed to write tar file content
  60. c.Assert(err, checker.IsNil)
  61. // failed to close tar archive
  62. c.Assert(tw.Close(), checker.IsNil)
  63. server := fakestorage.New(c, "", fakecontext.WithBinaryFiles(map[string]*bytes.Buffer{
  64. "testT.tar": buffer,
  65. }))
  66. defer server.Close()
  67. res, b, err := request.Post("/build?remote="+server.URL()+"/testT.tar", request.ContentType("application/tar"))
  68. c.Assert(err, checker.IsNil)
  69. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  70. b.Close()
  71. }
  72. func (s *DockerSuite) TestBuildAPIRemoteTarballContextWithCustomDockerfile(c *check.C) {
  73. buffer := new(bytes.Buffer)
  74. tw := tar.NewWriter(buffer)
  75. defer tw.Close()
  76. dockerfile := []byte(`FROM busybox
  77. RUN echo 'wrong'`)
  78. err := tw.WriteHeader(&tar.Header{
  79. Name: "Dockerfile",
  80. Size: int64(len(dockerfile)),
  81. })
  82. // failed to write tar file header
  83. c.Assert(err, checker.IsNil)
  84. _, err = tw.Write(dockerfile)
  85. // failed to write tar file content
  86. c.Assert(err, checker.IsNil)
  87. custom := []byte(`FROM busybox
  88. RUN echo 'right'
  89. `)
  90. err = tw.WriteHeader(&tar.Header{
  91. Name: "custom",
  92. Size: int64(len(custom)),
  93. })
  94. // failed to write tar file header
  95. c.Assert(err, checker.IsNil)
  96. _, err = tw.Write(custom)
  97. // failed to write tar file content
  98. c.Assert(err, checker.IsNil)
  99. // failed to close tar archive
  100. c.Assert(tw.Close(), checker.IsNil)
  101. server := fakestorage.New(c, "", fakecontext.WithBinaryFiles(map[string]*bytes.Buffer{
  102. "testT.tar": buffer,
  103. }))
  104. defer server.Close()
  105. url := "/build?dockerfile=custom&remote=" + server.URL() + "/testT.tar"
  106. res, body, err := request.Post(url, request.ContentType("application/tar"))
  107. c.Assert(err, checker.IsNil)
  108. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  109. defer body.Close()
  110. content, err := testutil.ReadBody(body)
  111. c.Assert(err, checker.IsNil)
  112. // Build used the wrong dockerfile.
  113. c.Assert(string(content), checker.Not(checker.Contains), "wrong")
  114. }
  115. func (s *DockerSuite) TestBuildAPILowerDockerfile(c *check.C) {
  116. git := fakegit.New(c, "repo", map[string]string{
  117. "dockerfile": `FROM busybox
  118. RUN echo from dockerfile`,
  119. }, false)
  120. defer git.Close()
  121. res, body, err := request.Post("/build?remote="+git.RepoURL, request.JSON)
  122. c.Assert(err, checker.IsNil)
  123. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  124. buf, err := testutil.ReadBody(body)
  125. c.Assert(err, checker.IsNil)
  126. out := string(buf)
  127. c.Assert(out, checker.Contains, "from dockerfile")
  128. }
  129. func (s *DockerSuite) TestBuildAPIBuildGitWithF(c *check.C) {
  130. git := fakegit.New(c, "repo", map[string]string{
  131. "baz": `FROM busybox
  132. RUN echo from baz`,
  133. "Dockerfile": `FROM busybox
  134. RUN echo from Dockerfile`,
  135. }, false)
  136. defer git.Close()
  137. // Make sure it tries to 'dockerfile' query param value
  138. res, body, err := request.Post("/build?dockerfile=baz&remote="+git.RepoURL, request.JSON)
  139. c.Assert(err, checker.IsNil)
  140. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  141. buf, err := testutil.ReadBody(body)
  142. c.Assert(err, checker.IsNil)
  143. out := string(buf)
  144. c.Assert(out, checker.Contains, "from baz")
  145. }
  146. func (s *DockerSuite) TestBuildAPIDoubleDockerfile(c *check.C) {
  147. testRequires(c, UnixCli) // dockerfile overwrites Dockerfile on Windows
  148. git := fakegit.New(c, "repo", map[string]string{
  149. "Dockerfile": `FROM busybox
  150. RUN echo from Dockerfile`,
  151. "dockerfile": `FROM busybox
  152. RUN echo from dockerfile`,
  153. }, false)
  154. defer git.Close()
  155. // Make sure it tries to 'dockerfile' query param value
  156. res, body, err := request.Post("/build?remote="+git.RepoURL, request.JSON)
  157. c.Assert(err, checker.IsNil)
  158. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  159. buf, err := testutil.ReadBody(body)
  160. c.Assert(err, checker.IsNil)
  161. out := string(buf)
  162. c.Assert(out, checker.Contains, "from Dockerfile")
  163. }
  164. func (s *DockerSuite) TestBuildAPIUnnormalizedTarPaths(c *check.C) {
  165. // Make sure that build context tars with entries of the form
  166. // x/./y don't cause caching false positives.
  167. buildFromTarContext := func(fileContents []byte) string {
  168. buffer := new(bytes.Buffer)
  169. tw := tar.NewWriter(buffer)
  170. defer tw.Close()
  171. dockerfile := []byte(`FROM busybox
  172. COPY dir /dir/`)
  173. err := tw.WriteHeader(&tar.Header{
  174. Name: "Dockerfile",
  175. Size: int64(len(dockerfile)),
  176. })
  177. //failed to write tar file header
  178. c.Assert(err, checker.IsNil)
  179. _, err = tw.Write(dockerfile)
  180. // failed to write Dockerfile in tar file content
  181. c.Assert(err, checker.IsNil)
  182. err = tw.WriteHeader(&tar.Header{
  183. Name: "dir/./file",
  184. Size: int64(len(fileContents)),
  185. })
  186. //failed to write tar file header
  187. c.Assert(err, checker.IsNil)
  188. _, err = tw.Write(fileContents)
  189. // failed to write file contents in tar file content
  190. c.Assert(err, checker.IsNil)
  191. // failed to close tar archive
  192. c.Assert(tw.Close(), checker.IsNil)
  193. res, body, err := request.Post("/build", request.RawContent(ioutil.NopCloser(buffer)), request.ContentType("application/x-tar"))
  194. c.Assert(err, checker.IsNil)
  195. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  196. out, err := testutil.ReadBody(body)
  197. c.Assert(err, checker.IsNil)
  198. lines := strings.Split(string(out), "\n")
  199. c.Assert(len(lines), checker.GreaterThan, 1)
  200. c.Assert(lines[len(lines)-2], checker.Matches, ".*Successfully built [0-9a-f]{12}.*")
  201. re := regexp.MustCompile("Successfully built ([0-9a-f]{12})")
  202. matches := re.FindStringSubmatch(lines[len(lines)-2])
  203. return matches[1]
  204. }
  205. imageA := buildFromTarContext([]byte("abc"))
  206. imageB := buildFromTarContext([]byte("def"))
  207. c.Assert(imageA, checker.Not(checker.Equals), imageB)
  208. }
  209. func (s *DockerSuite) TestBuildOnBuildWithCopy(c *check.C) {
  210. dockerfile := `
  211. FROM ` + minimalBaseImage() + ` as onbuildbase
  212. ONBUILD COPY file /file
  213. FROM onbuildbase
  214. `
  215. ctx := fakecontext.New(c, "",
  216. fakecontext.WithDockerfile(dockerfile),
  217. fakecontext.WithFile("file", "some content"),
  218. )
  219. defer ctx.Close()
  220. res, body, err := request.Post(
  221. "/build",
  222. request.RawContent(ctx.AsTarReader(c)),
  223. request.ContentType("application/x-tar"))
  224. c.Assert(err, checker.IsNil)
  225. c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
  226. out, err := testutil.ReadBody(body)
  227. c.Assert(err, checker.IsNil)
  228. c.Assert(string(out), checker.Contains, "Successfully built")
  229. }
  230. func (s *DockerSuite) TestBuildOnBuildCache(c *check.C) {
  231. build := func(dockerfile string) []byte {
  232. ctx := fakecontext.New(c, "",
  233. fakecontext.WithDockerfile(dockerfile),
  234. )
  235. defer ctx.Close()
  236. res, body, err := request.Post(
  237. "/build",
  238. request.RawContent(ctx.AsTarReader(c)),
  239. request.ContentType("application/x-tar"))
  240. require.NoError(c, err)
  241. assert.Equal(c, http.StatusOK, res.StatusCode)
  242. out, err := testutil.ReadBody(body)
  243. require.NoError(c, err)
  244. assert.Contains(c, string(out), "Successfully built")
  245. return out
  246. }
  247. dockerfile := `
  248. FROM ` + minimalBaseImage() + ` as onbuildbase
  249. ENV something=bar
  250. ONBUILD ENV foo=bar
  251. `
  252. build(dockerfile)
  253. dockerfile += "FROM onbuildbase"
  254. out := build(dockerfile)
  255. imageIDs := getImageIDsFromBuild(c, out)
  256. assert.Len(c, imageIDs, 2)
  257. parentID, childID := imageIDs[0], imageIDs[1]
  258. client, err := request.NewClient()
  259. require.NoError(c, err)
  260. // check parentID is correct
  261. image, _, err := client.ImageInspectWithRaw(context.Background(), childID)
  262. require.NoError(c, err)
  263. assert.Equal(c, parentID, image.Parent)
  264. }
  265. type buildLine struct {
  266. Stream string
  267. Aux struct {
  268. ID string
  269. }
  270. }
  271. func getImageIDsFromBuild(c *check.C, output []byte) []string {
  272. ids := []string{}
  273. for _, line := range bytes.Split(output, []byte("\n")) {
  274. if len(line) == 0 {
  275. continue
  276. }
  277. entry := buildLine{}
  278. require.NoError(c, json.Unmarshal(line, &entry))
  279. if entry.Aux.ID != "" {
  280. ids = append(ids, entry.Aux.ID)
  281. }
  282. }
  283. return ids
  284. }