pkg/helm: new watch file option to support watching dependent resources

pkg/helm/controller/reconcile.go

@@ -175,9 +175,11 @@ func (r HelmOperatorReconciler) Reconcile(request reconcile.Request) (reconcile.
 		}
 		status.RemoveCondition(types.ConditionReleaseFailed)
 
-		if err := r.releaseHook(installedRelease); err != nil {
-			log.Error(err, "Failed to run release hook")
-			return reconcile.Result{}, err
+		if r.releaseHook != nil {
+			if err := r.releaseHook(installedRelease); err != nil {
+				log.Error(err, "Failed to run release hook")
+				return reconcile.Result{}, err
+			}
 		}
 
 		log.Info("Installed release")
@@ -212,9 +214,11 @@ func (r HelmOperatorReconciler) Reconcile(request reconcile.Request) (reconcile.
 		}
 		status.RemoveCondition(types.ConditionReleaseFailed)
 
-		if err := r.releaseHook(updatedRelease); err != nil {
-			log.Error(err, "Failed to run release hook")
-			return reconcile.Result{}, err
+		if r.releaseHook != nil {
+			if err := r.releaseHook(updatedRelease); err != nil {
+				log.Error(err, "Failed to run release hook")
+				return reconcile.Result{}, err
+			}
 		}
 
 		log.Info("Updated release")
@@ -247,9 +251,11 @@ func (r HelmOperatorReconciler) Reconcile(request reconcile.Request) (reconcile.
 	}
 	status.RemoveCondition(types.ConditionIrreconcilable)
 
-	if err := r.releaseHook(expectedRelease); err != nil {
-		log.Error(err, "Failed to run release hook")
-		return reconcile.Result{}, err
+	if r.releaseHook != nil {
+		if err := r.releaseHook(expectedRelease); err != nil {
+			log.Error(err, "Failed to run release hook")
+			return reconcile.Result{}, err
+		}
 	}
 
 	log.Info("Reconciled release")

pkg/helm/release/manager_factory.go

@@ -49,6 +49,11 @@ type managerFactory struct {
 	chartDir         string
 }
 
+// NewManagerFactory returns a new Helm manager factory capable of installing and uninstalling releases.
+func NewManagerFactory(storageBackend *storage.Storage, tillerKubeClient *kube.Client, chartDir string) ManagerFactory {
+	return &managerFactory{storageBackend, tillerKubeClient, chartDir}
+}
+
 func (f managerFactory) NewManager(r *unstructured.Unstructured) Manager {
 	return f.newManagerForCR(r)
 }

pkg/helm/run.go

@@ -23,6 +23,7 @@ import (
 	"github.com/operator-framework/operator-sdk/pkg/helm/controller"
 	hoflags "github.com/operator-framework/operator-sdk/pkg/helm/flags"
 	"github.com/operator-framework/operator-sdk/pkg/helm/release"
+	"github.com/operator-framework/operator-sdk/pkg/helm/watches"
 	"github.com/operator-framework/operator-sdk/pkg/k8sutil"
 	sdkVersion "github.com/operator-framework/operator-sdk/version"
 
@@ -77,20 +78,20 @@ func Run(flags *hoflags.HelmOperatorFlags) {
 		os.Exit(1)
 	}
 
-	factories, err := release.NewManagerFactoriesFromFile(storageBackend, tillerKubeClient, flags.WatchesFile)
+	watches, err := watches.Load(flags.WatchesFile)
 	if err != nil {
 		log.Error(err, "")
 		os.Exit(1)
 	}
 
-	for gvk, factory := range factories {
+	for _, w := range watches {
 		// Register the controller with the factory.
 		err := controller.Add(mgr, controller.WatchOptions{
 			Namespace:               namespace,
-			GVK:                     gvk,
-			ManagerFactory:          factory,
+			GVK:                     w.GroupVersionKind,
+			ManagerFactory:          release.NewManagerFactory(storageBackend, tillerKubeClient, w.ChartDir),
 			ReconcilePeriod:         flags.ReconcilePeriod,
-			WatchDependentResources: true,
+			WatchDependentResources: w.WatchDependentResources,
 		})
 		if err != nil {
 			log.Error(err, "")

pkg/helm/watches/watches.go

@@ -0,0 +1,112 @@
+// Copyright 2019 The Operator-SDK Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package watches
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+
+	yaml "gopkg.in/yaml.v2"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/helm/pkg/chartutil"
+)
+
+// Watch defines options for configuring a watch for a Helm-based
+// custom resource.
+type Watch struct {
+	GroupVersionKind        schema.GroupVersionKind
+	ChartDir                string
+	WatchDependentResources bool
+}
+
+type yamlWatch struct {
+	Group                   string `yaml:"group"`
+	Version                 string `yaml:"version"`
+	Kind                    string `yaml:"kind"`
+	Chart                   string `yaml:"chart"`
+	WatchDependentResources bool   `yaml:"watchDependentResources"`
+}
+
+func (w *yamlWatch) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	// by default, the operator will watch dependent resources
+	w.WatchDependentResources = true
+
+	// hide watch data in plain struct to prevent unmarshal from calling
+	// UnmarshalYAML again
+	type plain yamlWatch
+
+	return unmarshal((*plain)(w))
+}
+
+// Load loads a slice of Watches from the watch file at `path`. For each entry
+// in the watches file, it verifies the configuration. If an error is
+// encountered loading the file or verifying the configuration, it will be
+// returned.
+func Load(path string) ([]Watch, error) {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	yamlWatches := []yamlWatch{}
+	err = yaml.Unmarshal(b, &yamlWatches)
+	if err != nil {
+		return nil, err
+	}
+
+	watches := []Watch{}
+	watchesMap := make(map[schema.GroupVersionKind]Watch)
+	for _, w := range yamlWatches {
+		gvk := schema.GroupVersionKind{
+			Group:   w.Group,
+			Version: w.Version,
+			Kind:    w.Kind,
+		}
+
+		if err := verifyGVK(gvk); err != nil {
+			return nil, fmt.Errorf("invalid GVK: %s: %s", gvk, err)
+		}
+
+		if _, err := chartutil.IsChartDir(w.Chart); err != nil {
+			return nil, fmt.Errorf("invalid chart directory %s: %s", w.Chart, err)
+		}
+
+		if _, ok := watchesMap[gvk]; ok {
+			return nil, fmt.Errorf("duplicate GVK: %s", gvk)
+		}
+		watch := Watch{
+			GroupVersionKind:        gvk,
+			ChartDir:                w.Chart,
+			WatchDependentResources: w.WatchDependentResources,
+		}
+		watchesMap[gvk] = watch
+		watches = append(watches, watch)
+	}
+	return watches, nil
+}
+
+func verifyGVK(gvk schema.GroupVersionKind) error {
+	// A GVK without a group is valid. Certain scenarios may cause a GVK
+	// without a group to fail in other ways later in the initialization
+	// process.
+	if gvk.Version == "" {
+		return errors.New("version must not be empty")
+	}
+	if gvk.Kind == "" {
+		return errors.New("kind must not be empty")
+	}
+	return nil
+}