Update to be able to track both DaemonSets and Deployments

pkg/controller/networkconfig/networkconfig_controller.go

@@ -53,7 +53,7 @@ func newReconciler(mgr manager.Manager, status *clusteroperator.StatusManager) *
 		scheme: mgr.GetScheme(),
 		status: status,
 
-		daemonSetReconciler: newDaemonSetReconciler(status),
+		podReconciler: newPodReconciler(status),
 	}
 }
 
@@ -71,15 +71,19 @@ func add(mgr manager.Manager, r *ReconcileNetworkConfig) error {
 		return err
 	}
 
-	// Likewise for the DaemonSet reconciler
-	c, err = controller.New("daemonset-controller", mgr, controller.Options{Reconciler: r.daemonSetReconciler})
+	// Likewise for the Pod reconciler
+	c, err = controller.New("pod-controller", mgr, controller.Options{Reconciler: r.podReconciler})
 	if err != nil {
 		return err
 	}
 	err = c.Watch(&source.Kind{Type: &appsv1.DaemonSet{}}, &handler.EnqueueRequestForObject{})
 	if err != nil {
 		return err
 	}
+	err = c.Watch(&source.Kind{Type: &appsv1.Deployment{}}, &handler.EnqueueRequestForObject{})
+	if err != nil {
+		return err
+	}
 
 	return nil
 }
@@ -94,7 +98,7 @@ type ReconcileNetworkConfig struct {
 	scheme *runtime.Scheme
 	status *clusteroperator.StatusManager
 
-	daemonSetReconciler *ReconcileDaemonSets
+	podReconciler *ReconcilePods
 }
 
 // Reconcile updates the state of the cluster to match that which is desired
@@ -185,15 +189,24 @@ func (r *ReconcileNetworkConfig) Reconcile(request reconcile.Request) (reconcile
 	}
 	objs = append([]*uns.Unstructured{app}, objs...)
 
-	// Set up the DaemonSet reconciler before we start creating the DaemonSets
+	// Set up the Pod reconciler before we start creating DaemonSets/Deployments
 	r.status.SetConfigSuccess()
 	daemonSets := []types.NamespacedName{}
+	deployments := []types.NamespacedName{}
 	for _, obj := range objs {
 		if obj.GetAPIVersion() == "apps/v1" && obj.GetKind() == "DaemonSet" {
 			daemonSets = append(daemonSets, types.NamespacedName{Namespace: obj.GetNamespace(), Name: obj.GetName()})
+		} else if obj.GetAPIVersion() == "apps/v1" && obj.GetKind() == "Deployment" {
+			deployments = append(deployments, types.NamespacedName{Namespace: obj.GetNamespace(), Name: obj.GetName()})
 		}
 	}
-	r.daemonSetReconciler.SetDaemonSets(daemonSets)
+	r.status.SetDaemonSets(daemonSets)
+	r.status.SetDeployments(deployments)
+
+	allResources := []types.NamespacedName{}
+	allResources = append(allResources, daemonSets...)
+	allResources = append(allResources, deployments...)
+	r.podReconciler.SetResources(allResources)
 
 	// Apply the objects to the cluster
 	for _, obj := range objs {

pkg/controller/networkconfig/pod_controller.go

@@ -0,0 +1,48 @@
+package networkconfig
+
+import (
+	"log"
+
+	"github.com/openshift/cluster-network-operator/pkg/util/clusteroperator"
+
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+// newPodReconciler returns a new reconcile.Reconciler
+func newPodReconciler(status *clusteroperator.StatusManager) *ReconcilePods {
+	return &ReconcilePods{status: status}
+}
+
+var _ reconcile.Reconciler = &ReconcilePods{}
+
+// ReconcilePods watches for updates to specified resources and then updates its StatusManager
+type ReconcilePods struct {
+	status *clusteroperator.StatusManager
+
+	resources []types.NamespacedName
+}
+
+func (r *ReconcilePods) SetResources(resources []types.NamespacedName) {
+	r.resources = resources
+}
+
+// Reconcile updates the ClusterOperator.Status to match the current state of the
+// watched Deployments/DaemonSets
+func (r *ReconcilePods) Reconcile(request reconcile.Request) (reconcile.Result, error) {
+	found := false
+	for _, name := range r.resources {
+		if name.Namespace == request.Namespace && name.Name == request.Name {
+			found = true
+			break
+		}
+	}
+	if !found {
+		return reconcile.Result{}, nil
+	}
+
+	log.Printf("Reconciling update to %s/%s\n", request.Namespace, request.Name)
+	r.status.SetFromPods()
+
+	return reconcile.Result{RequeueAfter: ResyncPeriod}, nil
+}

pkg/util/clusteroperator/status_manager.go

@@ -26,6 +26,9 @@ type StatusManager struct {
 	version string
 
 	configFailure bool
+
+	daemonSets  []types.NamespacedName
+	deployments []types.NamespacedName
 }
 
 func NewStatusManager(client client.Client, name, version string) *StatusManager {
@@ -114,17 +117,25 @@ func (status *StatusManager) SetFailing(reason string, err error) error {
 	)
 }
 
-// SetFromDaemonSets sets the operator status to Failing, Progressing, or Available, based
-// on the current status of the indicated DaemonSets. However, this is a no-op if the
-// StatusManager is currently marked as failing due to a configuration error.
-func (status *StatusManager) SetFromDaemonSets(daemonSets []types.NamespacedName) error {
+func (status *StatusManager) SetDaemonSets(daemonSets []types.NamespacedName) {
+	status.daemonSets = daemonSets
+}
+
+func (status *StatusManager) SetDeployments(deployments []types.NamespacedName) {
+	status.deployments = deployments
+}
+
+// SetFromPods sets the operator status to Failing, Progressing, or Available, based on
+// the current status of the manager's DaemonSets and Deployments. However, this is a
+// no-op if the StatusManager is currently marked as failing due to a configuration error.
+func (status *StatusManager) SetFromPods() error {
 	if status.configFailure {
 		return nil
 	}
 
 	progressing := []string{}
 
-	for _, dsName := range daemonSets {
+	for _, dsName := range status.daemonSets {
 		ns := &corev1.Namespace{}
 		if err := status.client.Get(context.TODO(), types.NamespacedName{Name: dsName.Namespace}, ns); err != nil {
 			if errors.IsNotFound(err) {
@@ -150,6 +161,32 @@ func (status *StatusManager) SetFromDaemonSets(daemonSets []types.NamespacedName
 		}
 	}
 
+	for _, depName := range status.deployments {
+		ns := &corev1.Namespace{}
+		if err := status.client.Get(context.TODO(), types.NamespacedName{Name: depName.Namespace}, ns); err != nil {
+			if errors.IsNotFound(err) {
+				return status.SetFailing("NoNamespace", fmt.Errorf("Namespace %q does not exist", depName.Namespace))
+			} else {
+				return status.SetFailing("InternalError", err)
+			}
+		}
+
+		dep := &appsv1.Deployment{}
+		if err := status.client.Get(context.TODO(), depName, dep); err != nil {
+			if errors.IsNotFound(err) {
+				return status.SetFailing("NoDeployment", fmt.Errorf("Deployment %q does not exist", depName.String()))
+			} else {
+				return status.SetFailing("InternalError", err)
+			}
+		}
+
+		if dep.Status.UnavailableReplicas > 0 {
+			progressing = append(progressing, fmt.Sprintf("Deployment %q is not available (awaiting %d nodes)", depName.String(), dep.Status.UnavailableReplicas))
+		} else if dep.Status.AvailableReplicas == 0 {
+			progressing = append(progressing, fmt.Sprintf("Deployment %q is not yet scheduled on any nodes", depName.String()))
+		}
+	}
+
 	if len(progressing) > 0 {
 		return status.Set(
 			&configv1.ClusterOperatorStatusCondition{