test fix

Author: isabella-janssen

pkg/controller/common/layered_node_state.go

@@ -30,10 +30,13 @@ func NewLayeredNodeState(n *corev1.Node) *LayeredNodeState {
 // determined by the pool. If in layered mode, the image annotations are also checked
 // checked against the OCL objects.
 func (l *LayeredNodeState) IsDone(mcp *mcfgv1.MachineConfigPool, layered bool, mosc *mcfgv1.MachineOSConfig, mosb *mcfgv1.MachineOSBuild) bool {
-	if layered {
-		return l.IsNodeDone() && l.IsDesiredMachineConfigEqualToPool(mcp) && l.IsDesiredEqualToBuild(mosc, mosb)
-	}
-	return l.IsNodeDone() && l.IsDesiredMachineConfigEqualToPool(mcp)
+	// if layered {
+	// 	klog.Errorf("in IsDone and layered")
+	// 	return l.IsNodeDone() && l.IsDesiredMachineConfigEqualToPool(mcp) && l.IsDesiredEqualToBuild(mosc, mosb)
+	// }
+	// klog.Errorf("in IsDone and NOT layered")
+	// return l.IsNodeDone() && l.IsDesiredMachineConfigEqualToPool(mcp)
+	return l.IsNodeDone() && l.IsDesiredMachineConfigEqualToPool(mcp) && l.IsDesiredEqualToBuild(mosc, mosb)
 }
 
 // The original behavior of getUnavailableMachines is: getUnavailableMachines
@@ -67,19 +70,28 @@ func (l *LayeredNodeState) IsUnavailableForUpdate() bool {
 // node's desired image annotation and compares the MachineConfig specified by the
 // MachineOSBuild to the one specified by the node's desired MachineConfig annotation.
 func (l *LayeredNodeState) IsDesiredEqualToBuild(mosc *mcfgv1.MachineOSConfig, mosb *mcfgv1.MachineOSBuild) bool {
-	return (mosc != nil && l.isDesiredImageEqualToMachineOSConfig(mosc)) && (mosb != nil && l.isDesiredMachineConfigEqualToBuild(mosb))
+	klog.Errorf("in IsDesiredEqualToBuild")
+	return l.isDesiredImageEqualToMachineOSConfig(mosc) && l.isDesiredMachineConfigEqualToBuild(mosb)
 }
 
 // Compares the desired image annotation on the node against the CurrentImagePullSpec
 // specified by the MachineOSConfig object.
 func (l *LayeredNodeState) isDesiredImageEqualToMachineOSConfig(mosc *mcfgv1.MachineOSConfig) bool {
+	klog.Errorf("in isDesiredImageEqualToMachineOSConfig")
 	return l.isImageAnnotationEqualToMachineOSConfig(daemonconsts.DesiredImageAnnotationKey, mosc)
 }
 
 // Compares the MachineConfig specified by the MachineConfigPool to the MachineConfig
 // specified by the node's desired MachineConfig annotation.
 func (l *LayeredNodeState) isDesiredMachineConfigEqualToBuild(mosb *mcfgv1.MachineOSBuild) bool {
-	return l.node.Annotations[daemonconsts.DesiredMachineConfigAnnotationKey] == mosb.Spec.MachineConfig.Name
+	mosbName := ""
+	// Handle case when MOSB is nil (image mode is being disabled)
+	if mosb != nil {
+		// TODO: check if this comes back as nil or empty string
+		mosbName = mosb.Spec.MachineConfig.Name
+	}
+
+	return l.node.Annotations[daemonconsts.DesiredMachineConfigAnnotationKey] == mosbName
 
 }
 
@@ -92,7 +104,9 @@ func (l *LayeredNodeState) IsCurrentMachineConfigEqualToPool(mcp *mcfgv1.Machine
 // Compares the MachineConfig specified by the MachineConfigPool to the one
 // specified by the node's desired MachineConfig annotation.
 func (l *LayeredNodeState) IsDesiredMachineConfigEqualToPool(mcp *mcfgv1.MachineConfigPool) bool {
-	return l.node.Annotations[daemonconsts.DesiredMachineConfigAnnotationKey] == mcp.Spec.Configuration.Name
+	ret := l.node.Annotations[daemonconsts.DesiredMachineConfigAnnotationKey] == mcp.Spec.Configuration.Name
+	klog.Errorf("in IsDesiredMachineConfigEqualToPool, returning %v", ret)
+	return ret
 }
 
 // Checks if both the current and desired image annotation are present on the node.
@@ -113,23 +127,42 @@ func (l *LayeredNodeState) IsCurrentImageAnnotationPresentOnNode() bool {
 // Compares the CurrentImagePullSpec specified by the MachineOSConfig object against the
 // image specified by the annotation passed in.
 func (l *LayeredNodeState) isImageAnnotationEqualToMachineOSConfig(anno string, mosc *mcfgv1.MachineOSConfig) bool {
-	moscs := NewMachineOSConfigState(mosc)
+	moscImage := ""
 
+	// // Handle case when MOSC is nil (image mode is being disabled)
+	// if mosc != nil {
+	// 	// TOOD: check if this comes back as nil or empty string
+	// 	return moscName =
+	// }
+
+	// Get the image annotation from the node
 	val, ok := l.node.Annotations[anno]
+	klog.Errorf("in isImageAnnotationEqualToMachineOSConfig, val: %v, ok: %v", val, ok)
+
+	// // Handle case when MOSC is nil (image mode is being disabled)
+	// if mosc == nil {
+	// 	// TOOD: check if this comes back as nil or empty string
+	// 	return val == ""
+	// }
 
 	// If a layered node does not have an image annotation and has a valid MOSC, then the image is being built
 	if val == "" || !ok {
+		klog.Errorf("in isImageAnnotationEqualToMachineOSConfig returning false cause val == '' or !ok")
 		return false
 	}
 
+	// Get the MachineOSConfigState
+	moscs := NewMachineOSConfigState(mosc)
+	klog.Errorf("in isImageAnnotationEqualToMachineOSConfig with moscs")
+
 	if moscs.HasOSImage() {
 		// If the MOSC image has an image, the image annotation on the node can be directly compared.
-		return moscs.GetOSImage() == val
+		moscImage = moscs.GetOSImage()
 	}
 
 	// If the MOSC does not have an image, but the node has an older image annotation, the image is still likely
 	// being built.
-	return false
+	return moscImage == val
 }
 
 // Sets the desired MachineConfig annotations from the MachineConfigPool.
@@ -175,21 +208,26 @@ func (l *LayeredNodeState) Node() *corev1.Node {
 // isNodeDone returns true if the current == desired and the MCD has marked done.
 func (l *LayeredNodeState) IsNodeDone() bool {
 	if l.node.Annotations == nil {
+		klog.Error("in IsNodeDone, returning false, 1")
 		return false
 	}
 
 	if !l.isNodeConfigDone() {
+		klog.Error("in IsNodeDone, returning false, 2")
 		return false
 	}
 
 	if !l.isNodeImageDone() {
+		klog.Error("in IsNodeDone, returning false, 3")
 		return false
 	}
 
 	if !l.isNodeMCDState(daemonconsts.MachineConfigDaemonStateDone) {
+		klog.Error("in IsNodeDone, returning false, 4")
 		return false
 	}
 
+	klog.Error("in IsNodeDone, returning true")
 	return true
 }
 

pkg/controller/node/status.go

@@ -206,6 +206,7 @@ func (ctrl *Controller) calculateStatus(mcs []*mcfgv1.MachineConfigNode, cconfig
 
 	// this is # 1 priority, get the upgrade states actually reporting
 	if degradedMachineCount+readyMachineCount+unavailableMachineCount+updatingMachineCount != int32(len(nodes)) {
+		klog.Errorf("In degraded + ready + unavailable + updating != nodes...")
 
 		updatedMachines = getUpdatedMachines(pool, nodes, mosc, mosb, isLayeredPool)
 		updatedMachineCount = int32(len(updatedMachines))
@@ -218,6 +219,8 @@ func (ctrl *Controller) calculateStatus(mcs []*mcfgv1.MachineConfigNode, cconfig
 
 		degradedMachines = getDegradedMachines(nodes)
 		degradedMachineCount = int32(len(degradedMachines))
+	} else {
+		klog.Errorf("In degraded + ready + unavailable + updating == nodes... Not where we want to be.")
 	}
 
 	for _, n := range degradedMachines {