azlinux/mariner: Use provided platform for outputs

Before this change, the mariner/azl targets were ignoring the client
provided platform for the produced aritifacts.

With this change the platform is set on images so it will rely on
binfmt_misc to execute those images correctly.
There's probably some optimizations that can be made here to run certain
tasks on the native platform, some thoughts:

- Use native (host-arch) golang to download go modules
- Use native (host-arch) tdnf to download/install non-native packages
  onto the target build environment.

This does *not* add support for cross compilation (run x86 code to
generate, e.g., arm64 code).

Signed-off-by: Brian Goff <[email protected]>

.github/workflows/ci.yml

@@ -31,6 +31,12 @@ on:
       - go.mod
       - go.sum
 
+env:
+  # Used in tests to determine if certain tests should be skipped.
+  # Setting this ensures that they are *not* skipped and instead make sure CI
+  # is setup to be able to properly run all tests.
+  DALEC_CI: "1"
+
 permissions:
   contents: read
 
@@ -93,6 +99,8 @@ jobs:
         uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db # v3.6.1
       - name: download deps
         run: go mod download
+      - name: Setup QEMU
+        run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
       - name: Run integaration tests
         run: go test -v -json ./test | go run ./cmd/test2json2gha
       - name: dump logs

frontend/azlinux/handle_container.go

@@ -25,7 +25,7 @@ func handleContainer(w worker) gwclient.BuildFunc {
 
 			pg := dalec.ProgressGroup("Building " + targetKey + " container: " + spec.Name)
 
-			rpmDir, err := specToRpmLLB(ctx, w, client, spec, sOpt, targetKey, pg)
+			rpmDir, err := specToRpmLLB(ctx, w, client, spec, sOpt, targetKey, pg, dalec.WithPlatform(platform))
 			if err != nil {
 				return nil, nil, fmt.Errorf("error creating rpm: %w", err)
 			}
@@ -35,7 +35,7 @@ func handleContainer(w worker) gwclient.BuildFunc {
 				return nil, nil, err
 			}
 
-			st, err := specToContainerLLB(w, spec, targetKey, rpmDir, rpms, sOpt, pg)
+			st, err := specToContainerLLB(w, spec, targetKey, rpmDir, rpms, sOpt, pg, dalec.WithPlatform(platform))
 			if err != nil {
 				return nil, nil, err
 			}

frontend/azlinux/handle_depsonly.go

@@ -21,7 +21,7 @@ func handleDepsOnly(w worker) gwclient.BuildFunc {
 				return nil, nil, err
 			}
 
-			baseImg, err := w.Base(sOpt, pg)
+			baseImg, err := w.Base(sOpt, pg, dalec.WithPlatform(platform))
 			if err != nil {
 				return nil, nil, err
 			}

frontend/azlinux/handle_rpm.go

@@ -26,7 +26,7 @@ func handleRPM(w worker) gwclient.BuildFunc {
 				return nil, nil, err
 			}
 
-			st, err := specToRpmLLB(ctx, w, client, spec, sOpt, targetKey, pg)
+			st, err := specToRpmLLB(ctx, w, client, spec, sOpt, targetKey, pg, dalec.WithPlatform(platform))
 			if err != nil {
 				return nil, nil, err
 			}

frontend/debug/handler.go

@@ -25,6 +25,5 @@ func Handle(ctx context.Context, client gwclient.Client) (*gwclient.Result, erro
 		Name:        "gomods",
 		Description: "Outputs all the gomodule dependencies for the spec",
 	})
-
 	return r.Handle(ctx, client)
 }

frontend/gateway.go

@@ -17,10 +17,12 @@ import (
 )
 
 const (
-	requestIDKey               = "requestid"
-	dalecSubrequstForwardBuild = "dalec.forward.build"
+	// KeyRequestID is a key used in buildkit to performa subrequest
+	// This is exposed for convenience only.
+	KeyRequestID = "requestid"
 
-	gatewayFrontend = "gateway.v0"
+	dalecSubrequstForwardBuild = "dalec.forward.build"
+	gatewayFrontend            = "gateway.v0"
 )
 
 func getDockerfile(ctx context.Context, client gwclient.Client, build *dalec.SourceBuild, defPb *pb.Definition) ([]byte, error) {

frontend/mux.go

@@ -117,7 +117,7 @@ func (m *BuildMux) describe() (*gwclient.Result, error) {
 }
 
 func (m *BuildMux) handleSubrequest(ctx context.Context, client gwclient.Client, opts map[string]string) (*gwclient.Result, bool, error) {
-	switch opts[requestIDKey] {
+	switch opts[KeyRequestID] {
 	case "":
 		return nil, false, nil
 	case subrequests.RequestSubrequestsDescribe:
@@ -135,7 +135,7 @@ func (m *BuildMux) handleSubrequest(ctx context.Context, client gwclient.Client,
 		res, err := handleDefaultPlatform()
 		return res, true, err
 	default:
-		return nil, false, errors.Errorf("unsupported subrequest %q", opts[requestIDKey])
+		return nil, false, errors.Errorf("unsupported subrequest %q", opts[KeyRequestID])
 	}
 }
 
@@ -369,7 +369,7 @@ func (m *BuildMux) Handle(ctx context.Context, client gwclient.Client) (_ *gwcli
 		WithFields(logrus.Fields{
 			"handlers":  maps.Keys(m.handlers),
 			"target":    opts[keyTarget],
-			"requestid": opts[requestIDKey],
+			"requestid": opts[KeyRequestID],
 			"targetKey": GetTargetKey(client),
 		}))
 
@@ -403,7 +403,7 @@ func (m *BuildMux) Handle(ctx context.Context, client gwclient.Client) (_ *gwcli
 
 	// If this request was a request to list targets, we need to modify the response a bit
 	// Otherwise we can just return the result as is.
-	if opts[requestIDKey] == bktargets.SubrequestsTargetsDefinition.Name {
+	if opts[KeyRequestID] == bktargets.SubrequestsTargetsDefinition.Name {
 		return m.fixupListResult(matched, res)
 	}
 	return res, nil

helpers.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/moby/buildkit/client/llb"
 	"github.com/moby/buildkit/identity"
+	ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
 var disableDiffMerge atomic.Bool
@@ -399,3 +400,12 @@ func SortedMapValues[T any](m map[string]T) []T {
 
 	return out
 }
+
+// WithPlatform sets the platform in the constraints opts
+// This is similar to [llb.Platform] except this takes a pointer so you don't
+// need to worry about dereferencing a potentially nil pointer.
+func WithPlatform(p *ocispecs.Platform) llb.ConstraintsOpt {
+	return constraintsOptFunc(func(c *llb.Constraints) {
+		c.Platform = p
+	})
+}

test/azlinux_test.go

@@ -1,7 +1,9 @@
 package test
 
 import (
+	"bytes"
 	"context"
+	"debug/elf"
 	"errors"
 	"fmt"
 	"os"
@@ -10,9 +12,16 @@ import (
 
 	"github.com/Azure/dalec"
 	"github.com/Azure/dalec/frontend/azlinux"
+	"github.com/containerd/platforms"
 	"github.com/moby/buildkit/client/llb"
 	gwclient "github.com/moby/buildkit/frontend/gateway/client"
 	moby_buildkit_v1_frontend "github.com/moby/buildkit/frontend/gateway/pb"
+	ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
+)
+
+var (
+	linuxAmd64 = ocispecs.Platform{OS: "linux", Architecture: "amd64"}
+	linuxArm64 = ocispecs.Platform{OS: "linux", Architecture: "arm64"}
 )
 
 func TestMariner2(t *testing.T) {
@@ -41,6 +50,7 @@ func TestMariner2(t *testing.T) {
 			ID:        "mariner",
 			VersionID: "2.0",
 		},
+		SupportedPlatforms: platforms.Any(linuxAmd64, linuxArm64),
 	})
 }
 
@@ -70,6 +80,7 @@ func TestAzlinux3(t *testing.T) {
 			ID:        "azurelinux",
 			VersionID: "3.0",
 		},
+		SupportedPlatforms: platforms.Any(linuxAmd64, linuxArm64),
 	})
 }
 
@@ -124,8 +135,9 @@ type testLinuxConfig struct {
 		Units   string
 		Targets string
 	}
-	Worker  workerConfig
-	Release OSRelease
+	Worker             workerConfig
+	Release            OSRelease
+	SupportedPlatforms platforms.Matcher
 }
 
 type OSRelease struct {
@@ -603,6 +615,7 @@ WantedBy=multi-user.target
 						Dir: &dalec.SourceInlineDir{
 
 							Files: map[string]*dalec.SourceInlineFile{
+
 								"foo.service": {
 									Contents: `
 	# simple-socket.service
@@ -1144,6 +1157,11 @@ Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/boot
 		})
 	})
 
+	t.Run("platform", func(t *testing.T) {
+		ctx := startTestSpan(ctx, t)
+		testPlatforms(ctx, t, testConfig)
+	})
+
 	t.Run("custom worker", func(t *testing.T) {
 		t.Parallel()
 		ctx := startTestSpan(baseCtx, t)
@@ -1246,6 +1264,128 @@ func testCustomLinuxWorker(ctx context.Context, t *testing.T, targetCfg targetCo
 		// Unfortunately it seems like there is an issue with the gateway client passing
 		// in source policies.
 	})
+
+}
+
+func testPlatforms(ctx context.Context, t *testing.T, testConfig testLinuxConfig) {
+	t.Run("build against different platform", func(t *testing.T) {
+		t.Parallel()
+
+		ls, err := testEnv.Platforms(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(ls) <= 1 {
+			t.Skipf("builder does not support multiple platforms: %s", platformsAsStringer(ls))
+		}
+
+		testEnv.RunTest(ctx, t, func(ctx context.Context, client gwclient.Client) {
+			p := readDefaultPlatform(ctx, t, client)
+
+			matcher := platforms.OnlyStrict(p)
+			var testPlatform *ocispecs.Platform
+			for _, p2 := range ls {
+				// Get the first platform that is not the host platform that matches a supported distro platform
+				if !matcher.Match(p2) && testConfig.SupportedPlatforms.Match(p2) {
+					testPlatform = &p2
+					break
+				}
+			}
+
+			if testPlatform == nil {
+				msg := "could not find a platform suitable for testing, host platform: %s, available: %s"
+				ps := platformStringer(p)
+				workerPlatforms := platformsAsStringer(ls)
+				if os.Getenv("DALEC_CI") != "" {
+					t.Fatalf(msg, ps, workerPlatforms)
+				}
+				t.Skipf(msg, ps, workerPlatforms)
+			}
+
+			spec := &dalec.Spec{
+				Name:        "test-platforms",
+				Version:     "0.0.1",
+				Revision:    "1",
+				Description: "Testing building on platform different from host platform",
+				License:     "MIT",
+				Dependencies: &dalec.PackageDependencies{
+					Build: map[string]dalec.PackageConstraints{
+						"golang": {},
+					},
+				},
+				Sources: map[string]dalec.Source{
+					"src": {
+						Inline: &dalec.SourceInline{
+							Dir: &dalec.SourceInlineDir{
+								Files: map[string]*dalec.SourceInlineFile{
+									"go.mod": {
+										Contents: "module test\n\ngo 1.21.6",
+									},
+									"main.go": {
+										Contents: "package main\n\nfunc main() {}\n",
+									},
+								},
+							},
+						},
+					},
+				},
+				Build: dalec.ArtifactBuild{
+					Steps: []dalec.BuildStep{
+						{Command: "cd src; go build -o /tmp/test"},
+					},
+				},
+				Artifacts: dalec.Artifacts{
+					Binaries: map[string]dalec.ArtifactConfig{
+						"/tmp/test": {},
+					},
+				},
+			}
+
+			tp := *testPlatform
+			req := newSolveRequest(withPlatform(tp), withSpec(ctx, t, spec), withBuildTarget(testConfig.Target.Container))
+			res := solveT(ctx, t, client, req)
+
+			imgPlatforms := readResultPlatforms(t, res)
+			if len(imgPlatforms) != 1 {
+				t.Fatal("expected image output to contain 1 platform")
+			}
+
+			if !platforms.OnlyStrict(tp).Match(imgPlatforms[0]) {
+				t.Errorf("Expected image platform %q, got: %q", platformStringer(tp), platformStringer(imgPlatforms[0]))
+			}
+
+			ref, err := res.SingleRef()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if ref == nil {
+				t.Fatal("got empty reference -- most likely an empty (scratch) state was returned")
+			}
+
+			// Read the ELF header so we can determine what the target architecture is.
+			dt, err := ref.ReadFile(ctx, gwclient.ReadRequest{
+				Filename: "/usr/bin/test",
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			f, err := elf.NewFile(bytes.NewReader(dt))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			check := ocispecs.Platform{
+				OS: "linux",
+			}
+			elfToPlatform(f, &check)
+
+			if !platforms.OnlyStrict(*testPlatform).Match(check) {
+				t.Fatalf("output binary has unexpected platform, expected: %s, got: %s", platformStringer(*testPlatform), platformStringer(check))
+			}
+		})
+	})
+
 }
 
 func testPinnedBuildDeps(ctx context.Context, t *testing.T, targetCfg targetConfig, workerCfg workerConfig) {