mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
e25352a42a
goimports -w \
-- "./integration-cli/daemon" "./pkg/discovery" "./pkg/discovery/file" "./pkg/discovery/kv" "./pkg/discovery/memory" "./pkg/discovery/nodes" "./integration-cli" \
&& \
gofmt -w -s \
-- "./integration-cli/daemon" "./pkg/discovery" "./pkg/discovery/file" "./pkg/discovery/kv" "./pkg/discovery/memory" "./pkg/discovery/nodes" "./integration-cli"
Signed-off-by: Tibor Vass <tibor@docker.com>
(cherry picked from commit 59e55dcdd0)
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
559 lines
15 KiB
Go
559 lines
15 KiB
Go
package main
|
|
|
|
import (
|
|
"archive/tar"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/docker/docker/api/types"
|
|
"github.com/docker/docker/internal/test/fakecontext"
|
|
"github.com/docker/docker/internal/test/fakegit"
|
|
"github.com/docker/docker/internal/test/fakestorage"
|
|
"github.com/docker/docker/internal/test/request"
|
|
"gotest.tools/assert"
|
|
is "gotest.tools/assert/cmp"
|
|
)
|
|
|
|
func (s *DockerSuite) TestBuildAPIDockerFileRemote(c *testing.T) {
|
|
testRequires(c, NotUserNamespace)
|
|
|
|
var testD string
|
|
if testEnv.OSType == "windows" {
|
|
testD = `FROM busybox
|
|
RUN find / -name ba*
|
|
RUN find /tmp/`
|
|
} else {
|
|
// -xdev is required because sysfs can cause EPERM
|
|
testD = `FROM busybox
|
|
RUN find / -xdev -name ba*
|
|
RUN find /tmp/`
|
|
}
|
|
server := fakestorage.New(c, "", fakecontext.WithFiles(map[string]string{"testD": testD}))
|
|
defer server.Close()
|
|
|
|
res, body, err := request.Post("/build?dockerfile=baz&remote="+server.URL()+"/testD", request.JSON)
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
buf, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
|
|
// Make sure Dockerfile exists.
|
|
// Make sure 'baz' doesn't exist ANYWHERE despite being mentioned in the URL
|
|
out := string(buf)
|
|
assert.Assert(c, is.Contains(out, "RUN find /tmp"))
|
|
assert.Assert(c, !strings.Contains(out, "baz"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAPIRemoteTarballContext(c *testing.T) {
|
|
buffer := new(bytes.Buffer)
|
|
tw := tar.NewWriter(buffer)
|
|
defer tw.Close()
|
|
|
|
dockerfile := []byte("FROM busybox")
|
|
err := tw.WriteHeader(&tar.Header{
|
|
Name: "Dockerfile",
|
|
Size: int64(len(dockerfile)),
|
|
})
|
|
assert.NilError(c, err, "failed to write tar file header")
|
|
|
|
_, err = tw.Write(dockerfile)
|
|
assert.NilError(c, err, "failed to write tar file content")
|
|
assert.NilError(c, tw.Close(), "failed to close tar archive")
|
|
|
|
server := fakestorage.New(c, "", fakecontext.WithBinaryFiles(map[string]*bytes.Buffer{
|
|
"testT.tar": buffer,
|
|
}))
|
|
defer server.Close()
|
|
|
|
res, b, err := request.Post("/build?remote="+server.URL()+"/testT.tar", request.ContentType("application/tar"))
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
b.Close()
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAPIRemoteTarballContextWithCustomDockerfile(c *testing.T) {
|
|
buffer := new(bytes.Buffer)
|
|
tw := tar.NewWriter(buffer)
|
|
defer tw.Close()
|
|
|
|
dockerfile := []byte(`FROM busybox
|
|
RUN echo 'wrong'`)
|
|
err := tw.WriteHeader(&tar.Header{
|
|
Name: "Dockerfile",
|
|
Size: int64(len(dockerfile)),
|
|
})
|
|
// failed to write tar file header
|
|
assert.NilError(c, err)
|
|
|
|
_, err = tw.Write(dockerfile)
|
|
// failed to write tar file content
|
|
assert.NilError(c, err)
|
|
|
|
custom := []byte(`FROM busybox
|
|
RUN echo 'right'
|
|
`)
|
|
err = tw.WriteHeader(&tar.Header{
|
|
Name: "custom",
|
|
Size: int64(len(custom)),
|
|
})
|
|
|
|
// failed to write tar file header
|
|
assert.NilError(c, err)
|
|
|
|
_, err = tw.Write(custom)
|
|
// failed to write tar file content
|
|
assert.NilError(c, err)
|
|
|
|
// failed to close tar archive
|
|
assert.NilError(c, tw.Close())
|
|
|
|
server := fakestorage.New(c, "", fakecontext.WithBinaryFiles(map[string]*bytes.Buffer{
|
|
"testT.tar": buffer,
|
|
}))
|
|
defer server.Close()
|
|
|
|
url := "/build?dockerfile=custom&remote=" + server.URL() + "/testT.tar"
|
|
res, body, err := request.Post(url, request.ContentType("application/tar"))
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
defer body.Close()
|
|
content, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
|
|
// Build used the wrong dockerfile.
|
|
assert.Assert(c, !strings.Contains(string(content), "wrong"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAPILowerDockerfile(c *testing.T) {
|
|
git := fakegit.New(c, "repo", map[string]string{
|
|
"dockerfile": `FROM busybox
|
|
RUN echo from dockerfile`,
|
|
}, false)
|
|
defer git.Close()
|
|
|
|
res, body, err := request.Post("/build?remote="+git.RepoURL, request.JSON)
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
buf, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
|
|
out := string(buf)
|
|
assert.Assert(c, is.Contains(out, "from dockerfile"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAPIBuildGitWithF(c *testing.T) {
|
|
git := fakegit.New(c, "repo", map[string]string{
|
|
"baz": `FROM busybox
|
|
RUN echo from baz`,
|
|
"Dockerfile": `FROM busybox
|
|
RUN echo from Dockerfile`,
|
|
}, false)
|
|
defer git.Close()
|
|
|
|
// Make sure it tries to 'dockerfile' query param value
|
|
res, body, err := request.Post("/build?dockerfile=baz&remote="+git.RepoURL, request.JSON)
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
buf, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
|
|
out := string(buf)
|
|
assert.Assert(c, is.Contains(out, "from baz"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAPIDoubleDockerfile(c *testing.T) {
|
|
testRequires(c, UnixCli) // dockerfile overwrites Dockerfile on Windows
|
|
git := fakegit.New(c, "repo", map[string]string{
|
|
"Dockerfile": `FROM busybox
|
|
RUN echo from Dockerfile`,
|
|
"dockerfile": `FROM busybox
|
|
RUN echo from dockerfile`,
|
|
}, false)
|
|
defer git.Close()
|
|
|
|
// Make sure it tries to 'dockerfile' query param value
|
|
res, body, err := request.Post("/build?remote="+git.RepoURL, request.JSON)
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
buf, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
|
|
out := string(buf)
|
|
assert.Assert(c, is.Contains(out, "from Dockerfile"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAPIUnnormalizedTarPaths(c *testing.T) {
|
|
// Make sure that build context tars with entries of the form
|
|
// x/./y don't cause caching false positives.
|
|
|
|
buildFromTarContext := func(fileContents []byte) string {
|
|
buffer := new(bytes.Buffer)
|
|
tw := tar.NewWriter(buffer)
|
|
defer tw.Close()
|
|
|
|
dockerfile := []byte(`FROM busybox
|
|
COPY dir /dir/`)
|
|
err := tw.WriteHeader(&tar.Header{
|
|
Name: "Dockerfile",
|
|
Size: int64(len(dockerfile)),
|
|
})
|
|
//failed to write tar file header
|
|
assert.NilError(c, err)
|
|
|
|
_, err = tw.Write(dockerfile)
|
|
// failed to write Dockerfile in tar file content
|
|
assert.NilError(c, err)
|
|
|
|
err = tw.WriteHeader(&tar.Header{
|
|
Name: "dir/./file",
|
|
Size: int64(len(fileContents)),
|
|
})
|
|
//failed to write tar file header
|
|
assert.NilError(c, err)
|
|
|
|
_, err = tw.Write(fileContents)
|
|
// failed to write file contents in tar file content
|
|
assert.NilError(c, err)
|
|
|
|
// failed to close tar archive
|
|
assert.NilError(c, tw.Close())
|
|
|
|
res, body, err := request.Post("/build", request.RawContent(ioutil.NopCloser(buffer)), request.ContentType("application/x-tar"))
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
lines := strings.Split(string(out), "\n")
|
|
assert.Assert(c, len(lines) > 1)
|
|
matched, err := regexp.MatchString(".*Successfully built [0-9a-f]{12}.*", lines[len(lines)-2])
|
|
assert.NilError(c, err)
|
|
assert.Assert(c, matched)
|
|
|
|
re := regexp.MustCompile("Successfully built ([0-9a-f]{12})")
|
|
matches := re.FindStringSubmatch(lines[len(lines)-2])
|
|
return matches[1]
|
|
}
|
|
|
|
imageA := buildFromTarContext([]byte("abc"))
|
|
imageB := buildFromTarContext([]byte("def"))
|
|
|
|
assert.Assert(c, imageA != imageB)
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildOnBuildWithCopy(c *testing.T) {
|
|
dockerfile := `
|
|
FROM ` + minimalBaseImage() + ` as onbuildbase
|
|
ONBUILD COPY file /file
|
|
|
|
FROM onbuildbase
|
|
`
|
|
ctx := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
fakecontext.WithFile("file", "some content"),
|
|
)
|
|
defer ctx.Close()
|
|
|
|
res, body, err := request.Post(
|
|
"/build",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Assert(c, is.Contains(string(out), "Successfully built"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildOnBuildCache(c *testing.T) {
|
|
build := func(dockerfile string) []byte {
|
|
ctx := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
)
|
|
defer ctx.Close()
|
|
|
|
res, body, err := request.Post(
|
|
"/build",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Assert(c, is.Contains(string(out), "Successfully built"))
|
|
return out
|
|
}
|
|
|
|
dockerfile := `
|
|
FROM ` + minimalBaseImage() + ` as onbuildbase
|
|
ENV something=bar
|
|
ONBUILD ENV foo=bar
|
|
`
|
|
build(dockerfile)
|
|
|
|
dockerfile += "FROM onbuildbase"
|
|
out := build(dockerfile)
|
|
|
|
imageIDs := getImageIDsFromBuild(c, out)
|
|
assert.Assert(c, is.Len(imageIDs, 2))
|
|
parentID, childID := imageIDs[0], imageIDs[1]
|
|
|
|
client := testEnv.APIClient()
|
|
|
|
// check parentID is correct
|
|
image, _, err := client.ImageInspectWithRaw(context.Background(), childID)
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.Equal(parentID, image.Parent))
|
|
}
|
|
|
|
func (s *DockerRegistrySuite) TestBuildCopyFromForcePull(c *testing.T) {
|
|
client := testEnv.APIClient()
|
|
|
|
repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
|
|
// tag the image to upload it to the private registry
|
|
err := client.ImageTag(context.TODO(), "busybox", repoName)
|
|
assert.Check(c, err)
|
|
// push the image to the registry
|
|
rc, err := client.ImagePush(context.TODO(), repoName, types.ImagePushOptions{RegistryAuth: "{}"})
|
|
assert.Check(c, err)
|
|
_, err = io.Copy(ioutil.Discard, rc)
|
|
assert.Check(c, err)
|
|
|
|
dockerfile := fmt.Sprintf(`
|
|
FROM %s AS foo
|
|
RUN touch abc
|
|
FROM %s
|
|
COPY --from=foo /abc /
|
|
`, repoName, repoName)
|
|
|
|
ctx := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
)
|
|
defer ctx.Close()
|
|
|
|
res, body, err := request.Post(
|
|
"/build?pull=1",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.Contains(string(out), "Successfully built"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAddRemoteNoDecompress(c *testing.T) {
|
|
buffer := new(bytes.Buffer)
|
|
tw := tar.NewWriter(buffer)
|
|
dt := []byte("contents")
|
|
err := tw.WriteHeader(&tar.Header{
|
|
Name: "foo",
|
|
Size: int64(len(dt)),
|
|
Mode: 0600,
|
|
Typeflag: tar.TypeReg,
|
|
})
|
|
assert.NilError(c, err)
|
|
_, err = tw.Write(dt)
|
|
assert.NilError(c, err)
|
|
err = tw.Close()
|
|
assert.NilError(c, err)
|
|
|
|
server := fakestorage.New(c, "", fakecontext.WithBinaryFiles(map[string]*bytes.Buffer{
|
|
"test.tar": buffer,
|
|
}))
|
|
defer server.Close()
|
|
|
|
dockerfile := fmt.Sprintf(`
|
|
FROM busybox
|
|
ADD %s/test.tar /
|
|
RUN [ -f test.tar ]
|
|
`, server.URL())
|
|
|
|
ctx := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
)
|
|
defer ctx.Close()
|
|
|
|
res, body, err := request.Post(
|
|
"/build",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.Contains(string(out), "Successfully built"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildChownOnCopy(c *testing.T) {
|
|
// new feature added in 1.31 - https://github.com/moby/moby/pull/34263
|
|
testRequires(c, DaemonIsLinux, MinimumAPIVersion("1.31"))
|
|
dockerfile := `FROM busybox
|
|
RUN echo 'test1:x:1001:1001::/bin:/bin/false' >> /etc/passwd
|
|
RUN echo 'test1:x:1001:' >> /etc/group
|
|
RUN echo 'test2:x:1002:' >> /etc/group
|
|
COPY --chown=test1:1002 . /new_dir
|
|
RUN ls -l /
|
|
RUN [ $(ls -l / | grep new_dir | awk '{print $3":"$4}') = 'test1:test2' ]
|
|
RUN [ $(ls -nl / | grep new_dir | awk '{print $3":"$4}') = '1001:1002' ]
|
|
`
|
|
ctx := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
fakecontext.WithFile("test_file1", "some test content"),
|
|
)
|
|
defer ctx.Close()
|
|
|
|
res, body, err := request.Post(
|
|
"/build",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.Contains(string(out), "Successfully built"))
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildCopyCacheOnFileChange(c *testing.T) {
|
|
|
|
dockerfile := `FROM busybox
|
|
COPY file /file`
|
|
|
|
ctx1 := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
fakecontext.WithFile("file", "foo"))
|
|
ctx2 := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
fakecontext.WithFile("file", "bar"))
|
|
|
|
var build = func(ctx *fakecontext.Fake) string {
|
|
res, body, err := request.Post("/build",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Assert(c, is.Contains(string(out), "Successfully built"))
|
|
|
|
ids := getImageIDsFromBuild(c, out)
|
|
assert.Assert(c, is.Len(ids, 1))
|
|
return ids[len(ids)-1]
|
|
}
|
|
|
|
id1 := build(ctx1)
|
|
id2 := build(ctx1)
|
|
id3 := build(ctx2)
|
|
|
|
if id1 != id2 {
|
|
c.Fatal("didn't use the cache")
|
|
}
|
|
if id1 == id3 {
|
|
c.Fatal("COPY With different source file should not share same cache")
|
|
}
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildAddCacheOnFileChange(c *testing.T) {
|
|
|
|
dockerfile := `FROM busybox
|
|
ADD file /file`
|
|
|
|
ctx1 := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
fakecontext.WithFile("file", "foo"))
|
|
ctx2 := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
fakecontext.WithFile("file", "bar"))
|
|
|
|
var build = func(ctx *fakecontext.Fake) string {
|
|
res, body, err := request.Post("/build",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Assert(c, is.Contains(string(out), "Successfully built"))
|
|
|
|
ids := getImageIDsFromBuild(c, out)
|
|
assert.Assert(c, is.Len(ids, 1))
|
|
return ids[len(ids)-1]
|
|
}
|
|
|
|
id1 := build(ctx1)
|
|
id2 := build(ctx1)
|
|
id3 := build(ctx2)
|
|
|
|
if id1 != id2 {
|
|
c.Fatal("didn't use the cache")
|
|
}
|
|
if id1 == id3 {
|
|
c.Fatal("COPY With different source file should not share same cache")
|
|
}
|
|
}
|
|
|
|
func (s *DockerSuite) TestBuildScratchCopy(c *testing.T) {
|
|
testRequires(c, DaemonIsLinux)
|
|
dockerfile := `FROM scratch
|
|
ADD Dockerfile /
|
|
ENV foo bar`
|
|
ctx := fakecontext.New(c, "",
|
|
fakecontext.WithDockerfile(dockerfile),
|
|
)
|
|
defer ctx.Close()
|
|
|
|
res, body, err := request.Post(
|
|
"/build",
|
|
request.RawContent(ctx.AsTarReader(c)),
|
|
request.ContentType("application/x-tar"))
|
|
assert.NilError(c, err)
|
|
assert.Equal(c, res.StatusCode, http.StatusOK)
|
|
|
|
out, err := request.ReadBody(body)
|
|
assert.NilError(c, err)
|
|
assert.Check(c, is.Contains(string(out), "Successfully built"))
|
|
}
|
|
|
|
type buildLine struct {
|
|
Stream string
|
|
Aux struct {
|
|
ID string
|
|
}
|
|
}
|
|
|
|
func getImageIDsFromBuild(c *testing.T, output []byte) []string {
|
|
var ids []string
|
|
for _, line := range bytes.Split(output, []byte("\n")) {
|
|
if len(line) == 0 {
|
|
continue
|
|
}
|
|
entry := buildLine{}
|
|
assert.NilError(c, json.Unmarshal(line, &entry))
|
|
if entry.Aux.ID != "" {
|
|
ids = append(ids, entry.Aux.ID)
|
|
}
|
|
}
|
|
return ids
|
|
}
|