Merge pull request kubernetes-sigs#2 from droot/machineset-adoption

added machinedeployment rollout and machineset adoption logic

Author: Phillip Wittrock

pkg/controller/machinedeployment/controller.go

@@ -18,6 +18,7 @@ package machinedeployment
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 
 	"github.com/golang/glog"
@@ -26,7 +27,8 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
-	clusterv1alpha1 "sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha1"
+	"sigs.k8s.io/cluster-api/pkg/apis/cluster/common"
+	"sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
@@ -36,35 +38,50 @@ import (
 )
 
 // controllerKind contains the schema.GroupVersionKind for this controller type.
-var controllerKind = clusterv1alpha1.SchemeGroupVersion.WithKind("MachineDeployment")
+var controllerKind = v1alpha1.SchemeGroupVersion.WithKind("MachineDeployment")
 
-// Add creates a new MachineDeployment Controller and adds it to the Manager with default RBAC.
-func Add(mgr manager.Manager) error {
-	return add(mgr, newReconciler(mgr))
+// ReconcileMachineDeployment reconciles a MachineDeployment object
+type ReconcileMachineDeployment struct {
+	client.Client
+	scheme *runtime.Scheme
 }
 
 // newReconciler returns a new reconcile.Reconciler
-func newReconciler(mgr manager.Manager) reconcile.Reconciler {
+func newReconciler(mgr manager.Manager) *ReconcileMachineDeployment {
 	return &ReconcileMachineDeployment{Client: mgr.GetClient(), scheme: mgr.GetScheme()}
 }
 
+// Add creates a new MachineDeployment Controller and adds it to the Manager with default RBAC.
+func Add(mgr manager.Manager) error {
+	r := newReconciler(mgr)
+	return add(mgr, newReconciler(mgr), r.MachineSetToDeployments)
+}
+
 // add adds a new Controller to mgr with r as the reconcile.Reconciler
-func add(mgr manager.Manager, r reconcile.Reconciler) error {
+func add(mgr manager.Manager, r reconcile.Reconciler, mapFn handler.ToRequestsFunc) error {
 	// Create a new controller
 	c, err := controller.New("machinedeployment-controller", mgr, controller.Options{Reconciler: r})
 	if err != nil {
 		return err
 	}
 
 	// Watch for changes to MachineDeployment
-	err = c.Watch(&source.Kind{Type: &clusterv1alpha1.MachineDeployment{}}, &handler.EnqueueRequestForObject{})
+	err = c.Watch(&source.Kind{Type: &v1alpha1.MachineDeployment{}}, &handler.EnqueueRequestForObject{})
 	if err != nil {
 		return err
 	}
 
 	// Watch for changes to MachineSet and reconcile the owner MachineDeployment
-	err = c.Watch(&source.Kind{Type: &clusterv1alpha1.MachineSet{}},
-		&handler.EnqueueRequestForOwner{OwnerType: &clusterv1alpha1.MachineDeployment{}, IsController: true})
+	err = c.Watch(&source.Kind{Type: &v1alpha1.MachineSet{}},
+		&handler.EnqueueRequestForOwner{OwnerType: &v1alpha1.MachineDeployment{}, IsController: true})
+	if err != nil {
+		return err
+	}
+
+	// Map MachineSet changes to MachineDeployment
+	err = c.Watch(
+		&source.Kind{Type: &v1alpha1.MachineSet{}},
+		&handler.EnqueueRequestsFromMapFunc{ToRequests: mapFn})
 	if err != nil {
 		return err
 	}
@@ -74,18 +91,49 @@ func add(mgr manager.Manager, r reconcile.Reconciler) error {
 
 var _ reconcile.Reconciler = &ReconcileMachineDeployment{}
 
-// ReconcileMachineDeployment reconciles a MachineDeployment object
-type ReconcileMachineDeployment struct {
-	client.Client
-	scheme *runtime.Scheme
+func (r *ReconcileMachineDeployment) getMachineSetsForDeployment(d *v1alpha1.MachineDeployment) ([]*v1alpha1.MachineSet, error) {
+	// List all MachineSets to find those we own but that no longer match our
+	// selector.
+	machineSets := &v1alpha1.MachineSetList{}
+	err := r.List(context.Background(), client.InNamespace(d.Namespace), machineSets)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: flush out machine set adoption.
+
+	var filteredMS []*v1alpha1.MachineSet
+	for idx, _ := range machineSets.Items {
+		ms := &machineSets.Items[idx]
+		if metav1.GetControllerOf(ms) == nil || (metav1.GetControllerOf(ms) != nil && !metav1.IsControlledBy(ms, d)) {
+			glog.V(4).Infof("%s not controlled by %v", ms.Name, d.Name)
+			continue
+		}
+		selector, err := metav1.LabelSelectorAsSelector(&d.Spec.Selector)
+		if err != nil {
+			glog.Errorf("Skipping machineset %v, failed to get label selector from spec selector.", ms.Name)
+			continue
+		}
+		// If a deployment with a nil or empty selector creeps in, it should match nothing, not everything.
+		if selector.Empty() {
+			glog.Warningf("Skipping machineset %v as the selector is empty.", ms.Name)
+			continue
+		}
+		if !selector.Matches(labels.Set(ms.Labels)) {
+			glog.V(4).Infof("Skipping machineset %v, label mismatch.", ms.Name)
+			continue
+		}
+		filteredMS = append(filteredMS, ms)
+	}
+	return filteredMS, nil
 }
 
 // Reconcile reads that state of the cluster for a MachineDeployment object and makes changes based on the state read
 // and what is in the MachineDeployment.Spec
 // +kubebuilder:rbac:groups=cluster.k8s.io,resources=machinedeployments,verbs=get;list;watch;create;update;patch;delete
 func (r *ReconcileMachineDeployment) Reconcile(request reconcile.Request) (reconcile.Result, error) {
 	// Fetch the MachineDeployment instance
-	d := &clusterv1alpha1.MachineDeployment{}
+	d := &v1alpha1.MachineDeployment{}
 	err := r.Get(context.TODO(), request.NamespacedName, d)
 	if err != nil {
 		if errors.IsNotFound(err) {
@@ -96,6 +144,7 @@ func (r *ReconcileMachineDeployment) Reconcile(request reconcile.Request) (recon
 		// Error reading the object - requeue the request.
 		return reconcile.Result{}, err
 	}
+
 	everything := metav1.LabelSelector{}
 	if reflect.DeepEqual(d.Spec.Selector, &everything) {
 		if d.Status.ObservedGeneration < d.Generation {
@@ -126,55 +175,50 @@ func (r *ReconcileMachineDeployment) Reconcile(request reconcile.Request) (recon
 		return reconcile.Result{}, r.sync(d, msList, machineMap)
 	}
 
-	return reconcile.Result{}, nil
+	switch d.Spec.Strategy.Type {
+	case common.RollingUpdateMachineDeploymentStrategyType:
+		return reconcile.Result{}, r.rolloutRolling(d, msList, machineMap)
+	}
+
+	return reconcile.Result{}, fmt.Errorf("unexpected deployment strategy type: %s", d.Spec.Strategy.Type)
 }
 
-func (r *ReconcileMachineDeployment) getMachineSetsForDeployment(d *clusterv1alpha1.MachineDeployment) ([]*clusterv1alpha1.MachineSet, error) {
-	// List all MachineSets to find those we own but that no longer match our
-	// selector.
-	machineSets := &clusterv1alpha1.MachineSetList{}
-	err := r.List(context.Background(),
-		// TODO(droot): check if we need to specify labels for fetching
-		// everything ?
-		// client.InNamespace(d.Namespace).MatchingLabels(labels.Everything()),
-		client.InNamespace(d.Namespace), machineSets)
-	if err != nil {
-		return nil, err
+// getMachineDeploymentsForMachineSet returns a list of Deployments that potentially
+// match a MachineSet.
+func (r *ReconcileMachineDeployment) getMachineDeploymentsForMachineSet(ms *v1alpha1.MachineSet) []*v1alpha1.MachineDeployment {
+	if len(ms.Labels) == 0 {
+		glog.Warningf("no machine deployments found for MachineSet %v because it has no labels", ms.Name)
+		return nil
 	}
 
-	// TODO: flush out machine set adoption.
+	dList := &v1alpha1.MachineDeploymentList{}
+	err := r.Client.List(context.Background(), client.InNamespace(ms.Namespace), dList)
+	if err != nil {
+		glog.Warningf("failed to list machine deployments, %v", err)
+		return nil
+	}
 
-	var filteredMS []*clusterv1alpha1.MachineSet
-	for idx := range machineSets.Items {
-		ms := &machineSets.Items[idx]
-		if metav1.GetControllerOf(ms) == nil || (metav1.GetControllerOf(ms) != nil && !metav1.IsControlledBy(ms, d)) {
-			glog.V(4).Infof("%s not controlled by %v", ms.Name, d.Name)
-			continue
-		}
+	var deployments []*v1alpha1.MachineDeployment
+	for idx, d := range dList.Items {
 		selector, err := metav1.LabelSelectorAsSelector(&d.Spec.Selector)
 		if err != nil {
-			glog.Errorf("Skipping machineset %v, failed to get label selector from spec selector.", ms.Name)
 			continue
 		}
 		// If a deployment with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() {
-			glog.Warningf("Skipping machineset %v as the selector is empty.", ms.Name)
-			continue
-		}
-		if !selector.Matches(labels.Set(ms.Labels)) {
-			glog.V(4).Infof("Skipping machineset %v, label mismatch.", ms.Name)
+		if selector.Empty() || !selector.Matches(labels.Set(ms.Labels)) {
 			continue
 		}
-		filteredMS = append(filteredMS, ms)
+		deployments = append(deployments, &dList.Items[idx])
 	}
-	return filteredMS, nil
+
+	return deployments
 }
 
 // getMachineMapForDeployment returns the Machines managed by a Deployment.
 //
 // It returns a map from MachineSet UID to a list of Machines controlled by that MS,
 // according to the Machine's ControllerRef.
-func (r *ReconcileMachineDeployment) getMachineMapForDeployment(d *clusterv1alpha1.MachineDeployment, msList []*clusterv1alpha1.MachineSet) (map[types.UID]*clusterv1alpha1.MachineList, error) {
+func (r *ReconcileMachineDeployment) getMachineMapForDeployment(d *v1alpha1.MachineDeployment, msList []*v1alpha1.MachineSet) (map[types.UID]*v1alpha1.MachineList, error) {
 	// TODO(droot): double check if previous selector maps correctly to new one.
 	// _, err := metav1.LabelSelectorAsSelector(&d.Spec.Selector)
 
@@ -183,15 +227,15 @@ func (r *ReconcileMachineDeployment) getMachineMapForDeployment(d *clusterv1alph
 	if err != nil {
 		return nil, err
 	}
-	machines := &clusterv1alpha1.MachineList{}
+	machines := &v1alpha1.MachineList{}
 	err = r.List(context.Background(), client.InNamespace(d.Namespace).MatchingLabels(selector), machines)
 	if err != nil {
 		return nil, err
 	}
 	// Group Machines by their controller (if it's in msList).
-	machineMap := make(map[types.UID]*clusterv1alpha1.MachineList, len(msList))
+	machineMap := make(map[types.UID]*v1alpha1.MachineList, len(msList))
 	for _, ms := range msList {
-		machineMap[ms.UID] = &clusterv1alpha1.MachineList{}
+		machineMap[ms.UID] = &v1alpha1.MachineList{}
 	}
 	for idx := range machines.Items {
 		machine := &machines.Items[idx]
@@ -208,3 +252,33 @@ func (r *ReconcileMachineDeployment) getMachineMapForDeployment(d *clusterv1alph
 	}
 	return machineMap, nil
 }
+
+func (r *ReconcileMachineDeployment) MachineSetToDeployments(o handler.MapObject) []reconcile.Request {
+	result := []reconcile.Request{}
+	ms := &v1alpha1.MachineSet{}
+	key := client.ObjectKey{Namespace: o.Meta.GetNamespace(), Name: o.Meta.GetNamespace()}
+	err := r.Client.Get(context.Background(), key, ms)
+	if err != nil {
+		glog.Errorf("Unable to retrieve Machineset %v from store: %v", key, err)
+		return nil
+	}
+
+	for _, ref := range ms.ObjectMeta.OwnerReferences {
+		if ref.Controller != nil && *ref.Controller {
+			return result
+		}
+	}
+
+	mds := r.getMachineDeploymentsForMachineSet(ms)
+	if len(mds) == 0 {
+		glog.V(4).Infof("Found no machine set for machine: %v", ms.Name)
+		return nil
+	}
+
+	for _, md := range mds {
+		result = append(result, reconcile.Request{
+			NamespacedName: client.ObjectKey{Namespace: md.Namespace, Name: md.Name}})
+	}
+
+	return result
+}

pkg/controller/machinedeployment/machinedeployment_controller_test.go

@@ -50,7 +50,8 @@ func TestReconcile(t *testing.T) {
 	c = mgr.GetClient()
 
 	recFn, requests := SetupTestReconcile(newReconciler(mgr))
-	g.Expect(add(mgr, recFn)).NotTo(gomega.HaveOccurred())
+	r := &ReconcileMachineDeployment{}
+	g.Expect(add(mgr, recFn, r.MachineSetToDeployments)).NotTo(gomega.HaveOccurred())
 	defer close(StartTestManager(mgr, g))
 
 	// Create the MachineDeployment object and expect the Reconcile and Deployment to be created