Merge pull request #850 from SchSeba/skip_drain_on_reboot_single_node

Allow to drain on single node

Author: zeeke

controllers/drain_controller_helper.go

@@ -86,8 +86,24 @@ func (dr *DrainReconcile) handleNodeDrainOrReboot(ctx context.Context,
 		}
 	}
 
+	// Check if we are on a single node, and we require a reboot/full-drain we just return
+	fullNodeDrain := nodeDrainAnnotation == constants.RebootRequired
+	singleNode := false
+	if fullNodeDrain {
+		nodeList := &corev1.NodeList{}
+		err := dr.Client.List(ctx, nodeList)
+		if err != nil {
+			reqLogger.Error(err, "failed to list nodes")
+			return ctrl.Result{}, err
+		}
+		if len(nodeList.Items) == 1 {
+			reqLogger.Info("drainNode(): FullNodeDrain requested and we are on Single node")
+			singleNode = true
+		}
+	}
+
 	// call the drain function that will also call drain to other platform providers like openshift
-	drained, err := dr.drainer.DrainNode(ctx, node, nodeDrainAnnotation == constants.RebootRequired)
+	drained, err := dr.drainer.DrainNode(ctx, node, fullNodeDrain, singleNode)
 	if err != nil {
 		reqLogger.Error(err, "error trying to drain the node")
 		dr.recorder.Event(nodeNetworkState,

controllers/drain_controller_test.go

@@ -113,7 +113,7 @@ var _ = Describe("Drain Controller", Ordered, func() {
 
 	Context("when there is only one node", func() {
 
-		It("should drain", func(ctx context.Context) {
+		It("should drain single node on drain require", func(ctx context.Context) {
 			node, nodeState := createNode(ctx, "node1")
 
 			simulateDaemonSetAnnotation(node, constants.DrainRequired)
@@ -126,6 +126,33 @@ var _ = Describe("Drain Controller", Ordered, func() {
 			expectNodeStateAnnotation(nodeState, constants.DrainIdle)
 			expectNodeIsSchedulable(node)
 		})
+
+		It("should not drain on reboot for single node", func(ctx context.Context) {
+			node, nodeState := createNode(ctx, "node1")
+
+			simulateDaemonSetAnnotation(node, constants.RebootRequired)
+
+			expectNodeStateAnnotation(nodeState, constants.DrainComplete)
+			expectNodeIsSchedulable(node)
+
+			simulateDaemonSetAnnotation(node, constants.DrainIdle)
+			expectNodeStateAnnotation(nodeState, constants.DrainIdle)
+			expectNodeIsSchedulable(node)
+		})
+
+		It("should drain on reboot for multiple node", func(ctx context.Context) {
+			node, nodeState := createNode(ctx, "node1")
+			createNode(ctx, "node2")
+
+			simulateDaemonSetAnnotation(node, constants.RebootRequired)
+
+			expectNodeStateAnnotation(nodeState, constants.DrainComplete)
+			expectNodeIsNotSchedulable(node)
+
+			simulateDaemonSetAnnotation(node, constants.DrainIdle)
+			expectNodeStateAnnotation(nodeState, constants.DrainIdle)
+			expectNodeIsSchedulable(node)
+		})
 	})
 
 	Context("when there are multiple nodes", func() {

pkg/drain/drainer.go

@@ -29,7 +29,7 @@ func (w writer) Write(p []byte) (n int, err error) {
 }
 
 type DrainInterface interface {
-	DrainNode(context.Context, *corev1.Node, bool) (bool, error)
+	DrainNode(context.Context, *corev1.Node, bool, bool) (bool, error)
 	CompleteDrainNode(context.Context, *corev1.Node) (bool, error)
 }
 
@@ -53,7 +53,7 @@ func NewDrainer(platformHelpers platforms.Interface) (DrainInterface, error) {
 // DrainNode the function cordon a node and drain pods from it
 // if fullNodeDrain true all the pods on the system will get drained
 // for openshift system we also pause the machine config pool this machine is part of it
-func (d *Drainer) DrainNode(ctx context.Context, node *corev1.Node, fullNodeDrain bool) (bool, error) {
+func (d *Drainer) DrainNode(ctx context.Context, node *corev1.Node, fullNodeDrain, singleNode bool) (bool, error) {
 	reqLogger := log.FromContext(ctx).WithValues("drain node", node.Name)
 	reqLogger.Info("drainNode(): Node drain requested", "node", node.Name)
 
@@ -68,6 +68,11 @@ func (d *Drainer) DrainNode(ctx context.Context, node *corev1.Node, fullNodeDrai
 		return false, nil
 	}
 
+	// Check if we are on a single node, and we require a reboot/full-drain we just return
+	if fullNodeDrain && singleNode {
+		return true, nil
+	}
+
 	drainHelper := createDrainHelper(d.kubeClient, ctx, fullNodeDrain)
 	backoff := wait.Backoff{
 		Steps:    5,