introduction of finalizer

pkg/controller/finalizer.go

@@ -0,0 +1,221 @@
+package controller
+
+import (
+	"fmt"
+	ex "github.com/pkg/errors"
+	flaggerv1 "github.com/weaveworks/flagger/pkg/apis/flagger/v1beta1"
+	"github.com/weaveworks/flagger/pkg/canary"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/util/retry"
+)
+
+const finalizer = "finalizer.flagger.com"
+
+func (c *Controller) finalize(old interface{}) error {
+	var r *flaggerv1.Canary
+	var ok bool
+
+	//Ensure interface is a canary
+	if r, ok = old.(*flaggerv1.Canary); !ok {
+		c.logger.Warnf("Received unexpected object: %v", old)
+		return nil
+	}
+
+	//Retrieve a controller
+	canaryController := c.canaryFactory.Controller(r.Spec.TargetRef.Kind)
+
+	//Set the status to terminating if not already in that state
+	if r.Status.Phase != flaggerv1.CanaryPhaseTerminating {
+		if err := canaryController.SetStatusPhase(r, flaggerv1.CanaryPhaseTerminating); err != nil {
+			c.logger.Infof("Failed to update status to finalizing %s", err)
+			return err
+		}
+		//record event
+		c.recordEventInfof(r, "Terminating canary %s.%s", r.Name, r.Namespace)
+	}
+
+	err := c.revertTargetRef(canaryController, r)
+	if err != nil {
+		if errors.IsNotFound(err) {
+			//No reason to wait not found
+			c.logger.Warnf("%s.%s failed due to %s not found", r.Name, r.Namespace, r.Kind)
+			return nil
+		}
+		c.logger.Errorf("%s.%s failed due to %s", r.Name, r.Namespace, err)
+		return err
+	} else {
+		//Ensure that targetRef has met a ready state
+		c.logger.Infof("Checking is canary is ready %s.%s", r.Name, r.Namespace)
+		ready, err := canaryController.IsCanaryReady(r)
+		if err != nil && ready {
+			return fmt.Errorf("%s.%s has not reached ready state during finalizing", r.Name, r.Namespace)
+		}
+
+	}
+
+	c.logger.Infof("%s.%s moving forward with router finalizing", r.Name, r.Namespace)
+	//TODO if I can't revert continue on?
+	labelSelector, ports, err := canaryController.GetMetadata(r)
+	if err != nil {
+		c.logger.Errorf("%s.%s failed to get metadata for router finalizing", r.Name, r.Namespace)
+		return err
+	}
+	//Revert the router
+	if err := c.revertRouter(r, labelSelector, ports); err != nil {
+		if errors.IsNotFound(err) {
+			return nil
+		}
+		return err
+	}
+
+	c.logger.Infof("%s.%s moving forward with mesh finalizing", r.Name, r.Namespace)
+	//TODO if I can't revert the mesh continue on?
+	//Revert the Mesh
+	if err := c.revertMesh(r); err != nil {
+		if errors.IsNotFound(err) {
+			return nil
+		}
+		return err
+	}
+
+	c.logger.Infof("Finalization complete for %s.%s", r.Name, r.Namespace)
+
+	return nil
+
+
+}
+
+func (c *Controller) revertTargetRef(ctrl canary.Controller, r *flaggerv1.Canary) error {
+	if err := ctrl.Finalize(r); err != nil {
+		return err
+	}
+	/*if err != nil {
+		if errors.IsNotFound(err) {
+			return false, err
+		}
+		return true, fmt.Errorf("%s.%s failed to revert deployment to original replicas", r.Name, r.Namespace)
+	}*/
+	c.logger.Infof("%s.%s kind %s reverted", r.Name, r.Namespace, r.Spec.TargetRef.Kind)
+	return nil
+}
+
+//revertRouter
+func (c *Controller) revertRouter(r *flaggerv1.Canary, labelSelector string, ports map[string]int32) error {
+	router := c.routerFactory.KubernetesRouter(r.Spec.TargetRef.Kind, labelSelector, map[string]string{}, ports)
+	if err := router.Finalize(r); err != nil {
+		c.logger.Errorf("%s.%s router failed with error %s", r.Name, r.Namespace, err)
+		return err
+	}
+	/*if err != nil {
+		return fmt.Errorf("%s.%s failed to revert service to original state", r.Name, r.Namespace)
+	}*/
+	c.logger.Infof("Service %s.%s reverted", r.Name, r.Namespace)
+	return nil
+}
+
+//revertMesh reverts defined mesh provider based upon the implementation's respective Finalize method.
+//If the Finalize method encounters and error that is returned, else revert is considered successful.
+func (c *Controller) revertMesh(r *flaggerv1.Canary) error {
+	provider := c.meshProvider
+	if r.Spec.Provider != "" {
+		provider = r.Spec.Provider
+	}
+
+	//Establish provider
+	meshRouter := c.routerFactory.MeshRouter(provider)
+
+	//Finalize mesh
+	err := meshRouter.Finalize(r)
+	if err != nil {
+		c.logger.Errorf("%s.%s mesh failed with error %s", r.Name, r.Namespace, err)
+		return err
+	}
+
+	c.logger.Infof("%s.%s mesh provider %s reverted", r.Name, r.Namespace, provider)
+	return nil
+}
+
+//hasFinalizer evaluates the finalizers of a given canary for for existence of a provide finalizer string.
+//It returns a boolean, true if the finalizer is found false otherwise.
+func hasFinalizer(canary *flaggerv1.Canary, finalizerString string) bool {
+	currentFinalizers := canary.ObjectMeta.Finalizers
+
+	for _, f := range currentFinalizers {
+		if f == finalizerString {
+			return true
+		}
+	}
+	return false
+}
+
+//addFinalizer adds a provided finalizer to the specified canary resource.
+//If failures occur the error will be returned otherwise the action is deemed successful
+//and error will be nil.
+func (c *Controller) addFinalizer(canary *flaggerv1.Canary, finalizerString string) error {
+	firstTry := true
+	err := retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
+
+		var selErr error
+		if !firstTry {
+			canary, selErr = c.flaggerClient.FlaggerV1beta1().Canaries(canary.Namespace).Get(canary.GetName(),metav1.GetOptions{})
+			if selErr != nil {
+				return selErr
+			}
+		}
+
+		copy := canary.DeepCopy()
+		copy.ObjectMeta.Finalizers = append(copy.ObjectMeta.Finalizers, finalizerString)
+
+		 _, err = c.flaggerClient.FlaggerV1beta1().Canaries(canary.Namespace).Update(copy)
+
+		firstTry = false
+		return
+	})
+
+	if err != nil {
+		return ex.Wrap(err, "Remove finalizer failed")
+	}
+	return nil
+}
+
+//removeFinalizer removes a provided finalizer to the specified canary resource.
+//If failures occur the error will be returned otherwise the action is deemed successful
+//and error will be nil.
+func (c *Controller) removeFinalizer(canary *flaggerv1.Canary, finalizerString string)  error {
+	firstTry := true
+	err := retry.RetryOnConflict(retry.DefaultBackoff, func() (err error) {
+
+		var selErr error
+		if !firstTry {
+			canary, selErr = c.flaggerClient.FlaggerV1beta1().Canaries(canary.Namespace).Get(canary.GetName(),metav1.GetOptions{})
+			if selErr != nil {
+				return selErr
+			}
+		}
+		copy := canary.DeepCopy()
+
+		newSlice := make([]string, 0)
+		for _, item := range copy.ObjectMeta.Finalizers {
+			if item == finalizerString {
+				continue
+			}
+			newSlice = append(newSlice, item)
+		}
+		if len(newSlice) == 0 {
+			newSlice = nil
+		}
+		copy.ObjectMeta.Finalizers = newSlice
+
+		_, err = c.flaggerClient.FlaggerV1beta1().Canaries(canary.Namespace).Update(copy)
+
+		firstTry = false
+		return
+	})
+
+	if err != nil {
+		return ex.Wrap(err, "Remove finalizer failed")
+	}
+	return nil
+
+}