Add a new manifest command to support multi-architecture builds

cmd/cmd.go

@@ -104,6 +104,7 @@ func NewPackCommand(logger ConfigurableLogger) (*cobra.Command, error) {
 		rootCmd.AddCommand(commands.SetDefaultRegistry(logger, cfg, cfgPath))
 		rootCmd.AddCommand(commands.RemoveRegistry(logger, cfg, cfgPath))
 		rootCmd.AddCommand(commands.YankBuildpack(logger, cfg, packClient))
+		rootCmd.AddCommand(commands.NewManifestCommand(logger, packClient))
 	}
 
 	packHome, err := config.PackHome()

internal/commands/commands.go

@@ -32,6 +32,14 @@ type PackClient interface {
 	InspectExtension(client.InspectExtensionOptions) (*client.ExtensionInfo, error)
 	PullBuildpack(context.Context, client.PullBuildpackOptions) error
 	DownloadSBOM(name string, options client.DownloadSBOMOptions) error
+	CreateManifest(ctx context.Context, name string, images []string, opts client.CreateManifestOptions) (imageID string, err error)
+	AnnotateManifest(ctx context.Context, name string, image string, opts client.ManifestAnnotateOptions) error
+	ExistsManifest(ctx context.Context, image string) error
+	AddManifest(ctx context.Context, index string, images string, opts client.ManifestAddOptions) (imageID string, err error)
+	DeleteManifest(ctx context.Context, name []string) error
+	RemoveManifest(ctx context.Context, name string, images []string) error
+	PushManifest(ctx context.Context, index string, opts client.PushManifestOptions) (imageID string, err error)
+	InspectManifest(ctx context.Context, name string, opts client.InspectManifestOptions) error
 }
 
 func AddHelpFlag(cmd *cobra.Command, commandName string) {

internal/commands/manifest.go

@@ -0,0 +1,26 @@
+package commands
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/buildpacks/pack/pkg/logging"
+)
+
+func NewManifestCommand(logger logging.Logger, client PackClient) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "manifest",
+		Short: "Interact with image index or manifest list",
+		RunE:  nil,
+	}
+
+	cmd.AddCommand(ManifestCreate(logger, client))
+	cmd.AddCommand(ManifestAdd(logger, client))
+	cmd.AddCommand(ManifestAnnotate(logger, client))
+	cmd.AddCommand(ManifestDelete(logger, client))
+	cmd.AddCommand(ManifestInspect(logger, client))
+	cmd.AddCommand(ManifestPush(logger, client))
+	cmd.AddCommand(ManifestRemove(logger, client))
+
+	AddHelpFlag(cmd, "manifest")
+	return cmd
+}

internal/commands/manifest_add.go

@@ -0,0 +1,98 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/buildpacks/pack/pkg/client"
+	"github.com/buildpacks/pack/pkg/logging"
+)
+
+// ManifestAddFlags define flags provided to the ManifestAdd
+type ManifestAddFlags struct {
+	OS, OSVersion, OSArch, OSVariant  string
+	OSFeatures, Annotations, Features string
+	all bool
+}
+
+// ManifestAdd modifies a manifest list (Image index) and add a new image to the list of manifests.
+func ManifestAdd(logger logging.Logger, pack PackClient) *cobra.Command {
+	var flags ManifestAddFlags
+
+	cmd := &cobra.Command{
+		Use:   "pack manifest add [OPTIONS] <manifest-list> <manifest> [flags]",
+		Args:  cobra.MatchAll(cobra.ExactArgs(2), cobra.OnlyValidArgs),
+		Short: "manifest add modifies a manifest list (Image index) and add a new image to the list of manifests.",
+		Example: `pack manifest add cnbs/sample-package:hello-multiarch-universe \
+		cnbs/sample-package:hello-universe-riscv-linux`,
+		Long: `manifest add modifies a manifest list (Image index) and add a new image to the list of manifests.
+
+		When a manifest list exits locally, user can add a new image to the manifest list using this command`,
+		RunE: logError(logger, func(cmd *cobra.Command, args []string) error {
+			imageIndex := args[0]
+			manifests := args[1]
+			if err := validateManifestAddFlags(flags); err != nil {
+				return err
+			}
+
+			osFeatures:= strings.Split(flags.OSFeatures, ";")
+			features:= strings.Split(flags.Features, ";")
+			annotations, err := stringToKeyValueMap(flags.Annotations)
+			if err != nil {
+				return err
+			}
+
+			imageID, err := pack.AddManifest(cmd.Context(), imageIndex, manifests, client.ManifestAddOptions{
+				OS: flags.OS,
+				OSVersion: flags.OSVersion,
+				OSArch: flags.OSArch,
+				OSVariant: flags.OSVariant,
+				OSFeatures: osFeatures,
+				Features: features,
+				Annotations: annotations,
+				All: flags.all,
+			})
+
+			if err != nil {
+				return err
+			}
+
+			logger.Infof(imageID)
+			return nil
+		}),
+	}
+
+	cmd.Flags().BoolVar(&flags.all, "all", false, "add all of the contents to the local list (applies only if <manifest> is an index)")
+	cmd.Flags().StringVar(&flags.os, "os", "", "Set the operating system")
+	cmd.Flags().StringVar(&flags.arch, "arch", "", "Set the architecture")
+	cmd.Flags().StringVar(&flags.variant, "variant", "", "Set the architecture variant")
+
+	AddHelpFlag(cmd, "add")
+	return cmd
+}
+
+func validateManifestAddFlags(flags ManifestAddFlags) error {
+	return nil
+}
+
+func stringToKeyValueMap(s string) (map[string]string, error) {
+	keyValues := strings.Split(s, ";")
+
+	m := map[string]string{}
+
+	for _, keyValue := range keyValues {
+	  parts := strings.Split(keyValue, "=")
+	  if len(parts) != 2 {
+		return nil, fmt.Errorf("invalid key-value pair: %s", keyValue)
+	  }
+
+	  key := parts[0]
+	  value := parts[1]
+
+	  m[key] = value
+	}
+
+	return m, nil
+  }

internal/commands/manifest_add_test.go

@@ -0,0 +1,104 @@
+package commands_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/heroku/color"
+	"github.com/sclevine/spec"
+	"github.com/sclevine/spec/report"
+	"github.com/spf13/cobra"
+
+	"github.com/buildpacks/pack/internal/commands"
+	"github.com/buildpacks/pack/internal/commands/testmocks"
+	"github.com/buildpacks/pack/pkg/logging"
+)
+
+func TestManifestAddCommand(t *testing.T) {
+	color.Disable(true)
+	defer color.Disable(false)
+
+	spec.Run(t, "Commands", testManifestAddCommand, spec.Random(), spec.Report(report.Terminal{}))
+}
+
+func testManifestAddCommand(t *testing.T, when spec.G, it spec.S) {
+	var (
+		command        *cobra.Command
+		logger         *logging.LogWithWriters
+		outBuf         bytes.Buffer
+		mockController *gomock.Controller
+		mockClient     *testmocks.MockPackClient
+	)
+
+	it.Before(func() {
+		logger = logging.NewLogWithWriters(&outBuf, &outBuf)
+		mockController = gomock.NewController(t)
+		mockClient = testmocks.NewMockPackClient(mockController)
+
+		command = commands.ManifestAdd(logger, mockClient)
+	})
+
+	when("#ManifestAdd", func() {
+		when("no flags specified", func() {
+
+		})
+		when("when --all flags passed", func() {
+
+		})
+		when("when --os flags passed", func() {
+
+		})
+		when("when --arch flags passed", func() {
+
+		})
+		when("when --variant flags passed", func() {
+
+		})
+		when("when --os-version flags passed", func() {
+
+		})
+		when("when --features flags passed", func() {
+
+		})
+		when("when --os-features flags passed", func() {
+
+		})
+		when("when --annotations flags passed", func() {
+
+		})
+		when("when multiple flags passed", func() {
+
+		})
+		when("when no args passed", func() {
+
+		})
+		when("when manifest list reference is incorrect", func() {
+
+		})
+		when("when manifest reference is incorrect", func() {
+
+		})
+		when("when manifest passed in-place of manifest list on first arg", func() {
+
+		})
+		when("when manifest list is passed on second arg", func() {
+
+		})
+		when("when manifest is passed on second arg with --all option", func() {
+
+		})
+		when("when manifest list in locally available", func() {
+
+		})
+		when("when manifest is not locally available", func() {
+
+		})
+		when("when manifest is locally available passed", func() {
+
+		})
+		when("when multiple manifests passed", func() {
+
+		})
+	})
+}

internal/commands/manifest_annotate.go

@@ -0,0 +1,42 @@
+package commands
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/buildpacks/pack/pkg/logging"
+)
+
+// ManifestAnnotateFlags define flags provided to the ManifestAnnotate
+type ManifestAnnotateFlags struct {
+	os, arch, variant, osVersion      string
+	features, osFeatures, annotations []string
+}
+
+// ManifestAnnotate modifies a manifest list (Image index) and update the platform information for an image included in the manifest list.
+func ManifestAnnotate(logger logging.Logger, pack PackClient) *cobra.Command {
+	var flags ManifestAnnotateFlags
+
+	cmd := &cobra.Command{
+		Use:   "pack manifest annotate [OPTIONS] <manifest-list> <manifest> [<manifest>...] [flags]",
+		Args:  cobra.MatchAll(cobra.ExactArgs(2), cobra.OnlyValidArgs),
+		Short: "manifest annotate modifies a manifest list (Image index) and update the platform information for an image included in the manifest list.",
+		Example: `pack manifest annotate cnbs/sample-package:hello-universe-multiarch \ 
+		cnbs/sample-package:hello-universe --arch amd64`,
+		Long: `manifest annotate modifies a manifest list (Image index) and update the platform information for an image included in the manifest list.
+		Sometimes a manifest list could reference an image that doesn't specify the architecture, The "annotate" command allows users to update those values before pushing the manifest list a registry`,
+		RunE: logError(logger, func(cmd *cobra.Command, args []string) error {
+			return nil
+		}),
+	}
+
+	cmd.Flags().StringVar(&flags.os, "os", "", "Set the architecture")
+	cmd.Flags().StringVar(&flags.arch, "arch", "", "Set the architecture")
+	cmd.Flags().StringVar(&flags.variant, "variant", "", "Set the architecture")
+	cmd.Flags().StringVar(&flags.osVersion, "os-version", "", "override the os `version` of the specified image")
+	cmd.Flags().StringSliceVar(&flags.features, "features", nil, "override the `features` of the specified image")
+	cmd.Flags().StringSliceVar(&flags.osFeatures, "os-features", nil, "override the os `features` of the specified image")
+	cmd.Flags().StringSliceVar(&flags.annotations, "annotations", nil, "set an `annotation` for the specified image")
+
+	AddHelpFlag(cmd, "annotate")
+	return cmd
+}

internal/commands/manifest_annotate_test.go

@@ -0,0 +1,101 @@
+package commands_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/heroku/color"
+	"github.com/sclevine/spec"
+	"github.com/sclevine/spec/report"
+	"github.com/spf13/cobra"
+
+	"github.com/buildpacks/pack/internal/commands"
+	"github.com/buildpacks/pack/internal/commands/testmocks"
+	"github.com/buildpacks/pack/pkg/logging"
+)
+
+func TestManifestAnnotateCommand(t *testing.T) {
+	color.Disable(true)
+	defer color.Disable(false)
+
+	spec.Run(t, "Commands", testManifestAnnotateCommand, spec.Random(), spec.Report(report.Terminal{}))
+}
+
+func testManifestAnnotateCommand(t *testing.T, when spec.G, it spec.S) {
+	var (
+		command        *cobra.Command
+		logger         *logging.LogWithWriters
+		outBuf         bytes.Buffer
+		mockController *gomock.Controller
+		mockClient     *testmocks.MockPackClient
+	)
+
+	it.Before(func() {
+		logger = logging.NewLogWithWriters(&outBuf, &outBuf)
+		mockController = gomock.NewController(t)
+		mockClient = testmocks.NewMockPackClient(mockController)
+
+		command = commands.ManifestAnnotate(logger, mockClient)
+	})
+
+	when("#ManifestAnnotate", func() {
+		when("no flags specified", func() {
+
+		})
+		when("when --os flags passed", func() {
+
+		})
+		when("when --arch flags passed", func() {
+
+		})
+		when("when --variant flags passed", func() {
+
+		})
+		when("when --os-version flags passed", func() {
+
+		})
+		when("when --features flags passed", func() {
+
+		})
+		when("when --os-features flags passed", func() {
+
+		})
+		when("when --annotations flags passed", func() {
+
+		})
+		when("when multiple flags passed", func() {
+
+		})
+		when("when no args passed", func() {
+
+		})
+		when("when manifest list reference is incorrect", func() {
+
+		})
+		when("when manifest reference is incorrect", func() {
+
+		})
+		when("when manifest passed in-place of manifest list on first arg", func() {
+
+		})
+		when("when manifest list is passed on second arg", func() {
+
+		})
+		when("when manifest is passed on second arg with --all option", func() {
+
+		})
+		when("when manifest list in locally available", func() {
+
+		})
+		when("when manifest is not locally available", func() {
+
+		})
+		when("when manifest is locally available passed", func() {
+
+		})
+		when("when multiple manifests passed", func() {
+
+		})
+	})
+}