gittrackobject_controller.go

/*
Copyright 2018 Pusher Ltd.

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 gittrackobject

import (
	"context"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"

	farosv1alpha1 "github.com/pusher/faros/pkg/apis/faros/v1alpha1"
	gittrackobjectutils "github.com/pusher/faros/pkg/controller/gittrackobject/utils"

	"github.com/go-logr/logr"
	farosflags "github.com/pusher/faros/pkg/flags"
	"github.com/pusher/faros/pkg/utils"
	farosclient "github.com/pusher/faros/pkg/utils/client"
	"k8s.io/apimachinery/pkg/api/errors"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/record"
	"sigs.k8s.io/controller-runtime/pkg/cache"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/controller"
	"sigs.k8s.io/controller-runtime/pkg/event"
	"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"
	rlogr "sigs.k8s.io/controller-runtime/pkg/runtime/log"
	"sigs.k8s.io/controller-runtime/pkg/source"
)

// Add creates a new GitTrackObject Controller and adds it to the Manager with default RBAC. The Manager will set fields on the Controller
// and Start it when the Manager is Started.
// USER ACTION REQUIRED: update cmd/manager/main.go to call this faros.Add(mgr) to install this Controller
func Add(mgr manager.Manager) error {
	rec, opts := newReconciler(mgr)
	return add(mgr, rec, opts)
}

// newReconciler returns a new reconcile.Reconciler
func newReconciler(mgr manager.Manager) (reconcile.Reconciler, *reconcileGitTrackObjectOpts) {
	// Set up informer stop channel
	stop := make(chan struct{})
	c := make(chan os.Signal)
	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
	go func() {
		<-c
		close(stop)
	}()

	applier, err := farosclient.NewApplier(mgr.GetConfig(), farosclient.Options{})
	if err != nil {
		panic(fmt.Errorf("unable to create applier: %v", err))
	}

	dryRunVerifier, err := utils.NewDryRunVerifier(mgr.GetConfig())
	if err != nil {
		panic(fmt.Errorf("unable to create dry run verifier: %v", err))
	}

	rec := &ReconcileGitTrackObject{
		Client:              mgr.GetClient(),
		scheme:              mgr.GetScheme(),
		eventStream:         make(chan event.GenericEvent),
		cache:               mgr.GetCache(),
		informers:           make(map[string]cache.Informer),
		config:              mgr.GetConfig(),
		stop:                stop,
		recorder:            mgr.GetEventRecorderFor("gittrackobject-controller"),
		applier:             applier,
		dryRunVerifier:      dryRunVerifier,
		log:                 rlogr.Log.WithName("gittrackobject-controller"),
		namespace:           farosflags.Namespace,
		gitTrackMode:        farosflags.GitTrack,
		clusterGitTrackMode: farosflags.ClusterGitTrack,
	}
	opts := &reconcileGitTrackObjectOpts{
		gitTrackMode:        farosflags.GitTrack,
		clusterGitTrackMode: farosflags.ClusterGitTrack,
	}
	return rec, opts
}

// reconcileGitTrackOpts is the mode that we're running the reconciler
// in. Being able to change these options during runtime is helpful during tests.
type reconcileGitTrackObjectOpts struct {
	clusterGitTrackMode farosflags.ClusterGitTrackMode
	gitTrackMode        farosflags.GitTrackMode
}

// add adds a new Controller to mgr with r as the reconcile.Reconciler
func add(mgr manager.Manager, r reconcile.Reconciler, opts *reconcileGitTrackObjectOpts) error {
	// Create a new controller
	c, err := controller.New("gittrackobject-controller", mgr, controller.Options{Reconciler: r})
	if err != nil {
		return err
	}

	// Watch for changes to GitTrackObject
	if opts.gitTrackMode != farosflags.GTMDisabled {
		err = c.Watch(&source.Kind{Type: &farosv1alpha1.GitTrackObject{}},
			&handler.EnqueueRequestForObject{},
			utils.NewOwnerIsGitTrackPredicate(mgr.GetClient()))
		if err != nil {
			return err
		}
	}
	if opts.clusterGitTrackMode == farosflags.CGTMIncludeNamespaced {
		err = c.Watch(&source.Kind{Type: &farosv1alpha1.GitTrackObject{}},
			&handler.EnqueueRequestForObject{},
			utils.NewOwnerIsClusterGitTrackPredicate(mgr.GetClient()))
		if err != nil {
			return err
		}
	}

	if opts.clusterGitTrackMode != farosflags.CGTMDisabled {
		// Watch for changes to ClusterGitTrackObject
		err = c.Watch(
			&source.Kind{Type: &farosv1alpha1.ClusterGitTrackObject{}},
			&handler.EnqueueRequestForObject{},
		)
		if err != nil {
			return err
		}
	}

	// Watch for events on the reconciler's eventStream channel
	if gtoReconciler, ok := r.(Reconciler); ok {
		src := &source.Channel{
			Source: gtoReconciler.EventStream(),
		}

		// usually, this would be created by multiple independent watches, but because our source is a channel
		// we can't do that, since once one watch reads off the channel, the value isn't there for any other watches.
		// Instead construct a predicate that will fire if any of the underlying predicates fire
		var preds []predicate.Predicate
		if opts.gitTrackMode == farosflags.GTMEnabled {
			preds = append(preds, utils.NewOwnersOwnerIsGitTrackPredicate(mgr.GetClient()))
		}
		if opts.clusterGitTrackMode != farosflags.CGTMDisabled {
			includeNamespaced := opts.clusterGitTrackMode == farosflags.CGTMIncludeNamespaced
			preds = append(preds, utils.NewOwnersOwnerIsClusterGitTrackPredicate(mgr.GetClient(), includeNamespaced))
		}

		// When an event is received, queue the event's owner for reconciliation
		err = c.Watch(src,
			&gittrackobjectutils.EnqueueRequestForOwner{
				NamespacedEnqueueRequestForOwner: &handler.EnqueueRequestForOwner{
					IsController: true,
					OwnerType:    &farosv1alpha1.GitTrackObject{},
				},
				NonNamespacedEnqueueRequestForOwner: &handler.EnqueueRequestForOwner{
					IsController: true,
					OwnerType:    &farosv1alpha1.ClusterGitTrackObject{},
				},
				Log: rlogr.Log.WithName("gittrackobject-controller/enqueue-request-for-owner"),
			},
			utils.NewAnyPredicate(preds...),
		)
		if err != nil {
			msg := fmt.Sprintf("unable to watch channel: %v", err)
			log.Printf(msg)
			return fmt.Errorf(msg)
		}
	}

	return nil
}

// Reconciler allows the test suite to mock the required methods
// for setting up the watch streams.
type Reconciler interface {
	EventStream() chan event.GenericEvent
	StopChan() chan struct{}
}

var _ reconcile.Reconciler = &ReconcileGitTrackObject{}

// ReconcileGitTrackObject reconciles a GitTrackObject object
type ReconcileGitTrackObject struct {
	client.Client
	scheme      *runtime.Scheme
	eventStream chan event.GenericEvent
	cache       cache.Cache
	informers   map[string]cache.Informer
	config      *rest.Config
	stop        chan struct{}
	recorder    record.EventRecorder
	log         logr.Logger

	namespace           string
	gitTrackMode        farosflags.GitTrackMode
	clusterGitTrackMode farosflags.ClusterGitTrackMode

	applier        farosclient.Client
	dryRunVerifier *utils.DryRunVerifier
}

// EventStream returns a stream of generic event to trigger reconciles
func (r *ReconcileGitTrackObject) EventStream() chan event.GenericEvent {
	return r.eventStream
}

// StopChan returns the object stop channel
func (r *ReconcileGitTrackObject) StopChan() chan struct{} {
	return r.stop
}

func (r *ReconcileGitTrackObject) withValues(keysAndValues ...interface{}) *ReconcileGitTrackObject {
	reconciler := *r
	reconciler.log = r.log.WithValues(keysAndValues...)
	return &reconciler
}

// Reconcile reads that state of the cluster for a GitTrackObject object and makes changes based on the state read
// and what is in the GitTrackObject.Spec
// Automatically generate RBAC rules to allow the Controller to read and write Deployments
// +kubebuilder:rbac:groups=*,resources=*,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=faros.pusher.com,resources=gittrackobjects,verbs=get;list;watch;create;update;patch;delete
func (r *ReconcileGitTrackObject) Reconcile(request reconcile.Request) (reconcile.Result, error) {
	// Fetch the GTO requested
	instance, err := r.getInstance(request)
	if err != nil {
		if errors.IsNotFound(err) {
			// Object not found, return.  Created objects are automatically garbage collected.
			// For additional cleanup logic use finalizers.
			return reconcile.Result{}, nil
		}
		// Error reading the object - requeue the request.
		return reconcile.Result{}, err
	}

	// Get a reconciler with appropriate logging values
	reconciler := r.withValues(
		"namespace", instance.GetNamespace(),
		"child name", instance.GetSpec().Name,
		"child kind", instance.GetSpec().Kind,
	)

	reconciler.log.V(1).Info("Reconcile started")

	// Create new opts structs for updating status and metrics
	result := reconciler.handleGitTrackObject(instance)
	reconciler.updateStatus(instance, &statusOpts{inSyncError: result.inSyncError, inSyncReason: result.inSyncReason})
	inSync := result.inSyncError == nil
	reconciler.updateMetrics(instance, &metricsOpts{inSync: inSync})

	reconciler.log.V(1).Info("Reconcile finished")
	return reconcile.Result{}, result.inSyncError
}

// getInstance fetches the requested (Cluster)GitTrackObject from the API server
func (r *ReconcileGitTrackObject) getInstance(request reconcile.Request) (farosv1alpha1.GitTrackObjectInterface, error) {
	var instance farosv1alpha1.GitTrackObjectInterface
	if request.Namespace != "" {
		instance = &farosv1alpha1.GitTrackObject{}
	} else {
		instance = &farosv1alpha1.ClusterGitTrackObject{}
	}

	// Fetch the ClusterGitTrackObject instance
	err := r.Get(context.TODO(), request.NamespacedName, instance)
	if err != nil {
		return nil, err
	}
	return instance, nil
}