Adding deprecated property type to bundles

Adding support marking bundles as deprecated and truncating the update
graph of a given package. Deprecated versions will not be installable.
Deprecating a bundle can result in the removal of channels but this is
not permitted for the default channel. Bundles that are not in the
index will be ignored during deprecation.

Author: gallettilance

bundles/etcd.0.9.0/metadata/annotations.yaml

@@ -1,4 +1,5 @@
 annotations:
   operators.operatorframework.io.bundle.package.v1: "etcd"
-  operators.operatorframework.io.bundle.channels.v1: "alpha,stable"
-  operators.operatorframework.io.bundle.channel.default.v1: "stable"
+  operators.operatorframework.io.bundle.channels.v1: "alpha,stable,beta"
+  operators.operatorframework.io.bundle.channel.default.v1: "stable"
+  

cmd/opm/index/cmd.go

@@ -25,4 +25,5 @@ func AddCommand(parent *cobra.Command) {
 	addIndexAddCmd(cmd)
 	cmd.AddCommand(newIndexExportCmd())
 	cmd.AddCommand(newIndexPruneCmd())
+	cmd.AddCommand(newIndexDeprecateTruncateCmd())
 }

cmd/opm/index/deprecate.go

@@ -0,0 +1,133 @@
+package index
+
+import (
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+	"k8s.io/kubectl/pkg/util/templates"
+
+	"github.com/operator-framework/operator-registry/pkg/containertools"
+	"github.com/operator-framework/operator-registry/pkg/lib/indexer"
+)
+
+var deprecateLong = templates.LongDesc(`
+	Deprecate and truncate operator bundles from an index.
+	
+	Deprecated bundles will no longer be installable. Bundles that are replaced by deprecated bundles will be removed enirely from the index.
+	
+	For example:
+
+		Given the update graph in quay.io/my/index:v1
+		1.4.0 -- replaces -> 1.3.0 -- replaces -> 1.2.0 -- replaces -> 1.1.0
+
+		Applying the command:
+		opm index deprecate --bundles "quay.io/my/bundle:1.3.0" --from-index "quay.io/my/index:v1" --tag "quay.io/my/index:v2"
+
+		Produces the following update graph in quay.io/my/index:v2
+		1.4.0 -- replaces -> 1.3.0 [deprecated]
+		
+	Deprecating a bundle that removes the default channel is not allowed. Changing the default channel prior to deprecation is possible by publishing a new bundle to the index.
+	`)
+
+func newIndexDeprecateTruncateCmd() *cobra.Command {
+	indexCmd := &cobra.Command{
+		Hidden: true,
+		Use:    "deprecatetruncate",
+		Short:  "Deprecate and truncate operator bundles from an index.",
+		Long:   deprecateLong,
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			if debug, _ := cmd.Flags().GetBool("debug"); debug {
+				logrus.SetLevel(logrus.DebugLevel)
+			}
+			return nil
+		},
+		RunE: runIndexDeprecateTruncateCmdFunc,
+	}
+
+	indexCmd.Flags().Bool("debug", false, "enable debug logging")
+	indexCmd.Flags().Bool("generate", false, "if enabled, just creates the dockerfile and saves it to local disk")
+	indexCmd.Flags().StringP("out-dockerfile", "d", "", "if generating the dockerfile, this flag is used to (optionally) specify a dockerfile name")
+	indexCmd.Flags().StringP("from-index", "f", "", "previous index to add to")
+	indexCmd.Flags().StringSliceP("bundles", "b", nil, "comma separated list of bundles to add")
+	if err := indexCmd.MarkFlagRequired("bundles"); err != nil {
+		logrus.Panic("Failed to set required `bundles` flag for `index add`")
+	}
+	indexCmd.Flags().StringP("binary-image", "i", "", "container image for on-image `opm` command")
+	indexCmd.Flags().StringP("container-tool", "c", "", "tool to interact with container images (save, build, etc.). One of: [docker, podman]")
+	indexCmd.Flags().StringP("build-tool", "u", "", "tool to build container images. One of: [docker, podman]. Defaults to podman. Overrides part of container-tool.")
+	indexCmd.Flags().StringP("pull-tool", "p", "", "tool to pull container images. One of: [none, docker, podman]. Defaults to none. Overrides part of container-tool.")
+	indexCmd.Flags().StringP("tag", "t", "", "custom tag for container image being built")
+	indexCmd.Flags().Bool("permissive", false, "allow registry load errors")
+	if err := indexCmd.Flags().MarkHidden("debug"); err != nil {
+		logrus.Panic(err.Error())
+	}
+
+	return indexCmd
+}
+
+func runIndexDeprecateTruncateCmdFunc(cmd *cobra.Command, args []string) error {
+	generate, err := cmd.Flags().GetBool("generate")
+	if err != nil {
+		return err
+	}
+
+	outDockerfile, err := cmd.Flags().GetString("out-dockerfile")
+	if err != nil {
+		return err
+	}
+
+	fromIndex, err := cmd.Flags().GetString("from-index")
+	if err != nil {
+		return err
+	}
+
+	bundles, err := cmd.Flags().GetStringSlice("bundles")
+	if err != nil {
+		return err
+	}
+
+	binaryImage, err := cmd.Flags().GetString("binary-image")
+	if err != nil {
+		return err
+	}
+
+	tag, err := cmd.Flags().GetString("tag")
+	if err != nil {
+		return err
+	}
+
+	permissive, err := cmd.Flags().GetBool("permissive")
+	if err != nil {
+		return err
+	}
+
+	pullTool, buildTool, err := getContainerTools(cmd)
+	if err != nil {
+		return err
+	}
+
+	logger := logrus.WithFields(logrus.Fields{"bundles": bundles})
+
+	logger.Info("deprecating bundles from the index")
+
+	indexDeprecator := indexer.NewIndexDeprecator(
+		containertools.NewContainerTool(buildTool, containertools.PodmanTool),
+		containertools.NewContainerTool(pullTool, containertools.NoneTool),
+		logger)
+
+	request := indexer.DeprecateFromIndexRequest{
+		Generate:          generate,
+		FromIndex:         fromIndex,
+		BinarySourceImage: binaryImage,
+		OutDockerfile:     outDockerfile,
+		Tag:               tag,
+		Bundles:           bundles,
+		Permissive:        permissive,
+	}
+
+	err = indexDeprecator.DeprecateFromIndex(request)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/lib/indexer/indexer.go

@@ -41,6 +41,7 @@ type ImageIndexer struct {
 	RegistryAdder       registry.RegistryAdder
 	RegistryDeleter     registry.RegistryDeleter
 	RegistryPruner      registry.RegistryPruner
+	RegistryDeprecator  registry.RegistryDeprecator
 	BuildTool           containertools.ContainerTool
 	PullTool            containertools.ContainerTool
 	Logger              *logrus.Entry
@@ -527,3 +528,61 @@ func generatePackageYaml(dbQuerier pregistry.Query, packageName, downloadPath st
 
 	return utilerrors.NewAggregate(errs)
 }
+
+// DeprecateFromIndexRequest defines the parameters to send to the PruneFromIndex API
+type DeprecateFromIndexRequest struct {
+	Generate          bool
+	Permissive        bool
+	BinarySourceImage string
+	FromIndex         string
+	OutDockerfile     string
+	Bundles           []string
+	Tag               string
+}
+
+// DeprecateFromIndex takes a DeprecateFromIndexRequest and deprecates the requested
+// bundles.
+func (i ImageIndexer) DeprecateFromIndex(request DeprecateFromIndexRequest) error {
+	buildDir, outDockerfile, cleanup, err := buildContext(request.Generate, request.OutDockerfile)
+	defer cleanup()
+	if err != nil {
+		return err
+	}
+
+	databasePath, err := i.extractDatabase(buildDir, request.FromIndex)
+	if err != nil {
+		return err
+	}
+
+	// Run opm registry prune on the database
+	deprecateFromRegistryReq := registry.DeprecateFromRegistryRequest{
+		Bundles:       request.Bundles,
+		InputDatabase: databasePath,
+		Permissive:    request.Permissive,
+	}
+
+	// Prune the bundles from the registry
+	err = i.RegistryDeprecator.DeprecateFromRegistry(deprecateFromRegistryReq)
+	if err != nil {
+		return err
+	}
+
+	// generate the dockerfile
+	dockerfile := i.DockerfileGenerator.GenerateIndexDockerfile(request.BinarySourceImage, databasePath)
+	err = write(dockerfile, outDockerfile, i.Logger)
+	if err != nil {
+		return err
+	}
+
+	if request.Generate {
+		return nil
+	}
+
+	// build the dockerfile with requested tooling
+	err = build(outDockerfile, request.Tag, i.CommandRunner, i.Logger)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/lib/indexer/interfaces.go

@@ -80,3 +80,20 @@ func NewIndexPruner(containerTool containertools.ContainerTool, logger *logrus.E
 		Logger:              logger,
 	}
 }
+
+// IndexDeprecator prunes operators out of an index
+type IndexDeprecator interface {
+	DeprecateFromIndex(DeprecateFromIndexRequest) error
+}
+
+func NewIndexDeprecator(buildTool, pullTool containertools.ContainerTool, logger *logrus.Entry) IndexDeprecator {
+	return ImageIndexer{
+		DockerfileGenerator: containertools.NewDockerfileGenerator(logger),
+		CommandRunner:       containertools.NewCommandRunner(buildTool, logger),
+		LabelReader:         containertools.NewLabelReader(pullTool, logger),
+		RegistryDeprecator:  registry.NewRegistryDeprecator(logger),
+		BuildTool:           buildTool,
+		PullTool:            pullTool,
+		Logger:              logger,
+	}
+}

pkg/lib/registry/interfaces.go

@@ -36,3 +36,13 @@ func NewRegistryPruner(logger *logrus.Entry) RegistryPruner {
 		Logger: logger,
 	}
 }
+
+type RegistryDeprecator interface {
+	DeprecateFromRegistry(DeprecateFromRegistryRequest) error
+}
+
+func NewRegistryDeprecator(logger *logrus.Entry) RegistryDeprecator {
+	return RegistryUpdater{
+		Logger: logger,
+	}
+}

pkg/lib/registry/registry.go

@@ -228,3 +228,37 @@ func (r RegistryUpdater) PruneFromRegistry(request PruneFromRegistryRequest) err
 
 	return nil
 }
+
+type DeprecateFromRegistryRequest struct {
+	Permissive    bool
+	InputDatabase string
+	Bundles       []string
+}
+
+func (r RegistryUpdater) DeprecateFromRegistry(request DeprecateFromRegistryRequest) error {
+	db, err := sql.Open("sqlite3", request.InputDatabase)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	dbLoader, err := sqlite.NewSQLLiteLoader(db)
+	if err != nil {
+		return err
+	}
+	if err := dbLoader.Migrate(context.TODO()); err != nil {
+		return fmt.Errorf("unable to migrate database: %s", err)
+	}
+
+	deprecator := sqlite.NewSQLDeprecatorForBundles(dbLoader, request.Bundles)
+	if err := deprecator.Deprecate(); err != nil {
+		r.Logger.Debugf("unable to deprecate bundles from database: %s", err)
+		if !request.Permissive {
+			r.Logger.WithError(err).Error("permissive mode disabled")
+			return err
+		}
+		r.Logger.WithError(err).Warn("permissive mode enabled")
+	}
+
+	return nil
+}

pkg/registry/interface.go

@@ -12,6 +12,7 @@ type Load interface {
 	AddPackageChannels(manifest PackageManifest) error
 	AddBundlePackageChannels(manifest PackageManifest, bundle *Bundle) error
 	RemovePackage(packageName string) error
+	DeprecateBundle(path string) error
 	ClearNonHeadBundles() error
 }