Add simple operator package

Author: pwittrock

pkg/patterns/application/application.go

@@ -0,0 +1,150 @@
+/*
+Copyright 2018 The Kubernetes 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 application
+
+import (
+	"fmt"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/rest"
+	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
+	"sigs.k8s.io/controller-runtime/pkg/client/config"
+	"sigs.k8s.io/controller-runtime/pkg/controller"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
+)
+
+// application is a simple Controller for a single API type.  It will create a Manager for itself
+// if one is not provided.
+type application struct {
+	mgr  manager.Manager
+	ctrl controller.Controller
+}
+
+// Supporting mocking out functions for testing
+var getConfig = config.GetConfig
+var newController = controller.New
+var newManager = manager.New
+var getGvk = apiutil.GVKForObject
+
+// Builder builds an Application Controller (e.g. Operator) and returns a manager.Manager to start it.
+type Builder struct {
+	apiType        runtime.Object
+	mgr            manager.Manager
+	predicates     []predicate.Predicate
+	managedObjects []runtime.Object
+	config         *rest.Config
+	reconcile      reconcile.Reconciler
+}
+
+// BuilderFor returns a new Builder for and BuilderFor
+func BuilderFor(apiType runtime.Object) *Builder {
+	return &Builder{apiType: apiType}
+}
+
+// Owns configures the Application Controller to respond to create / delete / update events for objects it managedObjects
+// - e.g. creates.  apiType is an empty instance of an object matching the managed object type.
+func (b *Builder) Owns(apiType runtime.Object) *Builder {
+	b.managedObjects = append(b.managedObjects, apiType)
+	return b
+}
+
+// WithConfig sets the Config to use for configuring clients.  Defaults to the in-cluster config or to ~/.kube/config.
+func (b *Builder) WithConfig(config *rest.Config) *Builder {
+	b.config = config
+	return b
+}
+
+// WithManager sets the Manager to use for registering the Controller.  Defaults to a new manager.Manager.
+func (b *Builder) WithManager(m manager.Manager) *Builder {
+	b.mgr = m
+	return b
+}
+
+// WithEventFilter sets the event filters, to filter which create/update/delete/generic events eventually
+// trigger reconciliations.  For example, filtering on whether the resource version has changed.
+// Defaults to the empty list.
+func (b *Builder) WithEventFilter(p predicate.Predicate) *Builder {
+	b.predicates = append(b.predicates, p)
+	return b
+}
+
+// WithReconciler sets the Reconcile called in response to create / update / delete events for the
+// BuilderFor type or Created object types.
+func (b *Builder) WithReconciler(r reconcile.Reconciler) *Builder {
+	b.reconcile = r
+	return b
+}
+
+// Build builds the Application Controller and returns the Manager used to start it.
+func (b *Builder) Build() (manager.Manager, error) {
+	a := &application{}
+
+	if b.reconcile == nil {
+		return nil, fmt.Errorf("must call WithReconciler to set Reconciler")
+	}
+
+	var err error
+	if b.config == nil {
+		b.config, err = getConfig()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if b.mgr == nil {
+		b.mgr, err = newManager(b.config, manager.Options{})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	a.mgr = b.mgr
+
+	gvk, err := getGvk(b.apiType, a.mgr.GetScheme())
+	if err != nil {
+		return nil, err
+	}
+
+	// Create the controller
+	name := fmt.Sprintf("%s-application", strings.ToLower(gvk.Kind))
+	a.ctrl, err = newController(name, a.mgr, controller.Options{Reconciler: b.reconcile})
+	if err != nil {
+		return nil, err
+	}
+
+	// Reconcile type
+	err = a.ctrl.Watch(&source.Kind{Type: b.apiType}, &handler.EnqueueRequestForObject{}, b.predicates...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Watch the managed types
+	for _, t := range b.managedObjects {
+		err = a.ctrl.Watch(&source.Kind{Type: t}, &handler.EnqueueRequestForOwner{
+			OwnerType: b.apiType, IsController: true}, b.predicates...)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return a.mgr, nil
+}

pkg/patterns/application/application_suite_test.go

@@ -0,0 +1,35 @@
+package application
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"k8s.io/client-go/rest"
+	"sigs.k8s.io/controller-runtime/pkg/envtest"
+	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
+)
+
+func TestSource(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecsWithDefaultAndCustomReporters(t, "application Suite", []Reporter{envtest.NewlineReporter{}})
+}
+
+var testenv *envtest.Environment
+var cfg *rest.Config
+
+var _ = BeforeSuite(func(done Done) {
+	logf.SetLogger(logf.ZapLogger(false))
+
+	testenv = &envtest.Environment{}
+
+	var err error
+	cfg, err = testenv.Start()
+	Expect(err).NotTo(HaveOccurred())
+
+	close(done)
+}, 60)
+
+var _ = AfterSuite(func() {
+	testenv.Stop()
+})

pkg/patterns/application/application_test.go

@@ -0,0 +1,206 @@
+package application
+
+import (
+	"context"
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/rest"
+	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
+	"sigs.k8s.io/controller-runtime/pkg/controller"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+var _ = Describe("application", func() {
+	var stop chan struct{}
+
+	BeforeEach(func() {
+		stop = make(chan struct{})
+		getConfig = func() (*rest.Config, error) { return cfg, nil }
+		newController = controller.New
+		newManager = manager.New
+		getGvk = apiutil.GVKForObject
+	})
+
+	AfterEach(func() {
+		close(stop)
+	})
+
+	noop := reconcile.Func(func(req reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil })
+
+	Describe("New", func() {
+		It("should return success if given valid objects", func() {
+			instance, err := BuilderFor(&appsv1.ReplicaSet{}).Owns(&appsv1.ReplicaSet{}).WithReconciler(noop).Build()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(instance).NotTo(BeNil())
+		})
+
+		It("should return an error if the Config is invalid", func() {
+			getConfig = func() (*rest.Config, error) { return cfg, fmt.Errorf("expected error") }
+			instance, err := BuilderFor(&appsv1.ReplicaSet{}).Owns(&appsv1.ReplicaSet{}).WithReconciler(noop).Build()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("expected error"))
+			Expect(instance).To(BeNil())
+		})
+
+		It("should return an error if there is no GVK for an object", func() {
+			instance, err := BuilderFor(fakeType("")).Owns(&appsv1.ReplicaSet{}).WithReconciler(noop).Build()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("expected pointer, but got application.fakeType"))
+			Expect(instance).To(BeNil())
+
+			instance, err = BuilderFor(&appsv1.ReplicaSet{}).Owns(fakeType("")).WithReconciler(noop).Build()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("expected pointer, but got application.fakeType"))
+			Expect(instance).To(BeNil())
+		})
+
+		It("should return an error if it cannot create the manager", func() {
+			newManager = func(config *rest.Config, options manager.Options) (manager.Manager, error) {
+				return nil, fmt.Errorf("expected error")
+			}
+			instance, err := BuilderFor(&appsv1.ReplicaSet{}).Owns(&appsv1.ReplicaSet{}).WithReconciler(noop).Build()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("expected error"))
+			Expect(instance).To(BeNil())
+		})
+
+		It("should return an error if it cannot create the controller", func() {
+			newController = func(name string, mgr manager.Manager, options controller.Options) (
+				controller.Controller, error) {
+				return nil, fmt.Errorf("expected error")
+			}
+			instance, err := BuilderFor(&appsv1.ReplicaSet{}).Owns(&appsv1.ReplicaSet{}).WithReconciler(noop).Build()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("expected error"))
+			Expect(instance).To(BeNil())
+		})
+
+		It("should return an error if there is no Reconciler", func() {
+			// Prevent getGVK from failing so watch fails
+			getGvk = func(obj runtime.Object, scheme *runtime.Scheme) (schema.GroupVersionKind, error) {
+				return schema.GroupVersionKind{Kind: "foo"}, nil
+			}
+			instance, err := BuilderFor(&appsv1.ReplicaSet{}).Owns(&appsv1.ReplicaSet{}).Build()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("must call WithReconciler to set Reconciler"))
+			Expect(instance).To(BeNil())
+		})
+
+		It("should use the provide config", func() {
+
+		})
+
+		It("should use the provide manager", func() {
+
+		})
+
+		It("should use the provide filters", func() {
+
+		})
+	})
+
+	Describe("Start", func() {
+		It("should Reconcile objects", func(done Done) {
+			By("Creating the application")
+			ch := make(chan reconcile.Request)
+			fn := reconcile.Func(func(req reconcile.Request) (reconcile.Result, error) {
+				defer GinkgoRecover()
+				ch <- req
+				return reconcile.Result{}, nil
+			})
+
+			instance, err := BuilderFor(&appsv1.Deployment{}).
+				WithConfig(cfg).
+				Owns(&appsv1.ReplicaSet{}).
+				WithReconciler(fn).
+				Build()
+			Expect(err).NotTo(HaveOccurred())
+
+			By("Starting the application")
+			go func() {
+				defer GinkgoRecover()
+				Expect(instance.Start(stop)).NotTo(HaveOccurred())
+				By("Stopping the application")
+			}()
+
+			By("Creating a Deployment")
+			// Expect a Reconcile when the Deployment is managedObjects.
+			dep := &appsv1.Deployment{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "default",
+					Name:      "deploy-name",
+				},
+				Spec: appsv1.DeploymentSpec{
+					Selector: &metav1.LabelSelector{
+						MatchLabels: map[string]string{"foo": "bar"},
+					},
+					Template: corev1.PodTemplateSpec{
+						ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"foo": "bar"}},
+						Spec: corev1.PodSpec{
+							Containers: []corev1.Container{
+								{
+									Name:  "nginx",
+									Image: "nginx",
+								},
+							},
+						},
+					},
+				},
+			}
+			err = instance.GetClient().Create(context.TODO(), dep)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("Waiting for the Deployment Reconcile")
+			Expect(<-ch).To(Equal(reconcile.Request{
+				NamespacedName: types.NamespacedName{Namespace: "default", Name: "deploy-name"}}))
+
+			By("Creating a ReplicaSet")
+			// Expect a Reconcile when an Owned object is managedObjects.
+			t := true
+			rs := &appsv1.ReplicaSet{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "default",
+					Name:      "rs-name",
+					Labels:    dep.Spec.Selector.MatchLabels,
+					OwnerReferences: []metav1.OwnerReference{
+						{
+							Name:       "deploy-name",
+							Kind:       "Deployment",
+							APIVersion: "apps/v1",
+							Controller: &t,
+							UID:        dep.UID,
+						},
+					},
+				},
+				Spec: appsv1.ReplicaSetSpec{
+					Selector: dep.Spec.Selector,
+					Template: dep.Spec.Template,
+				},
+			}
+			err = instance.GetClient().Create(context.TODO(), rs)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("Waiting for the ReplicaSet Reconcile")
+			Expect(<-ch).To(Equal(reconcile.Request{
+				NamespacedName: types.NamespacedName{Namespace: "default", Name: "deploy-name"}}))
+
+			close(done)
+		}, 10)
+	})
+})
+
+var _ runtime.Object = fakeType("")
+
+type fakeType string
+
+func (fakeType) GetObjectKind() schema.ObjectKind { return nil }
+func (fakeType) DeepCopyObject() runtime.Object   { return nil }