fix main.go and add controller logic

cmd/manager/main.go

@@ -7,8 +7,8 @@ import (
 	"os"
 	"runtime"
 
-	"github.com/kube-incubator/tomcat-operator/tomcat-operator/pkg/apis"
-	"github.com/kube-incubator/tomcat-operator/tomcat-operator/pkg/controller"
+	"github.com/kube-incubator/tomcat-operator/pkg/apis"
+	"github.com/kube-incubator/tomcat-operator/pkg/controller"
 
 	"github.com/operator-framework/operator-sdk/pkg/k8sutil"
 	"github.com/operator-framework/operator-sdk/pkg/leader"

pkg/controller/tomcat/internal/sync/common.go

@@ -0,0 +1,5 @@
+package sync
+
+var controllerLabels = map[string]string{
+	"app.kubernetes.io/managed-by": "tomcat-operator.apache.org",
+}

pkg/controller/tomcat/internal/sync/deployment.go

@@ -0,0 +1,66 @@
+package sync
+
+import (
+	"fmt"
+	"reflect"
+
+	appsv1 "k8s.io/api/apps/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/imdario/mergo"
+	"github.com/kube-incubator/kube-operator-helper/mergo/transformers"
+	"github.com/kube-incubator/kube-operator-helper/syncer"
+	"github.com/kube-incubator/tomcat-operator/pkg/scheme/tomcat"
+)
+
+var (
+	oneReplica int32 = 1
+)
+
+// NewDeploymentSyncer returns a new sync.Interface for reconciling tomcat Deployment
+func NewDeploymentSyncer(tc *tomcat.Tomcat, c client.Client, scheme *runtime.Scheme) syncer.Interface {
+	objLabels := tc.ComponentLabels(tomcat.TomcatDeployment)
+
+	obj := &appsv1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      tc.ComponentName(tomcat.TomcatDeployment),
+			Namespace: tc.Namespace,
+		},
+	}
+
+	return syncer.NewObjectSyncer("Deployment", tc.Unwrap(), obj, c, scheme, func(existing runtime.Object) error {
+		out := existing.(*appsv1.Deployment)
+		out.Labels = labels.Merge(labels.Merge(out.Labels, objLabels), controllerLabels)
+
+		template := tc.TomcatServerPodTemplateSpec()
+
+		out.Spec.Template.ObjectMeta = template.ObjectMeta
+
+		selector := metav1.SetAsLabelSelector(tc.TomcatServerPodLabels())
+		if !reflect.DeepEqual(selector, out.Spec.Selector) {
+			if out.ObjectMeta.CreationTimestamp.IsZero() {
+				out.Spec.Selector = selector
+			} else {
+				return fmt.Errorf("deployment selector is immutable")
+			}
+		}
+
+		err := mergo.Merge(&out.Spec.Template.Spec, template.Spec, mergo.WithTransformers(transformers.PodSpec))
+		if err != nil {
+			return err
+		}
+
+		if tc.Spec.Replicas != nil {
+			out.Spec.Replicas = tc.Spec.Replicas
+		}
+
+		if out.Spec.Replicas == nil {
+			out.Spec.Replicas = &oneReplica
+		}
+
+		return nil
+	})
+}

pkg/controller/tomcat/internal/sync/service.go

@@ -0,0 +1,51 @@
+package sync
+
+import (
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/intstr"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/kube-incubator/kube-operator-helper/syncer"
+	"github.com/kube-incubator/tomcat-operator/pkg/scheme/tomcat"
+)
+
+// NewServiceSyncer returns a new sync.Interface for reconciling Tomcat Service
+func NewServiceSyncer(tc *tomcat.Tomcat, c client.Client, scheme *runtime.Scheme) syncer.Interface {
+	objLabels := tc.ComponentLabels(tomcat.TomcatDeployment)
+
+	obj := &corev1.Service{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      tc.Name,
+			Namespace: tc.Namespace,
+		},
+	}
+
+	return syncer.NewObjectSyncer("Service", tc.Unwrap(), obj, c, scheme, func(existing runtime.Object) error {
+		out := existing.(*corev1.Service)
+		out.Labels = labels.Merge(labels.Merge(out.Labels, objLabels), controllerLabels)
+
+		selector := tc.TomcatServerPodLabels()
+		if !labels.Equals(selector, out.Spec.Selector) {
+			if out.ObjectMeta.CreationTimestamp.IsZero() {
+				out.Spec.Selector = selector
+			} else {
+				return fmt.Errorf("service selector is immutable")
+			}
+		}
+
+		if len(out.Spec.Ports) != 1 {
+			out.Spec.Ports = make([]corev1.ServicePort, 1)
+		}
+
+		out.Spec.Ports[0].Name = "http"
+		out.Spec.Ports[0].Port = *tc.Spec.ServicePort
+		out.Spec.Ports[0].TargetPort = intstr.FromInt(tomcat.TomcatHTTPPort)
+
+		return nil
+	})
+}

pkg/controller/tomcat/tomcat_controller.go

@@ -3,30 +3,27 @@ package tomcat
 import (
 	"context"
 
-	tomcatv1alpha1 "github.com/kube-incubator/tomcat-operator/pkg/apis/tomcat/v1alpha1"
-
+	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/tools/record"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
-	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
 	"sigs.k8s.io/controller-runtime/pkg/source"
+
+	"github.com/kube-incubator/kube-operator-helper/syncer"
+	tomcatv1alpha1 "github.com/kube-incubator/tomcat-operator/pkg/apis/tomcat/v1alpha1"
+	"github.com/kube-incubator/tomcat-operator/pkg/controller/tomcat/internal/sync"
+	"github.com/kube-incubator/tomcat-operator/pkg/scheme/tomcat"
 )
 
 var log = logf.Log.WithName("controller_tomcat")
 
-/**
-* USER ACTION REQUIRED: This is a scaffold file intended for the user to modify with their own Controller
-* business logic.  Delete these comments after modifying this file.*
- */
-
 // Add creates a new Tomcat Controller and adds it to the Manager. The Manager will set fields on the Controller
 // and Start it when the Manager is Started.
 func Add(mgr manager.Manager) error {
@@ -35,7 +32,7 @@ func Add(mgr manager.Manager) error {
 
 // newReconciler returns a new reconcile.Reconciler
 func newReconciler(mgr manager.Manager) reconcile.Reconciler {
-	return &ReconcileTomcat{client: mgr.GetClient(), scheme: mgr.GetScheme()}
+	return &ReconcileTomcat{client: mgr.GetClient(), scheme: mgr.GetScheme(), recorder: mgr.GetRecorder("tomcat-controller")}
 }
 
 // add adds a new Controller to mgr with r as the reconcile.Reconciler
@@ -52,14 +49,20 @@ func add(mgr manager.Manager, r reconcile.Reconciler) error {
 		return err
 	}
 
-	// TODO(user): Modify this to be the types you create that are owned by the primary resource
-	// Watch for changes to secondary resource Pods and requeue the owner Tomcat
-	err = c.Watch(&source.Kind{Type: &corev1.Pod{}}, &handler.EnqueueRequestForOwner{
-		IsController: true,
-		OwnerType:    &tomcatv1alpha1.Tomcat{},
-	})
-	if err != nil {
-		return err
+	// Watch for changes to the resources that owned by the primary resource
+	subresources := []runtime.Object{
+		&appsv1.Deployment{},
+		&corev1.Service{},
+	}
+
+	for _, subresource := range subresources {
+		err = c.Watch(&source.Kind{Type: subresource}, &handler.EnqueueRequestForOwner{
+			IsController: true,
+			OwnerType:    &tomcatv1alpha1.Tomcat{},
+		})
+		if err != nil {
+			return err
+		}
 	}
 
 	return nil
@@ -71,14 +74,13 @@ var _ reconcile.Reconciler = &ReconcileTomcat{}
 type ReconcileTomcat struct {
 	// This client, initialized using mgr.Client() above, is a split client
 	// that reads objects from the cache and writes to the apiserver
-	client client.Client
-	scheme *runtime.Scheme
+	client   client.Client
+	scheme   *runtime.Scheme
+	recorder record.EventRecorder
 }
 
 // Reconcile reads that state of the cluster for a Tomcat object and makes changes based on the state read
 // and what is in the Tomcat.Spec
-// TODO(user): Modify this Reconcile function to implement your Controller logic.  This example creates
-// a Pod as an example
 // Note:
 // The Controller will requeue the Request to be processed again if the returned error is non-nil or
 // Result.Requeue is true, otherwise upon completion it will remove the work from the queue.
@@ -87,8 +89,8 @@ func (r *ReconcileTomcat) Reconcile(request reconcile.Request) (reconcile.Result
 	reqLogger.Info("Reconciling Tomcat")
 
 	// Fetch the Tomcat instance
-	instance := &tomcatv1alpha1.Tomcat{}
-	err := r.client.Get(context.TODO(), request.NamespacedName, instance)
+	tomcat := tomcat.New(&tomcatv1alpha1.Tomcat{})
+	err := r.client.Get(context.TODO(), request.NamespacedName, tomcat.Unwrap())
 	if err != nil {
 		if errors.IsNotFound(err) {
 			// Request object not found, could have been deleted after reconcile request.
@@ -100,54 +102,22 @@ func (r *ReconcileTomcat) Reconcile(request reconcile.Request) (reconcile.Result
 		return reconcile.Result{}, err
 	}
 
-	// Define a new Pod object
-	pod := newPodForCR(instance)
+	r.scheme.Default(tomcat.Unwrap())
+	tomcat.SetDefaults()
 
-	// Set Tomcat instance as the owner and controller
-	if err := controllerutil.SetControllerReference(instance, pod, r.scheme); err != nil {
-		return reconcile.Result{}, err
-	}
-
-	// Check if this Pod already exists
-	found := &corev1.Pod{}
-	err = r.client.Get(context.TODO(), types.NamespacedName{Name: pod.Name, Namespace: pod.Namespace}, found)
-	if err != nil && errors.IsNotFound(err) {
-		reqLogger.Info("Creating a new Pod", "Pod.Namespace", pod.Namespace, "Pod.Name", pod.Name)
-		err = r.client.Create(context.TODO(), pod)
-		if err != nil {
-			return reconcile.Result{}, err
-		}
-
-		// Pod created successfully - don't requeue
-		return reconcile.Result{}, nil
-	} else if err != nil {
-		return reconcile.Result{}, err
+	syncers := []syncer.Interface{
+		sync.NewDeploymentSyncer(tomcat, r.client, r.scheme),
+		sync.NewServiceSyncer(tomcat, r.client, r.scheme),
 	}
 
-	// Pod already exists - don't requeue
-	reqLogger.Info("Skip reconcile: Pod already exists", "Pod.Namespace", found.Namespace, "Pod.Name", found.Name)
-	return reconcile.Result{}, nil
+	return reconcile.Result{}, r.sync(syncers)
 }
 
-// newPodForCR returns a busybox pod with the same name/namespace as the cr
-func newPodForCR(cr *tomcatv1alpha1.Tomcat) *corev1.Pod {
-	labels := map[string]string{
-		"app": cr.Name,
-	}
-	return &corev1.Pod{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      cr.Name + "-pod",
-			Namespace: cr.Namespace,
-			Labels:    labels,
-		},
-		Spec: corev1.PodSpec{
-			Containers: []corev1.Container{
-				{
-					Name:    "busybox",
-					Image:   "busybox",
-					Command: []string{"sleep", "3600"},
-				},
-			},
-		},
+func (r *ReconcileTomcat) sync(syncers []syncer.Interface) error {
+	for _, s := range syncers {
+		if err := syncer.Sync(context.TODO(), s, r.recorder); err != nil {
+			return err
+		}
 	}
+	return nil
 }