Add --all-platforms flag to push all architectures. Default is now pushing only amd64. Both flags --all-platforms and —platform are mutually exclusive to avoid any ambiguous commands.

Add a e2e test to validate.

Signed-off-by: Jean-Christophe Sirot <[email protected]>

Author: Jean-Christophe Sirot

Gopkg.lock

@@ -1,16 +1,22 @@
 package e2e
 
 import (
+	"encoding/json"
 	"fmt"
 	"math/rand"
 	"net"
+	"net/http"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/docker/app/internal"
+	"github.com/docker/cnab-to-oci/converter"
+	"github.com/docker/distribution/manifest/manifestlist"
+	"github.com/opencontainers/go-digest"
+	v1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"gotest.tools/assert"
 	"gotest.tools/assert/cmp"
 	"gotest.tools/fs"
@@ -87,6 +93,92 @@ func runWithDindSwarmAndRegistry(t *testing.T, todo func(dindSwarmAndRegistryInf
 
 }
 
+func TestPushArchs(t *testing.T) {
+	runWithDindSwarmAndRegistry(t, func(info dindSwarmAndRegistryInfo) {
+		testCases := []struct {
+			name              string
+			args              []string
+			expectedPlatforms []manifestlist.PlatformSpec
+		}{
+			{
+				name: "default",
+				args: []string{},
+				expectedPlatforms: []manifestlist.PlatformSpec{
+					{
+						OS:           "linux",
+						Architecture: "amd64",
+					},
+				},
+			},
+			{
+				name: "all-platforms",
+				args: []string{"--all-platforms"},
+				expectedPlatforms: []manifestlist.PlatformSpec{
+					{
+						OS:           "linux",
+						Architecture: "amd64",
+					},
+					{
+						OS:           "linux",
+						Architecture: "386",
+					},
+					{
+						OS:           "linux",
+						Architecture: "ppc64le",
+					},
+					{
+						OS:           "linux",
+						Architecture: "s390x",
+					},
+					{
+						OS:           "linux",
+						Architecture: "arm",
+						Variant:      "v5",
+					},
+					{
+						OS:           "linux",
+						Architecture: "arm",
+						Variant:      "v6",
+					},
+					{
+						OS:           "linux",
+						Architecture: "arm",
+						Variant:      "v7",
+					},
+					{
+						OS:           "linux",
+						Architecture: "arm64",
+						Variant:      "v8",
+					},
+				},
+			},
+		}
+
+		for _, testCase := range testCases {
+			t.Run(testCase.name, func(t *testing.T) {
+				cmd := info.configuredCmd
+				ref := info.registryAddress + "/test/push-pull:1"
+				args := []string{"app", "push", "--tag", ref, "--insecure-registries=" + info.registryAddress}
+				args = append(args, testCase.args...)
+				args = append(args, filepath.Join("testdata", "push-pull", "push-pull.dockerapp"))
+				cmd.Command = dockerCli.Command(args...)
+				icmd.RunCmd(cmd).Assert(t, icmd.Success)
+
+				var index v1.Index
+				httpGet(t, "http://"+info.registryAddress+"/v2/test/push-pull/manifests/1", &index)
+				digest, err := getManifestListDigest(index)
+				assert.NilError(t, err)
+				var manifestList manifestlist.ManifestList
+				httpGet(t, "http://"+info.registryAddress+"/v2/test/push-pull/manifests/"+digest.String(), &manifestList)
+				assert.Equal(t, len(manifestList.Manifests), len(testCase.expectedPlatforms), "Unexpected number of platforms")
+				for _, m := range manifestList.Manifests {
+					assert.Assert(t, cmp.Contains(testCase.expectedPlatforms, m.Platform), "Platform expected but not found: %s", m.Platform)
+				}
+			})
+		}
+	})
+}
+
 func TestPushInstall(t *testing.T) {
 	runWithDindSwarmAndRegistry(t, func(info dindSwarmAndRegistryInfo) {
 		cmd := info.configuredCmd
@@ -198,3 +290,21 @@ func isPortAvailable(port int) bool {
 	defer l.Close()
 	return true
 }
+
+func httpGet(t *testing.T, url string, obj interface{}) {
+	r, err := http.Get(url)
+	assert.NilError(t, err)
+	defer r.Body.Close()
+	assert.Equal(t, r.StatusCode, 200)
+	err = json.NewDecoder(r.Body).Decode(obj)
+	assert.NilError(t, err)
+}
+
+func getManifestListDigest(index v1.Index) (digest.Digest, error) {
+	for _, m := range index.Manifests {
+		if m.Annotations[converter.CNABDescriptorTypeAnnotation] == "component" {
+			return m.Digest, nil
+		}
+	}
+	return "", fmt.Errorf("Service image not found")
+}

e2e/pushpull_test.go

@@ -24,6 +24,7 @@ import (
 	ocischemav1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 const ( // Docker specific annotations and values
@@ -39,9 +40,10 @@ const ( // Docker specific annotations and values
 )
 
 type pushOptions struct {
-	registry  registryOptions
-	tag       string
-	platforms []string
+	registry     registryOptions
+	tag          string
+	platforms    []string
+	allPlatforms bool
 }
 
 func pushCmd(dockerCli command.Cli) *cobra.Command {
@@ -51,13 +53,17 @@ func pushCmd(dockerCli command.Cli) *cobra.Command {
 		Short:   "Push an application package to a registry",
 		Example: `$ docker app push myapp --tag myrepo/myapp:mytag`,
 		Args:    cli.RequiresMaxArgs(1),
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return checkFlags(cmd.Flags(), opts)
+		},
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return runPush(dockerCli, firstOrEmpty(args), opts)
 		},
 	}
 	flags := cmd.Flags()
 	flags.StringVarP(&opts.tag, "tag", "t", "", "Target registry reference (default: <name>:<version> from metadata)")
-	flags.StringSliceVar(&opts.platforms, "platform", nil, "For multi-arch service images, only push the specified platforms")
+	flags.StringSliceVar(&opts.platforms, "platform", []string{"linux/amd64"}, "For multi-arch service images, push the specified platforms")
+	flags.BoolVar(&opts.allPlatforms, "all-platforms", false, "If present, push all platforms")
 	opts.registry.addFlags(flags)
 	return cmd
 }
@@ -117,8 +123,8 @@ func runPush(dockerCli command.Cli, name string, opts pushOptions) error {
 	fixupOptions := []remotes.FixupOption{
 		remotes.WithEventCallback(display.onEvent),
 	}
-	if len(opts.platforms) > 0 {
-		fixupOptions = append(fixupOptions, remotes.WithComponentImagePlatforms(opts.platforms))
+	if platforms := platformFilter(opts); len(platforms) > 0 {
+		fixupOptions = append(fixupOptions, remotes.WithComponentImagePlatforms(platforms))
 	}
 	// bundle fixup
 	err = remotes.FixupBundle(context.Background(), bndl, retag.cnabRef, resolverConfig, fixupOptions...)
@@ -144,6 +150,13 @@ func withAppAnnotations(index *ocischemav1.Index) error {
 	return nil
 }
 
+func platformFilter(opts pushOptions) []string {
+	if opts.allPlatforms {
+		return nil
+	}
+	return opts.platforms
+}
+
 func retagInvocationImage(dockerCli command.Cli, bndl *bundle.Bundle, newName string) error {
 	err := dockerCli.Client().ImageTag(context.Background(), bndl.InvocationImages[0].Image, newName)
 	if err != nil {
@@ -319,3 +332,10 @@ func (r *plainDisplay) onEvent(ev remotes.FixupEvent) {
 		}
 	}
 }
+
+func checkFlags(flags *pflag.FlagSet, opts pushOptions) error {
+	if opts.allPlatforms && flags.Changed("all-platforms") && flags.Changed("platform") {
+		return fmt.Errorf("--all-plaforms and --plaform flags cannot be used at the same time")
+	}
+	return nil
+}

internal/commands/push.go

@@ -102,3 +102,33 @@ func TestInvocationImageRetag(t *testing.T) {
 		})
 	}
 }
+
+func TestPlatformFilter(t *testing.T) {
+	cases := []struct {
+		name     string
+		opts     pushOptions
+		expected []string
+	}{
+		{
+			name: "filtered-platforms",
+			opts: pushOptions{
+				allPlatforms: false,
+				platforms:    []string{"linux/amd64", "linux/arm64"},
+			},
+			expected: []string{"linux/amd64", "linux/arm64"},
+		},
+		{
+			name: "all-platforms",
+			opts: pushOptions{
+				allPlatforms: true,
+				platforms:    []string{"linux/amd64"},
+			},
+			expected: nil,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.DeepEqual(t, platformFilter(c.opts), c.expected)
+		})
+	}
+}