Extract some common thigns into helpers

cpuguy83 · cpuguy83 · commit aff98e0dda53 · 2024-07-02T19:47:11.000Z
- ShArgs - run a command in a shell
- Sources - Iterate spec sources and get states
- Tar - Make a tar from an llb.State

Also fixes some typos.

Signed-off-by: Brian Goff &lt;cpuguy83@gmail.com&gt;
diff --git a/frontend/azlinux/handle_container.go b/frontend/azlinux/handle_container.go
@@ -130,14 +130,14 @@ func readRPMs(ctx context.Context, client gwclient.Client, st llb.State) ([]stri
 	return out, nil
 }
 
-func specToContainerLLB(w worker, client gwclient.Client, spec *dalec.Spec, target string, rpmDir llb.State, files []string, sOpt dalec.SourceOpts, opts ...llb.ConstraintsOpt) (llb.State, error) {
+func specToContainerLLB(w worker, client gwclient.Client, spec *dalec.Spec, targetKey string, rpmDir llb.State, files []string, sOpt dalec.SourceOpts, opts ...llb.ConstraintsOpt) (llb.State, error) {
 	opts = append(opts, dalec.ProgressGroup("Install RPMs"))
 	const workPath = "/tmp/rootfs"
 
 	builderImg := w.Base(client, opts...)
 
 	rootfs := llb.Scratch()
-	if ref := dalec.GetBaseOutputImage(spec, target); ref != "" {
+	if ref := dalec.GetBaseOutputImage(spec, targetKey); ref != "" {
 		rootfs = llb.Image(ref, llb.WithMetaResolver(sOpt.Resolver), dalec.WithConstraints(opts...))
 	}
 
diff --git a/frontend/azlinux/handle_depsonly.go b/frontend/azlinux/handle_depsonly.go
@@ -17,7 +17,7 @@ func handleDepsOnly(w worker) gwclient.BuildFunc {
 			pg := dalec.ProgressGroup("Build mariner2 deps-only container: " + spec.Name)
 			baseImg := w.Base(client, pg)
 			rpmDir := baseImg.Run(
-				shArgs(`set -ex; dir="/tmp/rpms/RPMS/$(uname -m)"; mkdir -p "${dir}"; tdnf install -y --releasever=2.0 --downloadonly --alldeps --downloaddir "${dir}" `+strings.Join(spec.GetRuntimeDeps(targetKey), " ")),
+				dalec.ShArgs(`set -ex; dir="/tmp/rpms/RPMS/$(uname -m)"; mkdir -p "${dir}"; tdnf install -y --releasever=2.0 --downloadonly --alldeps --downloaddir "${dir}" `+strings.Join(spec.GetRuntimeDeps(targetKey), " ")),
 				pg,
 			).
 				AddMount("/tmp/rpms", llb.Scratch())
diff --git a/frontend/azlinux/handle_rpm.go b/frontend/azlinux/handle_rpm.go
@@ -52,10 +52,6 @@ func handleRPM(w worker) gwclient.BuildFunc {
 	}
 }
 
-func shArgs(cmd string) llb.RunOption {
-	return llb.Args([]string{"sh", "-c", cmd})
-}
-
 func installBuildDeps(w worker, spec *dalec.Spec, targetKey string, opts ...llb.ConstraintsOpt) llb.StateOption {
 	return func(in llb.State) llb.State {
 		deps := spec.GetBuildDeps(targetKey)
diff --git a/frontend/azlinux/install.go b/frontend/azlinux/install.go
@@ -117,6 +117,6 @@ func tdnfInstall(cfg *installConfig, relVer string, pkgs []string) llb.RunOption
 		cmdArgs += "; " + manifestPath
 	}
 
-	runOpts = append(runOpts, shArgs(cmdArgs))
+	runOpts = append(runOpts, dalec.ShArgs(cmdArgs))
 	return dalec.WithRunOptions(runOpts...)
 }
diff --git a/frontend/debug/handle_sources.go b/frontend/debug/handle_sources.go
@@ -19,16 +19,12 @@ func Sources(ctx context.Context, client gwclient.Client) (*client.Result, error
 			return nil, nil, err
 		}
 
-		sources := make([]llb.State, 0, len(spec.Sources))
-		for name, src := range spec.Sources {
-			st, err := src.AsState(name, sOpt)
-			if err != nil {
-				return nil, nil, err
-			}
-			sources = append(sources, st)
+		sources, err := dalec.Sources(spec, sOpt)
+		if err != nil {
+			return nil, nil, err
 		}
 
-		def, err := dalec.MergeAtPath(llb.Scratch(), sources, "/").Marshal(ctx)
+		def, err := dalec.MergeAtPath(llb.Scratch(), dalec.SortedMapValues(sources), "/").Marshal(ctx)
 		if err != nil {
 			return nil, nil, err
 		}
diff --git a/frontend/rpm/handle_sources.go b/frontend/rpm/handle_sources.go
@@ -3,7 +3,6 @@ package rpm
 import (
 	"context"
 	"fmt"
-	"path/filepath"
 
 	"github.com/Azure/dalec"
 	"github.com/Azure/dalec/frontend"
@@ -13,35 +12,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-// TarImageRef is the image used to create tarballs of sources
-// This is purposefully exported so it can be overridden at compile time if needed.
-// Currently this image needs /bin/sh and tar in $PATH
-var TarImageRef = "busybox:latest"
-
-func shArgs(cmd string) llb.RunOption {
-	return llb.Args([]string{"sh", "-c", cmd})
-}
-
-func tar(src llb.State, dest string, opts ...llb.ConstraintsOpt) llb.State {
-	tarImg := llb.Image(TarImageRef, dalec.WithConstraints(opts...))
-
-	// Put the output tar in a consistent location regardless of `dest`
-	// This way if `dest` changes we don't have to rebuild the tarball, which can be expensive.
-	outBase := "/tmp/out"
-	out := filepath.Join(outBase, filepath.Dir(dest))
-	worker := tarImg.Run(
-		llb.AddMount("/src", src, llb.Readonly),
-		shArgs("tar -C /src -cvzf /tmp/st ."),
-		dalec.WithConstraints(opts...),
-	).
-		Run(
-			shArgs("mkdir -p "+out+" && mv /tmp/st "+filepath.Join(out, filepath.Base(dest))),
-			dalec.WithConstraints(opts...),
-		)
-
-	return worker.AddMount(outBase, llb.Scratch())
-}
-
 func HandleSources(wf WorkerFunc) gwclient.BuildFunc {
 	return func(ctx context.Context, client gwclient.Client) (*gwclient.Result, error) {
 		return frontend.BuildWithPlatform(ctx, client, func(ctx context.Context, client gwclient.Client, platform *ocispecs.Platform, spec *dalec.Spec, targetKey string) (gwclient.Reference, *dalec.DockerImageSpec, error) {
@@ -85,39 +55,39 @@ func HandleSources(wf WorkerFunc) gwclient.BuildFunc {
 }
 
 func Dalec2SourcesLLB(worker llb.State, spec *dalec.Spec, sOpt dalec.SourceOpts, opts ...llb.ConstraintsOpt) ([]llb.State, error) {
-	// Sort the map keys so that the order is consistent This shouldn't be
-	// needed when MergeOp is supported, but when it is not this will improve
-	// cache hits for callers of this function.
-	sorted := dalec.SortMapKeys(spec.Sources)
-
-	out := make([]llb.State, 0, len(spec.Sources))
-
-	for _, k := range sorted {
-		src := spec.Sources[k]
-		isDir := dalec.SourceIsDir(src)
-
-		pg := dalec.ProgressGroup("Add spec source: " + k)
-		st, err := src.AsState(k, sOpt, append(opts, pg)...)
-		if err != nil {
-			return nil, err
-		}
+	sources, err := dalec.Sources(spec, sOpt)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]llb.State, 0, len(sources))
 
-		if isDir {
-			out = append(out, tar(st, k+".tar.gz", append(opts, pg)...))
-		} else {
-			out = append(out, st)
-		}
+	withPG := func(s string) []llb.ConstraintsOpt {
+		return append(opts, dalec.ProgressGroup(s))
 	}
 
-	opts = append(opts, dalec.ProgressGroup("Add gomod sources"))
-	st, err := spec.GomodDeps(sOpt, worker, opts...)
+	st, err := spec.GomodDeps(sOpt, worker, withPG("Add gomod sources")...)
 	if err != nil {
 		return nil, errors.Wrap(err, "error adding gomod sources")
 	}
 
+	sorted := dalec.SortMapKeys(sources)
+	for _, k := range sorted {
+		st := sources[k]
+		if dalec.SourceIsDir(spec.Sources[k]) {
+			st = st.With(sourceTar(worker, k, withPG("Tar source: "+k)...))
+		}
+		out = append(out, st)
+	}
+
 	if st != nil {
-		out = append(out, tar(*st, gomodsName+".tar.gz", opts...))
+		out = append(out, st.With(sourceTar(worker, gomodsName, withPG("Tar gomod deps")...)))
 	}
 
 	return out, nil
 }
+
+func sourceTar(worker llb.State, key string, opts ...llb.ConstraintsOpt) llb.StateOption {
+	return func(in llb.State) llb.State {
+		return dalec.Tar(worker, in, key+".tar.gz", opts...)
+	}
+}
diff --git a/frontend/rpm/rpmbuild.go b/frontend/rpm/rpmbuild.go
@@ -29,7 +29,7 @@ func Build(topDir, workerImg llb.State, specPath string, opts ...llb.Constraints
 		// TODO(cpuguy83): specPath would ideally never change.
 		// We don't want to have to re-run this step just because the path changed, this should be based on inputs only (ie the content of the rpm spec, sources, etc)
 		// The path should not be an input.
-		shArgs(`rpmbuild --define "_topdir /build/top" --define "_srcrpmdir /build/out/SRPMS" --define "_rpmdir /build/out/RPMS" --buildroot /build/tmp/work -ba `+specPath),
+		dalec.ShArgs(`rpmbuild --define "_topdir /build/top" --define "_srcrpmdir /build/out/SRPMS" --define "_rpmdir /build/out/RPMS" --buildroot /build/tmp/work -ba `+specPath),
 		llb.AddMount("/build/top", topDir),
 		llb.AddMount("/build/tmp", llb.Scratch(), llb.Tmpfs()),
 		llb.Dir("/build/top"),
diff --git a/frontend/windows/handle_zip.go b/frontend/windows/handle_zip.go
@@ -60,20 +60,9 @@ func handleZip(ctx context.Context, client gwclient.Client) (*gwclient.Result, e
 const gomodsName = "__gomods"
 
 func specToSourcesLLB(worker llb.State, spec *dalec.Spec, sOpt dalec.SourceOpts, opts ...llb.ConstraintsOpt) (map[string]llb.State, error) {
-	out := make(map[string]llb.State, len(spec.Sources))
-	for k, src := range spec.Sources {
-		displayRef, err := src.GetDisplayRef()
-		if err != nil {
-			return nil, err
-		}
-
-		pg := dalec.ProgressGroup("Add spec source: " + k + " " + displayRef)
-		st, err := src.AsState(k, sOpt, append(opts, pg)...)
-		if err != nil {
-			return nil, errors.Wrapf(err, "error creating source state for %q", k)
-		}
-
-		out[k] = st
+	out, err := dalec.Sources(spec, sOpt, opts...)
+	if err != nil {
+		return nil, errors.Wrap(err, "error preparign spec sources")
 	}
 
 	opts = append(opts, dalec.ProgressGroup("Add gomod sources"))
@@ -99,7 +88,7 @@ func installBuildDeps(deps []string) llb.StateOption {
 		slices.Sort(sorted)
 
 		return s.Run(
-			shArgs("apt-get update && apt-get install -y "+strings.Join(sorted, " ")),
+			dalec.ShArgs("apt-get update && apt-get install -y "+strings.Join(sorted, " ")),
 			dalec.WithMountedAptCache(aptCachePrefix),
 		).Root()
 	}
@@ -148,7 +137,7 @@ func buildBinaries(ctx context.Context, spec *dalec.Spec, worker llb.State, clie
 	script := generateInvocationScript(binaries)
 
 	st := worker.Run(
-		shArgs(script.String()),
+		dalec.ShArgs(script.String()),
 		llb.Dir("/build"),
 		withSourcesMounted("/build", patched, spec.Sources),
 		llb.AddMount("/tmp/scripts", buildScript),
@@ -170,7 +159,7 @@ func buildBinaries(ctx context.Context, spec *dalec.Spec, worker llb.State, clie
 func getZipLLB(worker llb.State, name string, artifacts llb.State) llb.State {
 	outName := filepath.Join(outputDir, name+".zip")
 	zipped := worker.Run(
-		shArgs("zip "+outName+" *"),
+		dalec.ShArgs("zip "+outName+" *"),
 		llb.Dir("/tmp/artifacts"),
 		llb.AddMount("/tmp/artifacts", artifacts),
 	).AddMount(outputDir, llb.Scratch())
@@ -192,15 +181,11 @@ func workerImg(sOpt dalec.SourceOpts, opts ...llb.ConstraintsOpt) llb.State {
 	// TODO: support named context override... also this should possibly be its own image, maybe?
 	return llb.Image(workerImgRef, llb.WithMetaResolver(sOpt.Resolver), dalec.WithConstraints(opts...)).
 		Run(
-			shArgs("apt-get update && apt-get install -y build-essential binutils-mingw-w64 g++-mingw-w64-x86-64 gcc git make pkg-config quilt zip"),
+			dalec.ShArgs("apt-get update && apt-get install -y build-essential binutils-mingw-w64 g++-mingw-w64-x86-64 gcc git make pkg-config quilt zip"),
 			dalec.WithMountedAptCache(aptCachePrefix),
 		).Root()
 }
 
-func shArgs(cmd string) llb.RunOption {
-	return llb.Args([]string{"sh", "-c", cmd})
-}
-
 func createBuildScript(spec *dalec.Spec) llb.State {
 	buf := bytes.NewBuffer(nil)
 
diff --git a/generator_gomod.go b/generator_gomod.go
@@ -38,7 +38,7 @@ func withGomod(g *SourceGenerator, srcSt, worker llb.State, opts ...llb.Constrai
 			srcMount = llb.AddMount(workDir, srcSt)
 		}
 		return worker.Run(
-			shArgs("go mod download"),
+			ShArgs("go mod download"),
 			llb.AddEnv("GOMODCACHE", gomodCacheDir),
 			llb.Dir(workDir),
 			srcMount,
diff --git a/helpers.go b/helpers.go
@@ -385,3 +385,15 @@ func (s *Spec) GetSigner(targetKey string) (*PackageSigner, bool) {
 func hasValidSigner(pc *PackageConfig) bool {
 	return pc != nil && pc.Signer != nil && pc.Signer.Image != ""
 }
+
+// SortMapValues is like [maps.Values], but the list is sorted based on the map key
+func SortedMapValues[T any](m map[string]T) []T {
+	keys := SortMapKeys(m)
+
+	out := make([]T, 0, len(keys))
+	for _, k := range keys {
+		out = append(out, m[k])
+	}
+
+	return out
+}
diff --git a/source.go b/source.go
@@ -175,10 +175,6 @@ type SourceOpts struct {
 	GetContext func(string, ...llb.LocalOption) (*llb.State, error)
 }
 
-func shArgs(cmd string) llb.RunOption {
-	return llb.Args([]string{"sh", "-c", cmd})
-}
-
 func (s *Source) asState(name string, forMount bool, sOpt SourceOpts, opts ...llb.ConstraintsOpt) (llb.State, error) {
 	st, err := getSource(*s, name, sOpt, opts...)
 	if err != nil {
@@ -514,7 +510,7 @@ func patchSource(worker, sourceState llb.State, sourceToState map[string]llb.Sta
 		sourceState = worker.Run(
 			llb.AddMount("/patch", patchState, llb.Readonly, llb.SourcePath(p.Source)),
 			llb.Dir("src"),
-			shArgs(fmt.Sprintf("patch -p%d < /patch", *p.Strip)),
+			ShArgs(fmt.Sprintf("patch -p%d < /patch", *p.Strip)),
 			WithConstraints(opts...),
 		).AddMount("/src", sourceState)
 	}
@@ -574,3 +570,45 @@ func (s *Spec) getPatchedSources(sOpt SourceOpts, worker llb.State, filterFunc f
 
 	return PatchSources(worker, s, states, opts...), nil
 }
+
+// Tar creates a tar+gz from the provided state and puts it in the provided dest.
+// The provided work state is used to perform the necessary operations to produce the tarball and requires the tar and gzip binaries.
+func Tar(work llb.State, src llb.State, dest string, opts ...llb.ConstraintsOpt) llb.State {
+	// Put the output tar in a consistent location regardless of `dest`
+	// This way if `dest` changes we don't have to rebuild the tarball, which can be expensive.
+	outBase := "/tmp/out"
+	out := filepath.Join(outBase, filepath.Dir(dest))
+	worker := work.Run(
+		llb.AddMount("/src", src, llb.Readonly),
+		ShArgs("tar -C /src -cvzf /tmp/st ."),
+		WithConstraints(opts...),
+	).
+		Run(
+			llb.Args([]string{"/bin/sh", "-c", "mkdir -p " + out + " && mv /tmp/st " + filepath.Join(out, filepath.Base(dest))}),
+			WithConstraints(opts...),
+		)
+
+	return worker.AddMount(outBase, llb.Scratch())
+}
+
+func DefaultTarWorker(resolver llb.ImageMetaResolver, opts ...llb.ConstraintsOpt) llb.State {
+	return llb.Image("busybox:latest", llb.WithMetaResolver(resolver), withConstraints(opts))
+}
+
+// Sources gets all the source LLB states from the spec.
+func Sources(spec *Spec, sOpt SourceOpts, opts ...llb.ConstraintsOpt) (map[string]llb.State, error) {
+	states := make(map[string]llb.State, len(spec.Sources))
+
+	for k, src := range spec.Sources {
+		pg := ProgressGroup("Prepare source: " + k)
+		opts := append(opts, pg)
+
+		st, err := src.AsState(k, sOpt, opts...)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not get source state for source: %s", k)
+		}
+
+		states[k] = st
+	}
+	return states, nil
+}
diff --git a/source_build_test.go b/source_build_test.go
@@ -30,7 +30,7 @@ func TestSourceBuild(t *testing.T) {
 		t.Errorf("expected identifier %q, got %q", xID, id)
 	}
 
-	// To reuse code, let's craft an equivelant SourceDockerImage with cmd's
+	// To reuse code, let's craft an equivalent SourceDockerImage with cmd's
 	// We'll use that to validate the ops we got from the build source with [checkCmd]
 	srcDI := SourceDockerImage{
 		Ref: xID,
@@ -53,7 +53,7 @@ func TestSourceBuild(t *testing.T) {
 			src := src
 			src.Path = "subdir"
 
-			// for build soruce, we expect to have a copy operation as the last op
+			// for build source, we expect to have a copy operation as the last op
 			ops := getSourceOp(ctx, t, src)
 
 			checkCmd(t, ops[1:len(ops)-1], &Source{DockerImage: &srcDI}, [][]expectMount{{rootMount}, {rootMount, expectMount{dest: "subdir"}}})
@@ -65,7 +65,7 @@ func TestSourceBuild(t *testing.T) {
 			src.Includes = []string{"foo", "bar"}
 			src.Excludes = []string{"baz"}
 
-			// for build soruce, we expect to have a copy operation as the last op
+			// for build source, we expect to have a copy operation as the last op
 			ops := getSourceOp(ctx, t, src)
 			checkCmd(t, ops[1:len(ops)-1], &Source{DockerImage: &srcDI}, [][]expectMount{noMountCheck, noMountCheck})
 			checkFilter(t, ops[len(ops)-1].GetFile(), &src)
diff --git a/source_test.go b/source_test.go
@@ -516,7 +516,7 @@ func TestSourceContext(t *testing.T) {
 				src.Path = "subdir"
 				ops := getSourceOp(ctx, t, src)
 				checkContext(t, ops[0].GetSource(), &src)
-				// for context soruce, we expect to have a copy operation as the last op when subdir is used
+				// for context source, we expect to have a copy operation as the last op when subdir is used
 				checkFilter(t, ops[1].GetFile(), &src)
 			})
 
@@ -539,7 +539,7 @@ func TestSourceContext(t *testing.T) {
 				src.Excludes = []string{"baz"}
 				ops := getSourceOp(ctx, t, src)
 				checkContext(t, ops[0].GetSource(), &src)
-				// for context soruce, we expect to have a copy operation as the last op when subdir is used
+				// for context source, we expect to have a copy operation as the last op when subdir is used
 
 				// set includes, excludes to nil before checking against filter, as includes and excludes are
 				// handled before filter operation for context sources
@@ -1024,7 +1024,7 @@ type stubMetaResolver struct{}
 
 func (stubMetaResolver) ResolveImageConfig(ctx context.Context, ref string, opt sourceresolver.Opt) (string, digest.Digest, []byte, error) {
 	// Craft a dummy image config
-	// If we don't put at least 1 diffID, buildkit will treat this as `FROM scratch` (and actually litterally convert it `llb.Scratch`)
+	// If we don't put at least 1 diffID, buildkit will treat this as `FROM scratch` (and actually literally convert it `llb.Scratch`)
 	// This affects what ops that get marshaled.
 	// Namely it removes our `docker-image` identifier op.
 	img := DockerImageSpec{
diff --git a/test/azlinux_test.go b/test/azlinux_test.go
diff --git a/test/testenv/builld.go b/test/testenv/builld.go

Original file line number	Diff line number	Diff line change
`@@ -130,14 +130,14 @@ func readRPMs(ctx context.Context, client gwclient.Client, st llb.State) ([]stri`
`130`	`130`	`return out, nil`
`131`	`131`	`}`
`132`	`132`
`133`		`-func specToContainerLLB(w worker, client gwclient.Client, spec *dalec.Spec, target string, rpmDir llb.State, files []string, sOpt dalec.SourceOpts, opts ...llb.ConstraintsOpt) (llb.State, error) {`
	`133`	`+func specToContainerLLB(w worker, client gwclient.Client, spec *dalec.Spec, targetKey string, rpmDir llb.State, files []string, sOpt dalec.SourceOpts, opts ...llb.ConstraintsOpt) (llb.State, error) {`
`134`	`134`	`opts = append(opts, dalec.ProgressGroup("Install RPMs"))`
`135`	`135`	`const workPath = "/tmp/rootfs"`
`136`	`136`
`137`	`137`	`builderImg := w.Base(client, opts...)`
`138`	`138`
`139`	`139`	`rootfs := llb.Scratch()`
`140`		`- if ref := dalec.GetBaseOutputImage(spec, target); ref != "" {`
	`140`	`+ if ref := dalec.GetBaseOutputImage(spec, targetKey); ref != "" {`
`141`	`141`	`rootfs = llb.Image(ref, llb.WithMetaResolver(sOpt.Resolver), dalec.WithConstraints(opts...))`
`142`	`142`	`}`
`143`	`143`
Original file line number	Diff line number	Diff line change
`@@ -52,10 +52,6 @@ func handleRPM(w worker) gwclient.BuildFunc {`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`-func shArgs(cmd string) llb.RunOption {`
`56`		`- return llb.Args([]string{"sh", "-c", cmd})`
`57`		`-}`
`58`		`-`
`59`	`55`	`func installBuildDeps(w worker, spec *dalec.Spec, targetKey string, opts ...llb.ConstraintsOpt) llb.StateOption {`
`60`	`56`	`return func(in llb.State) llb.State {`
`61`	`57`	`deps := spec.GetBuildDeps(targetKey)`
Original file line number	Diff line number	Diff line change
`@@ -117,6 +117,6 @@ func tdnfInstall(cfg *installConfig, relVer string, pkgs []string) llb.RunOption`
`117`	`117`	`cmdArgs += "; " + manifestPath`
`118`	`118`	`}`
`119`	`119`
`120`		`- runOpts = append(runOpts, shArgs(cmdArgs))`
	`120`	`+ runOpts = append(runOpts, dalec.ShArgs(cmdArgs))`
`121`	`121`	`return dalec.WithRunOptions(runOpts...)`
`122`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,16 +19,12 @@ func Sources(ctx context.Context, client gwclient.Client) (*client.Result, error`
`19`	`19`	`return nil, nil, err`
`20`	`20`	`}`
`21`	`21`
`22`		`- sources := make([]llb.State, 0, len(spec.Sources))`
`23`		`- for name, src := range spec.Sources {`
`24`		`- st, err := src.AsState(name, sOpt)`
`25`		`- if err != nil {`
`26`		`- return nil, nil, err`
`27`		`- }`
`28`		`- sources = append(sources, st)`
	`22`	`+ sources, err := dalec.Sources(spec, sOpt)`
	`23`	`+ if err != nil {`
	`24`	`+ return nil, nil, err`
`29`	`25`	`}`
`30`	`26`
`31`		`- def, err := dalec.MergeAtPath(llb.Scratch(), sources, "/").Marshal(ctx)`
	`27`	`+ def, err := dalec.MergeAtPath(llb.Scratch(), dalec.SortedMapValues(sources), "/").Marshal(ctx)`
`32`	`28`	`if err != nil {`
`33`	`29`	`return nil, nil, err`
`34`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ func withGomod(g *SourceGenerator, srcSt, worker llb.State, opts ...llb.Constrai`
`38`	`38`	`srcMount = llb.AddMount(workDir, srcSt)`
`39`	`39`	`}`
`40`	`40`	`return worker.Run(`
`41`		`- shArgs("go mod download"),`
	`41`	`+ ShArgs("go mod download"),`
`42`	`42`	`llb.AddEnv("GOMODCACHE", gomodCacheDir),`
`43`	`43`	`llb.Dir(workDir),`
`44`	`44`	`srcMount,`