refactor status_helpers.go methods by reducing duplicate lines

Author: mliptak0

pkg/services/status_helpers.go

@@ -11,54 +11,70 @@ import (
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/errors"
 )
 
+// computeNodePoolConditionsJSON aggregates adapter statuses into marshaled conditions JSON.
+// Returns nil if conditions are unchanged relative to np.StatusConditions.
+func computeNodePoolConditionsJSON(
+	ctx context.Context,
+	np *api.NodePool,
+	adapterStatuses []*api.AdapterStatus,
+	requiredAdapters []string,
+) ([]byte, *errors.ServiceError) {
+	ready, available, adapterConditions := AggregateResourceStatus(ctx, AggregateResourceStatusInput{
+		ResourceGeneration: np.Generation,
+		RefTime:            nodePoolRefTime(np),
+		PrevConditionsJSON: np.StatusConditions,
+		RequiredAdapters:   requiredAdapters,
+		AdapterStatuses:    adapterStatuses,
+	})
+
+	allConditions := make([]api.ResourceCondition, 0, 2+len(adapterConditions))
+	allConditions = append(allConditions, ready, available)
+	allConditions = append(allConditions, adapterConditions...)
+
+	conditionsJSON, err := json.Marshal(allConditions)
+	if err != nil {
+		return nil, errors.GeneralError("Failed to marshal conditions: %s", err)
+	}
+
+	if bytes.Equal(np.StatusConditions, conditionsJSON) {
+		return nil, nil
+	}
+
+	return conditionsJSON, nil
+}
+
+// updateNodePoolStatusFromAdapters fetches a single nodepool by ID, recomputes its status
+// conditions from current adapter reports, and persists the result via Replace.
+// Returns the updated nodepool unchanged if conditions have not changed.
 func updateNodePoolStatusFromAdapters(
 	ctx context.Context,
 	nodePoolID string,
 	nodePoolDao dao.NodePoolDao,
 	adapterStatusDao dao.AdapterStatusDao,
 	adapterConfig *config.AdapterRequirementsConfig,
 ) (*api.NodePool, *errors.ServiceError) {
-	// Get the nodepool
 	nodePool, err := nodePoolDao.Get(ctx, nodePoolID)
 	if err != nil {
 		return nil, handleGetError("NodePool", "id", nodePoolID, err)
 	}
 
-	// Get adapter statuses
 	adapterStatuses, err := adapterStatusDao.FindByResource(ctx, "NodePool", nodePoolID)
 	if err != nil {
 		return nil, errors.GeneralError("Failed to get adapter statuses: %s", err)
 	}
 
-	// Compute reference time
-	refTime := nodePoolRefTime(nodePool)
-
-	// Aggregate status
-	ready, available, adapterConditions := AggregateResourceStatus(ctx, AggregateResourceStatusInput{
-		ResourceGeneration: nodePool.Generation,
-		RefTime:            refTime,
-		PrevConditionsJSON: nodePool.StatusConditions,
-		RequiredAdapters:   adapterConfig.RequiredNodePoolAdapters(),
-		AdapterStatuses:    adapterStatuses,
-	})
-
-	// Build combined conditions
-	allConditions := make([]api.ResourceCondition, 0, 2+len(adapterConditions))
-	allConditions = append(allConditions, ready, available)
-	allConditions = append(allConditions, adapterConditions...)
-
-	// Marshal conditions
-	conditionsJSON, err := json.Marshal(allConditions)
-	if err != nil {
-		return nil, errors.GeneralError("Failed to marshal conditions: %s", err)
+	conditionsJSON, svcErr := computeNodePoolConditionsJSON(
+		ctx,
+		nodePool,
+		adapterStatuses,
+		adapterConfig.RequiredNodePoolAdapters())
+	if svcErr != nil {
+		return nil, svcErr
 	}
-
-	// Short-circuit if unchanged
-	if bytes.Equal(nodePool.StatusConditions, conditionsJSON) {
+	if conditionsJSON == nil {
 		return nodePool, nil
 	}
 
-	// Update and persist
 	nodePool.StatusConditions = conditionsJSON
 	nodePool, err = nodePoolDao.Replace(ctx, nodePool)
 	if err != nil {
@@ -69,8 +85,8 @@ func updateNodePoolStatusFromAdapters(
 }
 
 // batchUpdateNodePoolStatusesFromAdapters updates status conditions for multiple nodepools.
-// It eliminates the N+1 query pattern by fetching all adapter statuses in one query
-// and persisting all changed nodepools via UpdateStatusConditionsByIDs.
+// It's fetching all adapter statuses in one query and persisting
+// all changed nodepools via UpdateStatusConditionsByIDs.
 func batchUpdateNodePoolStatusesFromAdapters(
 	ctx context.Context,
 	nodePools []*api.NodePool,
@@ -94,35 +110,19 @@ func batchUpdateNodePoolStatusesFromAdapters(
 
 	statusesByResource := make(map[string][]*api.AdapterStatus)
 	for i := range allStatuses {
-		status := allStatuses[i]
-		statusesByResource[status.ResourceID] = append(statusesByResource[status.ResourceID], status)
+		s := allStatuses[i]
+		statusesByResource[s.ResourceID] = append(statusesByResource[s.ResourceID], s)
 	}
 
 	updates := make(map[string][]byte)
 	requiredAdapters := adapterConfig.RequiredNodePoolAdapters()
 
 	for _, np := range nodePools {
-		refTime := nodePoolRefTime(np)
-		adapterStatuses := statusesByResource[np.ID]
-
-		ready, available, adapterConditions := AggregateResourceStatus(ctx, AggregateResourceStatusInput{
-			ResourceGeneration: np.Generation,
-			RefTime:            refTime,
-			PrevConditionsJSON: np.StatusConditions,
-			RequiredAdapters:   requiredAdapters,
-			AdapterStatuses:    adapterStatuses,
-		})
-
-		allConditions := make([]api.ResourceCondition, 0, 2+len(adapterConditions))
-		allConditions = append(allConditions, ready, available)
-		allConditions = append(allConditions, adapterConditions...)
-
-		conditionsJSON, marshalErr := json.Marshal(allConditions)
-		if marshalErr != nil {
-			return errors.GeneralError("Failed to marshal conditions: %s", marshalErr)
+		conditionsJSON, svcErr := computeNodePoolConditionsJSON(ctx, np, statusesByResource[np.ID], requiredAdapters)
+		if svcErr != nil {
+			return svcErr
 		}
-
-		if !bytes.Equal(np.StatusConditions, conditionsJSON) {
+		if conditionsJSON != nil {
 			updates[np.ID] = conditionsJSON
 		}
 	}