package build // import "github.com/docker/docker/integration/build" import ( "archive/tar" "bytes" "context" "encoding/json" "io" "io/ioutil" "strings" "testing" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" "github.com/docker/docker/api/types/versions" "github.com/docker/docker/errdefs" "github.com/docker/docker/internal/test/fakecontext" "github.com/docker/docker/pkg/jsonmessage" "gotest.tools/assert" is "gotest.tools/assert/cmp" "gotest.tools/skip" ) func TestBuildWithRemoveAndForceRemove(t *testing.T) { skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME") defer setupTest(t)() cases := []struct { name string dockerfile string numberOfIntermediateContainers int rm bool forceRm bool }{ { name: "successful build with no removal", dockerfile: `FROM busybox RUN exit 0 RUN exit 0`, numberOfIntermediateContainers: 2, rm: false, forceRm: false, }, { name: "successful build with remove", dockerfile: `FROM busybox RUN exit 0 RUN exit 0`, numberOfIntermediateContainers: 0, rm: true, forceRm: false, }, { name: "successful build with remove and force remove", dockerfile: `FROM busybox RUN exit 0 RUN exit 0`, numberOfIntermediateContainers: 0, rm: true, forceRm: true, }, { name: "failed build with no removal", dockerfile: `FROM busybox RUN exit 0 RUN exit 1`, numberOfIntermediateContainers: 2, rm: false, forceRm: false, }, { name: "failed build with remove", dockerfile: `FROM busybox RUN exit 0 RUN exit 1`, numberOfIntermediateContainers: 1, rm: true, forceRm: false, }, { name: "failed build with remove and force remove", dockerfile: `FROM busybox RUN exit 0 RUN exit 1`, numberOfIntermediateContainers: 0, rm: true, forceRm: true, }, } client := testEnv.APIClient() ctx := context.Background() for _, c := range cases { t.Run(c.name, func(t *testing.T) { t.Parallel() dockerfile := []byte(c.dockerfile) buff := bytes.NewBuffer(nil) tw := tar.NewWriter(buff) assert.NilError(t, tw.WriteHeader(&tar.Header{ Name: "Dockerfile", Size: int64(len(dockerfile)), })) _, err := tw.Write(dockerfile) assert.NilError(t, err) assert.NilError(t, tw.Close()) resp, err := client.ImageBuild(ctx, buff, types.ImageBuildOptions{Remove: c.rm, ForceRemove: c.forceRm, NoCache: true}) assert.NilError(t, err) defer resp.Body.Close() filter, err := buildContainerIdsFilter(resp.Body) assert.NilError(t, err) remainingContainers, err := client.ContainerList(ctx, types.ContainerListOptions{Filters: filter, All: true}) assert.NilError(t, err) assert.Equal(t, c.numberOfIntermediateContainers, len(remainingContainers), "Expected %v remaining intermediate containers, got %v", c.numberOfIntermediateContainers, len(remainingContainers)) }) } } func buildContainerIdsFilter(buildOutput io.Reader) (filters.Args, error) { const intermediateContainerPrefix = " ---> Running in " filter := filters.NewArgs() dec := json.NewDecoder(buildOutput) for { m := jsonmessage.JSONMessage{} err := dec.Decode(&m) if err == io.EOF { return filter, nil } if err != nil { return filter, err } if ix := strings.Index(m.Stream, intermediateContainerPrefix); ix != -1 { filter.Add("id", strings.TrimSpace(m.Stream[ix+len(intermediateContainerPrefix):])) } } } // TestBuildMultiStageCopy verifies that copying between stages works correctly. // // Regression test for docker/for-win#4349, ENGCORE-935, where creating the target // directory failed on Windows, because `os.MkdirAll()` was called with a volume // GUID path (\\?\Volume{dae8d3ac-b9a1-11e9-88eb-e8554b2ba1db}\newdir\hello}), // which currently isn't supported by Golang. func TestBuildMultiStageCopy(t *testing.T) { ctx := context.Background() dockerfile, err := ioutil.ReadFile("testdata/Dockerfile." + t.Name()) assert.NilError(t, err) source := fakecontext.New(t, "", fakecontext.WithDockerfile(string(dockerfile))) defer source.Close() apiclient := testEnv.APIClient() for _, target := range []string{"copy_to_root", "copy_to_newdir", "copy_to_newdir_nested", "copy_to_existingdir", "copy_to_newsubdir"} { t.Run(target, func(t *testing.T) { imgName := strings.ToLower(t.Name()) resp, err := apiclient.ImageBuild( ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, Target: target, Tags: []string{imgName}, }, ) assert.NilError(t, err) out := bytes.NewBuffer(nil) _, err = io.Copy(out, resp.Body) _ = resp.Body.Close() if err != nil { t.Log(out) } assert.NilError(t, err) // verify the image was successfully built _, _, err = apiclient.ImageInspectWithRaw(ctx, imgName) if err != nil { t.Log(out) } assert.NilError(t, err) }) } } func TestBuildMultiStageParentConfig(t *testing.T) { skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.35"), "broken in earlier versions") skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME") dockerfile := ` FROM busybox AS stage0 ENV WHO=parent WORKDIR /foo FROM stage0 ENV WHO=sibling1 WORKDIR sub1 FROM stage0 WORKDIR sub2 ` ctx := context.Background() source := fakecontext.New(t, "", fakecontext.WithDockerfile(dockerfile)) defer source.Close() apiclient := testEnv.APIClient() resp, err := apiclient.ImageBuild(ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, Tags: []string{"build1"}, }) assert.NilError(t, err) _, err = io.Copy(ioutil.Discard, resp.Body) resp.Body.Close() assert.NilError(t, err) image, _, err := apiclient.ImageInspectWithRaw(ctx, "build1") assert.NilError(t, err) expected := "/foo/sub2" if testEnv.DaemonInfo.OSType == "windows" { expected = `C:\foo\sub2` } assert.Check(t, is.Equal(expected, image.Config.WorkingDir)) assert.Check(t, is.Contains(image.Config.Env, "WHO=parent")) } // Test cases in #36996 func TestBuildLabelWithTargets(t *testing.T) { skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.38"), "test added after 1.38") skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME") bldName := "build-a" testLabels := map[string]string{ "foo": "bar", "dead": "beef", } dockerfile := ` FROM busybox AS target-a CMD ["/dev"] LABEL label-a=inline-a FROM busybox AS target-b CMD ["/dist"] LABEL label-b=inline-b ` ctx := context.Background() source := fakecontext.New(t, "", fakecontext.WithDockerfile(dockerfile)) defer source.Close() apiclient := testEnv.APIClient() // For `target-a` build resp, err := apiclient.ImageBuild(ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, Tags: []string{bldName}, Labels: testLabels, Target: "target-a", }) assert.NilError(t, err) _, err = io.Copy(ioutil.Discard, resp.Body) resp.Body.Close() assert.NilError(t, err) image, _, err := apiclient.ImageInspectWithRaw(ctx, bldName) assert.NilError(t, err) testLabels["label-a"] = "inline-a" for k, v := range testLabels { x, ok := image.Config.Labels[k] assert.Assert(t, ok) assert.Assert(t, x == v) } // For `target-b` build bldName = "build-b" delete(testLabels, "label-a") resp, err = apiclient.ImageBuild(ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, Tags: []string{bldName}, Labels: testLabels, Target: "target-b", }) assert.NilError(t, err) _, err = io.Copy(ioutil.Discard, resp.Body) resp.Body.Close() assert.NilError(t, err) image, _, err = apiclient.ImageInspectWithRaw(ctx, bldName) assert.NilError(t, err) testLabels["label-b"] = "inline-b" for k, v := range testLabels { x, ok := image.Config.Labels[k] assert.Assert(t, ok) assert.Assert(t, x == v) } } func TestBuildWithEmptyLayers(t *testing.T) { dockerfile := ` FROM busybox COPY 1/ /target/ COPY 2/ /target/ COPY 3/ /target/ ` ctx := context.Background() source := fakecontext.New(t, "", fakecontext.WithDockerfile(dockerfile), fakecontext.WithFile("1/a", "asdf"), fakecontext.WithFile("2/a", "asdf"), fakecontext.WithFile("3/a", "asdf")) defer source.Close() apiclient := testEnv.APIClient() resp, err := apiclient.ImageBuild(ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, }) assert.NilError(t, err) _, err = io.Copy(ioutil.Discard, resp.Body) resp.Body.Close() assert.NilError(t, err) } // TestBuildMultiStageOnBuild checks that ONBUILD commands are applied to // multiple subsequent stages // #35652 func TestBuildMultiStageOnBuild(t *testing.T) { skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.33"), "broken in earlier versions") skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME") defer setupTest(t)() // test both metadata and layer based commands as they may be implemented differently dockerfile := `FROM busybox AS stage1 ONBUILD RUN echo 'foo' >somefile ONBUILD ENV bar=baz FROM stage1 # fails if ONBUILD RUN fails RUN cat somefile FROM stage1 RUN cat somefile` ctx := context.Background() source := fakecontext.New(t, "", fakecontext.WithDockerfile(dockerfile)) defer source.Close() apiclient := testEnv.APIClient() resp, err := apiclient.ImageBuild(ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, }) out := bytes.NewBuffer(nil) assert.NilError(t, err) _, err = io.Copy(out, resp.Body) resp.Body.Close() assert.NilError(t, err) assert.Check(t, is.Contains(out.String(), "Successfully built")) imageIDs, err := getImageIDsFromBuild(out.Bytes()) assert.NilError(t, err) assert.Check(t, is.Equal(3, len(imageIDs))) image, _, err := apiclient.ImageInspectWithRaw(context.Background(), imageIDs[2]) assert.NilError(t, err) assert.Check(t, is.Contains(image.Config.Env, "bar=baz")) } // #35403 #36122 func TestBuildUncleanTarFilenames(t *testing.T) { skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.37"), "broken in earlier versions") skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME") ctx := context.TODO() defer setupTest(t)() dockerfile := `FROM scratch COPY foo / FROM scratch COPY bar /` buf := bytes.NewBuffer(nil) w := tar.NewWriter(buf) writeTarRecord(t, w, "Dockerfile", dockerfile) writeTarRecord(t, w, "../foo", "foocontents0") writeTarRecord(t, w, "/bar", "barcontents0") err := w.Close() assert.NilError(t, err) apiclient := testEnv.APIClient() resp, err := apiclient.ImageBuild(ctx, buf, types.ImageBuildOptions{ Remove: true, ForceRemove: true, }) out := bytes.NewBuffer(nil) assert.NilError(t, err) _, err = io.Copy(out, resp.Body) resp.Body.Close() assert.NilError(t, err) // repeat with changed data should not cause cache hits buf = bytes.NewBuffer(nil) w = tar.NewWriter(buf) writeTarRecord(t, w, "Dockerfile", dockerfile) writeTarRecord(t, w, "../foo", "foocontents1") writeTarRecord(t, w, "/bar", "barcontents1") err = w.Close() assert.NilError(t, err) resp, err = apiclient.ImageBuild(ctx, buf, types.ImageBuildOptions{ Remove: true, ForceRemove: true, }) out = bytes.NewBuffer(nil) assert.NilError(t, err) _, err = io.Copy(out, resp.Body) resp.Body.Close() assert.NilError(t, err) assert.Assert(t, !strings.Contains(out.String(), "Using cache")) } // docker/for-linux#135 // #35641 func TestBuildMultiStageLayerLeak(t *testing.T) { skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME") skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.37"), "broken in earlier versions") ctx := context.TODO() defer setupTest(t)() // all commands need to match until COPY dockerfile := `FROM busybox WORKDIR /foo COPY foo . FROM busybox WORKDIR /foo COPY bar . RUN [ -f bar ] RUN [ ! -f foo ] ` source := fakecontext.New(t, "", fakecontext.WithFile("foo", "0"), fakecontext.WithFile("bar", "1"), fakecontext.WithDockerfile(dockerfile)) defer source.Close() apiclient := testEnv.APIClient() resp, err := apiclient.ImageBuild(ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, }) out := bytes.NewBuffer(nil) assert.NilError(t, err) _, err = io.Copy(out, resp.Body) resp.Body.Close() assert.NilError(t, err) assert.Check(t, is.Contains(out.String(), "Successfully built")) } // #37581 func TestBuildWithHugeFile(t *testing.T) { skip.If(t, testEnv.OSType == "windows") ctx := context.TODO() defer setupTest(t)() dockerfile := `FROM busybox # create a sparse file with size over 8GB RUN for g in $(seq 0 8); do dd if=/dev/urandom of=rnd bs=1K count=1 seek=$((1024*1024*g)) status=none; done && \ ls -la rnd && du -sk rnd` buf := bytes.NewBuffer(nil) w := tar.NewWriter(buf) writeTarRecord(t, w, "Dockerfile", dockerfile) err := w.Close() assert.NilError(t, err) apiclient := testEnv.APIClient() resp, err := apiclient.ImageBuild(ctx, buf, types.ImageBuildOptions{ Remove: true, ForceRemove: true, }) out := bytes.NewBuffer(nil) assert.NilError(t, err) _, err = io.Copy(out, resp.Body) resp.Body.Close() assert.NilError(t, err) assert.Check(t, is.Contains(out.String(), "Successfully built")) } func TestBuildWithEmptyDockerfile(t *testing.T) { skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.40"), "broken in earlier versions") ctx := context.TODO() defer setupTest(t)() tests := []struct { name string dockerfile string expectedErr string }{ { name: "empty-dockerfile", dockerfile: "", expectedErr: "cannot be empty", }, { name: "empty-lines-dockerfile", dockerfile: ` `, expectedErr: "file with no instructions", }, { name: "comment-only-dockerfile", dockerfile: `# this is a comment`, expectedErr: "file with no instructions", }, } apiclient := testEnv.APIClient() for _, tc := range tests { tc := tc t.Run(tc.name, func(t *testing.T) { t.Parallel() buf := bytes.NewBuffer(nil) w := tar.NewWriter(buf) writeTarRecord(t, w, "Dockerfile", tc.dockerfile) err := w.Close() assert.NilError(t, err) _, err = apiclient.ImageBuild(ctx, buf, types.ImageBuildOptions{ Remove: true, ForceRemove: true, }) assert.Check(t, is.Contains(err.Error(), tc.expectedErr)) }) } } func TestBuildPreserveOwnership(t *testing.T) { skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME") skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.40"), "broken in earlier versions") ctx := context.Background() dockerfile, err := ioutil.ReadFile("testdata/Dockerfile.testBuildPreserveOwnership") assert.NilError(t, err) source := fakecontext.New(t, "", fakecontext.WithDockerfile(string(dockerfile))) defer source.Close() apiclient := testEnv.APIClient() for _, target := range []string{"copy_from", "copy_from_chowned"} { t.Run(target, func(t *testing.T) { resp, err := apiclient.ImageBuild( ctx, source.AsTarReader(t), types.ImageBuildOptions{ Remove: true, ForceRemove: true, Target: target, }, ) assert.NilError(t, err) out := bytes.NewBuffer(nil) _, err = io.Copy(out, resp.Body) _ = resp.Body.Close() if err != nil { t.Log(out) } assert.NilError(t, err) }) } } func TestBuildPlatformInvalid(t *testing.T) { skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.40"), "experimental in older versions") ctx := context.Background() defer setupTest(t)() dockerfile := `FROM busybox ` buf := bytes.NewBuffer(nil) w := tar.NewWriter(buf) writeTarRecord(t, w, "Dockerfile", dockerfile) err := w.Close() assert.NilError(t, err) apiclient := testEnv.APIClient() _, err = apiclient.ImageBuild(ctx, buf, types.ImageBuildOptions{ Remove: true, ForceRemove: true, Platform: "foobar", }) assert.Assert(t, err != nil) assert.ErrorContains(t, err, "unknown operating system or architecture") assert.Assert(t, errdefs.IsInvalidParameter(err)) } func writeTarRecord(t *testing.T, w *tar.Writer, fn, contents string) { err := w.WriteHeader(&tar.Header{ Name: fn, Mode: 0600, Size: int64(len(contents)), Typeflag: '0', }) assert.NilError(t, err) _, err = w.Write([]byte(contents)) assert.NilError(t, err) } type buildLine struct { Stream string Aux struct { ID string } } func getImageIDsFromBuild(output []byte) ([]string, error) { var ids []string for _, line := range bytes.Split(output, []byte("\n")) { if len(line) == 0 { continue } entry := buildLine{} if err := json.Unmarshal(line, &entry); err != nil { return nil, err } if entry.Aux.ID != "" { ids = append(ids, entry.Aux.ID) } } return ids, nil }