allow empty systemUuid, generate pseudoUuid from serial

Author: xkonni

api/v1alpha1/server_types.go

@@ -83,7 +83,9 @@ type ServerSpec struct {
 	UUID string `json:"uuid,omitempty"`
 
 	// SystemUUID is the unique identifier for the server.
-	// +required
+	// If not provided, it will be derived from the serial
+	// during the discovery phase when the probe registers system details.
+	// +optional
 	SystemUUID string `json:"systemUUID"`
 
 	// SystemURI is the unique URI for the server resource in REDFISH API.

bmc/redfish.go

@@ -851,7 +851,9 @@ func (r *RedfishBMC) getSystemFromUri(ctx context.Context, systemURI string) (*r
 		}); err != nil {
 		return nil, fmt.Errorf("failed to wait for for server systems to be ready: %w", err)
 	}
-	if system.UUID != "" {
+	// System is considered ready even if UUID is empty - allow graceful handling of systems
+	// that don't expose System.UUID in their Redfish payload
+	if system != nil {
 		return system, nil
 	}
 	return nil, fmt.Errorf("no system found for %v", systemURI)

internal/controller/server_controller.go

@@ -5,6 +5,7 @@ package controller
 
 import (
 	"context"
+	"crypto/md5"
 	"crypto/rand"
 	"crypto/rsa"
 	"encoding/json"
@@ -812,6 +813,7 @@ func (r *ServerReconciler) extractServerDetailsFromRegistry(ctx context.Context,
 	}
 
 	serverBase := server.DeepCopy()
+
 	// update network interfaces
 	nics := make([]metalv1alpha1.NetworkInterface, 0, len(serverDetails.NetworkInterfaces))
 	for _, s := range serverDetails.NetworkInterfaces {
@@ -888,6 +890,23 @@ func (r *ServerReconciler) patchServerState(ctx context.Context, server *metalv1
 	return true, nil
 }
 
+// generatePseudoUUID generates a deterministic UUID from an input string.
+// Format: 99999999-xxxx-3xxx-8xxx-xxxxxxxxxxxx (prefix identifies generated UUIDs)
+func generatePseudoUUID(input string) string {
+	hash := md5.Sum([]byte(input))
+	hashHex := fmt.Sprintf("%x", hash[:])
+
+	// Build UUID with version (3) and variant (8) bits set
+	uuid := fmt.Sprintf("99999999-%s-%s3%s-8%s-%s",
+		hashHex[0:4],
+		hashHex[4:8],
+		hashHex[8:11],
+		hashHex[11:14],
+		hashHex[14:32],
+	)
+	return uuid
+}
+
 func (r *ServerReconciler) patchServerURI(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) {
 	if len(server.Spec.SystemURI) != 0 {
 		return false, nil
@@ -899,21 +918,55 @@ func (r *ServerReconciler) patchServerURI(ctx context.Context, log logr.Logger,
 		return false, err
 	}
 
-	for _, system := range systems {
-		if strings.EqualFold(system.UUID, server.Spec.SystemUUID) {
-			serverBase := server.DeepCopy()
-			server.Spec.SystemURI = system.URI
-			if err := r.Patch(ctx, server, client.MergeFrom(serverBase)); err != nil {
-				return false, fmt.Errorf("failed to patch server URI: %w", err)
+	// Try to find system by UUID if one is provided
+	if len(server.Spec.SystemUUID) > 0 {
+		for _, system := range systems {
+			if strings.EqualFold(system.UUID, server.Spec.SystemUUID) {
+				serverBase := server.DeepCopy()
+				server.Spec.SystemURI = system.URI
+				if err := r.Patch(ctx, server, client.MergeFrom(serverBase)); err != nil {
+					return false, fmt.Errorf("failed to patch server URI: %w", err)
+				}
+				return true, nil
 			}
 		}
 	}
-	if len(server.Spec.SystemURI) == 0 {
-		log.V(1).Info("Patching systemURI failed", "no system found for UUID", server.Spec.SystemUUID)
+
+	// If no system found by UUID or UUID is empty, and we only have one system, use it
+	// This handles cases where the Redfish implementation doesn't provide System.UUID
+	if len(systems) == 1 {
+		system := systems[0]
+		serverBase := server.DeepCopy()
+		server.Spec.SystemURI = system.URI
+
+		// If SystemUUID is empty, use system UUID if available, otherwise generate from SerialNumber
+		if len(server.Spec.SystemUUID) == 0 {
+			if len(system.UUID) > 0 {
+				server.Spec.SystemUUID = system.UUID
+			} else if len(system.SerialNumber) > 0 {
+				server.Spec.SystemUUID = generatePseudoUUID(system.SerialNumber)
+				log.V(1).Info("Generated pseudo-UUID from system serial number",
+					"serialNumber", system.SerialNumber, "pseudoUUID", server.Spec.SystemUUID)
+			} else {
+				return false, fmt.Errorf("system does not provide UUID or SerialNumber; cannot generate a unique identifier")
+			}
+		}
+
+		if err := r.Patch(ctx, server, client.MergeFrom(serverBase)); err != nil {
+			return false, fmt.Errorf("failed to patch server URI: %w", err)
+		}
+		return true, nil
+	}
+
+	// Multiple systems available but couldn't match by UUID
+	if len(server.Spec.SystemUUID) > 0 {
+		log.V(1).Info("No system found for UUID, and multiple systems available", "requestedUUID", server.Spec.SystemUUID)
 		return false, fmt.Errorf("unable to find system URI for UUID: %v", server.Spec.SystemUUID)
 	}
 
-	return true, nil
+	// No SystemUUID provided and multiple systems available - cannot determine which to use
+	log.V(1).Info("No SystemUUID provided and multiple systems available, cannot determine target system")
+	return false, fmt.Errorf("SystemUUID must be provided when multiple systems are available")
 }
 
 func (r *ServerReconciler) ensureServerPowerState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) error {