Add opm alpha init/render commands.

The `init` command is a simple CLI used to generate new `olm.package`
blobs. It has flags for default channel, icon file, and description file
to enable every field to be populated via the CLI.

The `render` command converts various opm-related images to a declarative
config format. It:
- converts bundle images to `olm.bundle` blobs
- converts databases in sqlite-based index images to declarative config
  blobs.
- loads and serializes config directories from declarative-config-based
  index images, inlining any bundle objects that are found.

Combined, these two commands form the foundation for building new
DC-based indexes.

Signed-off-by: Joe Lanford <[email protected]>

Upstream-repository: operator-registry
Upstream-commit: fd099516ef679bd14d53212f40b4dae8f61ca8b7

Author: joelanford

staging/operator-registry/cmd/opm/alpha/cmd.go

@@ -1,11 +1,14 @@
 package alpha
 
 import (
+	"github.com/spf13/cobra"
+
 	"github.com/operator-framework/operator-registry/cmd/opm/alpha/add"
 	"github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle"
+	initcmd "github.com/operator-framework/operator-registry/cmd/opm/alpha/init"
+	"github.com/operator-framework/operator-registry/cmd/opm/alpha/render"
 	"github.com/operator-framework/operator-registry/cmd/opm/alpha/serve"
 	"github.com/operator-framework/operator-registry/cmd/opm/alpha/validate"
-	"github.com/spf13/cobra"
 )
 
 func NewCmd() *cobra.Command {
@@ -15,6 +18,6 @@ func NewCmd() *cobra.Command {
 		Short:  "Run an alpha subcommand",
 	}
 
-	runCmd.AddCommand(bundle.NewCmd(), add.NewCmd(), serve.NewCmd(), validate.NewCmd())
+	runCmd.AddCommand(bundle.NewCmd(), add.NewCmd(), initcmd.NewCmd(), serve.NewCmd(), render.NewCmd(), validate.NewCmd())
 	return runCmd
 }

staging/operator-registry/cmd/opm/alpha/init/cmd.go

@@ -0,0 +1,77 @@
+package init
+
+import (
+	"io"
+	"os"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+
+	"github.com/operator-framework/operator-registry/internal/action"
+	"github.com/operator-framework/operator-registry/internal/declcfg"
+)
+
+func NewCmd() *cobra.Command {
+	var (
+		init            action.Init
+		iconFile        string
+		descriptionFile string
+		output          string
+	)
+	cmd := &cobra.Command{
+		Use:   "init <packageName>",
+		Short: "Generate an olm.package declarative config blob",
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			init.Package = args[0]
+
+			var write func(declcfg.DeclarativeConfig, io.Writer) error
+			switch output {
+			case "yaml":
+				write = declcfg.WriteYAML
+			case "json":
+				write = declcfg.WriteJSON
+			default:
+				log.Fatalf("invalid --output value %q, expected (json|yaml)", output)
+			}
+
+			if iconFile != "" {
+				iconReader, err := os.Open(iconFile)
+				if err != nil {
+					log.Fatalf("open icon file: %v", err)
+				}
+				defer closeReader(iconReader)
+				init.IconReader = iconReader
+			}
+
+			if descriptionFile != "" {
+				descriptionReader, err := os.Open(descriptionFile)
+				if err != nil {
+					log.Fatalf("open description file: %v", err)
+				}
+				defer closeReader(descriptionReader)
+				init.DescriptionReader = descriptionReader
+			}
+
+			pkg, err := init.Run()
+			if err != nil {
+				log.Fatal(err)
+			}
+			cfg := declcfg.DeclarativeConfig{Packages: []declcfg.Package{*pkg}}
+			if err := write(cfg, os.Stdout); err != nil {
+				log.Fatal(err)
+			}
+		},
+	}
+	cmd.Flags().StringVarP(&init.DefaultChannel, "default-channel", "c", "", "The channel that subscriptions will default to if unspecified")
+	cmd.Flags().StringVarP(&iconFile, "icon", "i", "", "Path to package's icon")
+	cmd.Flags().StringVarP(&descriptionFile, "description", "d", "", "Path to the operator's README.md (or other documentation)")
+	cmd.Flags().StringVarP(&output, "output", "o", "json", "Output format (json|yaml)")
+	return cmd
+}
+
+func closeReader(closer io.ReadCloser) {
+	if err := closer.Close(); err != nil {
+		log.Warn(err)
+	}
+}

staging/operator-registry/cmd/opm/alpha/render/cmd.go

@@ -0,0 +1,53 @@
+package render
+
+import (
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+
+	"github.com/operator-framework/operator-registry/internal/action"
+	"github.com/operator-framework/operator-registry/internal/declcfg"
+)
+
+func NewCmd() *cobra.Command {
+	var (
+		render action.Render
+		output string
+	)
+	cmd := &cobra.Command{
+		Use:   "render <index-or-bundle-image1> <index-or-bundle-image2> <index-or-bundle-imageN>",
+		Short: "Generate declarative config blobs from the provided index and bundle images",
+		Args:  cobra.MinimumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			render.Refs = args
+
+			var write func(declcfg.DeclarativeConfig, io.Writer) error
+			switch output {
+			case "yaml":
+				write = declcfg.WriteYAML
+			case "json":
+				write = declcfg.WriteJSON
+			default:
+				log.Fatalf("invalid --output value %q, expected (json|yaml)", output)
+			}
+
+			// TODO(joelanford): What's this for?
+			logrus.SetOutput(ioutil.Discard)
+
+			cfg, err := render.Run(cmd.Context())
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			if err := write(*cfg, os.Stdout); err != nil {
+				log.Fatal(err)
+			}
+		},
+	}
+	cmd.Flags().StringVarP(&output, "output", "o", "json", "Output format (json|yaml)")
+	return cmd
+}

staging/operator-registry/internal/action/init.go

@@ -0,0 +1,52 @@
+package action
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+
+	"github.com/h2non/filetype"
+
+	"github.com/operator-framework/operator-registry/internal/declcfg"
+)
+
+type Init struct {
+	Package           string
+	DefaultChannel    string
+	DescriptionReader io.Reader
+	IconReader        io.Reader
+}
+
+func (i Init) Run() (*declcfg.Package, error) {
+	pkg := &declcfg.Package{
+		Schema:         "olm.package",
+		Name:           i.Package,
+		DefaultChannel: i.DefaultChannel,
+	}
+	if i.DescriptionReader != nil {
+		descriptionData, err := ioutil.ReadAll(i.DescriptionReader)
+		if err != nil {
+			return nil, fmt.Errorf("read description: %v", err)
+		}
+		pkg.Description = string(descriptionData)
+	}
+
+	if i.IconReader != nil {
+		iconData, err := ioutil.ReadAll(i.IconReader)
+		if err != nil {
+			return nil, fmt.Errorf("read icon: %v", err)
+		}
+		iconType, err := filetype.Match(iconData)
+		if err != nil {
+			return nil, fmt.Errorf("detect icon mediatype: %v", err)
+		}
+		if iconType.MIME.Type != "image" {
+			return nil, fmt.Errorf("detected invalid type %q: not an image", iconType.MIME.Value)
+		}
+		pkg.Icon = &declcfg.Icon{
+			Data:      iconData,
+			MediaType: iconType.MIME.Value,
+		}
+	}
+	return pkg, nil
+}

staging/operator-registry/internal/action/init_test.go

@@ -0,0 +1,139 @@
+package action_test
+
+import (
+	"bytes"
+	"errors"
+	"testing"
+	"testing/iotest"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/operator-framework/operator-registry/internal/action"
+	"github.com/operator-framework/operator-registry/internal/declcfg"
+)
+
+const (
+	svgIcon = `<svg viewBox="0 0 100 100"><circle cx="25" cy="25" r="25"/></svg>`
+)
+
+func TestInit(t *testing.T) {
+	type spec struct {
+		name      string
+		init      action.Init
+		expectPkg *declcfg.Package
+		assertion require.ErrorAssertionFunc
+	}
+
+	specs := []spec{
+		{
+			name: "Success/Empty",
+			init: action.Init{},
+			expectPkg: &declcfg.Package{
+				Schema: "olm.package",
+			},
+			assertion: require.NoError,
+		},
+		{
+			name: "Success/SetPackage",
+			init: action.Init{
+				Package: "foo",
+			},
+			expectPkg: &declcfg.Package{
+				Schema: "olm.package",
+				Name:   "foo",
+			},
+			assertion: require.NoError,
+		},
+		{
+			name: "Success/SetDefaultChannel",
+			init: action.Init{
+				DefaultChannel: "foo",
+			},
+			expectPkg: &declcfg.Package{
+				Schema:         "olm.package",
+				DefaultChannel: "foo",
+			},
+			assertion: require.NoError,
+		},
+		{
+			name: "Success/SetDescription",
+			init: action.Init{
+				DescriptionReader: bytes.NewBufferString("foo"),
+			},
+			expectPkg: &declcfg.Package{
+				Schema:      "olm.package",
+				Description: "foo",
+			},
+			assertion: require.NoError,
+		},
+		{
+			name: "Success/SetIcon",
+			init: action.Init{
+				IconReader: bytes.NewBufferString(svgIcon),
+			},
+			expectPkg: &declcfg.Package{
+				Schema: "olm.package",
+				Icon: &declcfg.Icon{
+					Data:      bytes.NewBufferString(svgIcon).Bytes(),
+					MediaType: "image/svg+xml",
+				},
+			},
+			assertion: require.NoError,
+		},
+		{
+			name: "Success/SetAll",
+			init: action.Init{
+				Package:           "a",
+				DefaultChannel:    "b",
+				DescriptionReader: bytes.NewBufferString("c"),
+				IconReader:        bytes.NewBufferString(svgIcon),
+			},
+			expectPkg: &declcfg.Package{
+				Schema:         "olm.package",
+				Name:           "a",
+				DefaultChannel: "b",
+				Description:    "c",
+				Icon: &declcfg.Icon{
+					Data:      bytes.NewBufferString(svgIcon).Bytes(),
+					MediaType: "image/svg+xml",
+				},
+			},
+			assertion: require.NoError,
+		},
+		{
+			name: "Fail/ReadDescription",
+			init: action.Init{
+				DescriptionReader: iotest.ErrReader(errors.New("fail")),
+			},
+			assertion: require.Error,
+		},
+		{
+			name: "Fail/ReadIcon",
+			init: action.Init{
+				IconReader: iotest.ErrReader(errors.New("fail")),
+			},
+			assertion: require.Error,
+		},
+		{
+			name: "Fail/IconNotImage",
+			init: action.Init{
+				IconReader: bytes.NewBufferString("foo"),
+			},
+			assertion: require.Error,
+		},
+		{
+			name: "Fail/EmptyIcon",
+			init: action.Init{
+				IconReader: bytes.NewBuffer(nil),
+			},
+			assertion: require.Error,
+		},
+	}
+	for _, s := range specs {
+		t.Run(s.name, func(t *testing.T) {
+			actualPkg, actualErr := s.init.Run()
+			s.assertion(t, actualErr)
+			require.Equal(t, s.expectPkg, actualPkg)
+		})
+	}
+}