replaces via substitutes-for template

Signed-off-by: grokspawn <jordan@nimblewidget.com>

Author: grokspawn

alpha/template/substitutes/substitutes.go

@@ -0,0 +1,55 @@
+package substitutes
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"k8s.io/apimachinery/pkg/util/yaml"
+
+	"github.com/operator-framework/operator-registry/alpha/declcfg"
+)
+
+type Template struct {
+	RenderBundle func(context.Context, string) (*declcfg.DeclarativeConfig, error)
+}
+
+type SubstitutesTemplate struct {
+	Schema      string          `json:"schema"`
+	Entries     []*declcfg.Meta `json:"entries"`
+	Substitutes []string        `json:"substitutes"`
+}
+
+const schema string = "olm.template.substitutes"
+
+func parseSpec(reader io.Reader) (*SubstitutesTemplate, error) {
+	st := &SubstitutesTemplate{}
+	stDoc := json.RawMessage{}
+	stDecoder := yaml.NewYAMLOrJSONDecoder(reader, 4096)
+	err := stDecoder.Decode(&stDoc)
+	if err != nil {
+		return nil, fmt.Errorf("decoding template schema: %v", err)
+	}
+	err = json.Unmarshal(stDoc, st)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshalling template: %v", err)
+	}
+
+	if st.Schema != schema {
+		return nil, fmt.Errorf("template has unknown schema (%q), should be %q", st.Schema, schema)
+	}
+
+	return st, nil
+}
+
+func (t Template) Render(ctx context.Context, reader io.Reader) (*declcfg.DeclarativeConfig, error) {
+	st, err := parseSpec(reader)
+	if err != nil {
+		return nil, fmt.Errorf("render: unable to parse template: %v", err)
+	}
+
+	// TODO: Implement the actual rendering logic using st.Entries and st.Substitutes
+	_ = st
+	return nil, nil
+}

cmd/opm/alpha/template/cmd.go

@@ -21,6 +21,10 @@ func NewCmd() *cobra.Command {
 	// sc.Hidden = true
 	runCmd.AddCommand(sc)
 
+	subs := newSubstitutesForTemplateCmd()
+	// subs.Hidden = true
+	runCmd.AddCommand(subs)
+
 	runCmd.PersistentFlags().StringVarP(&output, "output", "o", "json", "Output format (json|yaml)")
 
 	return runCmd

cmd/opm/alpha/template/substitutes.go

@@ -0,0 +1,113 @@
+package template
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+
+	"github.com/operator-framework/operator-registry/alpha/action"
+	"github.com/operator-framework/operator-registry/alpha/action/migrations"
+	"github.com/operator-framework/operator-registry/alpha/declcfg"
+	"github.com/operator-framework/operator-registry/alpha/template/substitutes"
+	"github.com/operator-framework/operator-registry/cmd/opm/internal/util"
+)
+
+func newSubstitutesForTemplateCmd() *cobra.Command {
+	var (
+		migrateLevel string
+	)
+
+	cmd := &cobra.Command{
+		Use: "substitutes [FILE]",
+		Short: `Generate a file-based catalog from a single 'substitutes template' file
+When FILE is '-' or not provided, the template is read from standard input`,
+		Long: `Generate a file-based catalog from a single 'substitutes template' file
+When FILE is '-' or not provided, the template is read from standard input`,
+		Args: cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// Handle different input argument types
+			// When no arguments or "-" is passed to the command,
+			// assume input is coming from stdin
+			// Otherwise open the file passed to the command
+			data, source, err := util.OpenFileOrStdin(cmd, args)
+			if err != nil {
+				return err
+			}
+			defer data.Close()
+
+			var write func(declcfg.DeclarativeConfig, io.Writer) error
+			output, err := cmd.Flags().GetString("output")
+			if err != nil {
+				log.Fatalf("unable to determine output format")
+			}
+			switch output {
+			case "json":
+				write = declcfg.WriteJSON
+			case "yaml":
+				write = declcfg.WriteYAML
+			case "mermaid":
+				write = func(cfg declcfg.DeclarativeConfig, writer io.Writer) error {
+					mermaidWriter := declcfg.NewMermaidWriter()
+					return mermaidWriter.WriteChannels(cfg, writer)
+				}
+			default:
+				return fmt.Errorf("invalid output format %q", output)
+			}
+
+			// The bundle loading impl is somewhat verbose, even on the happy path,
+			// so discard all logrus default logger logs. Any important failures will be
+			// returned from template.Render and logged as fatal errors.
+			logrus.SetOutput(io.Discard)
+
+			reg, err := util.CreateCLIRegistry(cmd)
+			if err != nil {
+				log.Fatalf("creating containerd registry: %v", err)
+			}
+			defer func() {
+				_ = reg.Destroy()
+			}()
+
+			var m *migrations.Migrations
+			if migrateLevel != "" {
+				m, err = migrations.NewMigrations(migrateLevel)
+				if err != nil {
+					log.Fatal(err)
+				}
+			}
+
+			template := substitutes.Template{
+				RenderBundle: func(ctx context.Context, ref string) (*declcfg.DeclarativeConfig, error) {
+					renderer := action.Render{
+						Refs:           []string{ref},
+						Registry:       reg,
+						AllowedRefMask: action.RefBundleImage,
+						Migrations:     m,
+					}
+					return renderer.Run(ctx)
+				},
+			}
+
+			out, err := template.Render(cmd.Context(), data)
+			if err != nil {
+				log.Fatalf("substitutes %q: %v", source, err)
+			}
+
+			if out != nil {
+				if err := write(*out, os.Stdout); err != nil {
+					log.Fatal(err)
+				}
+			}
+
+			return nil
+		},
+	}
+
+	cmd.Flags().StringVar(&migrateLevel, "migrate-level", "", "Name of the last migration to run (default: none)\n"+migrations.HelpText())
+
+	return cmd
+}