Add PreallocatedMode skeleton for predetermined GUID lookup

In pre-allocated mode the GUID for a pod's IB network is a deterministic
function of (pkey, hca index, node index) rather than a free GUID pulled
from the pool. This is for substrates where we are not the UFM fabric
admin and GUIDs/PKeys are pre-provisioned by the provider (IREN B300s).

- Add PREALLOCATED_MODE config flag (DaemonConfig), default false so
  existing substrates are unchanged.
- Branch in processNetworkGUID: use LookupPredeterminedGUID when the flag
  is set, else GenerateGUID (unchanged).
- LookupPredeterminedGUID extracts pkey (CNI spec), hca index (networkID
  trailing number) and node index (node name suffix). The deterministic
  encoding itself is stubbed (TCL-7011) and returns not-implemented.
- Unit tests for the hca/node index parsers.

Refs TCL-6978

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: 2 people

pkg/config/config.go

@@ -27,6 +27,10 @@ type DaemonConfig struct {
 	// with UTC timestamps from GetServerTime().
 	// Example: "America/New_York", "America/Los_Angeles", "UTC" (default).
 	SMTimezone string `env:"SM_TIMEZONE" envDefault:"UTC"`
+	// Use deterministic pre-allocated GUIDs (lookup) instead of allocating from the pool.
+	// Enabled on substrates where we are not the UFM fabric admin and GUIDs/PKeys are
+	// pre-provisioned by the provider (e.g. IREN B300s).
+	PreallocatedMode bool `env:"PREALLOCATED_MODE" envDefault:"false"`
 }
 
 type GUIDPoolConfig struct {

pkg/daemon/daemon.go

@@ -8,6 +8,8 @@ import (
 	"os"
 	"os/signal"
 	"path"
+	"strconv"
+	"strings"
 	"sync"
 	"syscall"
 	"time"
@@ -500,18 +502,27 @@ func (d *daemon) processNetworkGUID(networkID string, spec *utils.IbSriovCniSpec
 			return err
 		}
 	} else {
-		guidAddr, err = d.guidPool.GenerateGUID()
-		// TODO(Nik): This error handling is funky. We sync the GUID pool but then don't
-		// re-assign a guidAddr so we're left with a 0 guid
-		if err != nil {
-			switch {
-			case errors.Is(err, guid.ErrGUIDPoolExhausted):
-				err = syncGUIDPool(d.smClient, d.guidPool)
-				if err != nil {
-					return err
+		if d.config.PreallocatedMode {
+			// Pre-allocated mode: the GUID is a deterministic function of
+			// (pkey, hca index, node) rather than a free GUID pulled from the pool.
+			guidAddr, err = d.LookupPredeterminedGUID(spec, networkID, pi)
+			if err != nil {
+				return fmt.Errorf("failed to lookup predetermined GUID for pod ID %s, with error: %v", pi.pod.UID, err)
+			}
+		} else {
+			guidAddr, err = d.guidPool.GenerateGUID()
+			// TODO(Nik): This error handling is funky. We sync the GUID pool but then don't
+			// re-assign a guidAddr so we're left with a 0 guid
+			if err != nil {
+				switch {
+				case errors.Is(err, guid.ErrGUIDPoolExhausted):
+					err = syncGUIDPool(d.smClient, d.guidPool)
+					if err != nil {
+						return err
+					}
+				default:
+					return fmt.Errorf("failed to generate GUID for pod ID %s, with error: %v", pi.pod.UID, err)
 				}
-			default:
-				return fmt.Errorf("failed to generate GUID for pod ID %s, with error: %v", pi.pod.UID, err)
 			}
 		}
 
@@ -540,6 +551,73 @@ func (d *daemon) processNetworkGUID(networkID string, spec *utils.IbSriovCniSpec
 	return nil
 }
 
+// LookupPredeterminedGUID returns the deterministic GUID for a pod's network attachment
+// in pre-allocated mode. The GUID is a pure function of the tenant pkey, the HCA (rail)
+// index, and the node the pod is scheduled on, so it never needs to be allocated or
+// tracked. Used when we are not the UFM fabric admin and GUIDs are pre-provisioned.
+func (d *daemon) LookupPredeterminedGUID(
+	spec *utils.IbSriovCniSpec, networkID string, pi *podNetworkInfo,
+) (guid.GUID, error) {
+	// pkey: the tenant partition, taken straight from the CNI spec.
+	pKey, err := utils.ParsePKey(spec.PKey)
+	if err != nil {
+		return 0, fmt.Errorf("failed to parse pkey %q: %v", spec.PKey, err)
+	}
+
+	// hca index: which rail this attachment is for, derived from the network id.
+	hcaIndex, err := hcaIndexFromNetworkID(networkID)
+	if err != nil {
+		return 0, fmt.Errorf("failed to derive hca index from networkID %q: %v", networkID, err)
+	}
+
+	// node index: the physical node the pod landed on, derived from its node name.
+	nodeName := pi.pod.Spec.NodeName
+	if nodeName == "" {
+		return 0, fmt.Errorf("pod %s is not scheduled to a node yet", pi.pod.UID)
+	}
+	nodeIndex, err := nodeIndexFromName(nodeName)
+	if err != nil {
+		return 0, fmt.Errorf("failed to derive node index from node name %q: %v", nodeName, err)
+	}
+
+	return computePredeterminedGUID(pKey, hcaIndex, nodeIndex)
+}
+
+// nodeIndexSuffixLen is the number of trailing characters of the node name that
+// encode the node index (e.g. "...-042" -> 42).
+const nodeIndexSuffixLen = 3
+
+// nodeIndexFromName derives the node index from the last nodeIndexSuffixLen
+// characters of the node name.
+func nodeIndexFromName(nodeName string) (int, error) {
+	if len(nodeName) < nodeIndexSuffixLen {
+		return 0, fmt.Errorf("node name %q is shorter than the %d-char index suffix", nodeName, nodeIndexSuffixLen)
+	}
+	suffix := nodeName[len(nodeName)-nodeIndexSuffixLen:]
+	idx, err := strconv.Atoi(suffix)
+	if err != nil {
+		return 0, fmt.Errorf("node name %q does not end in a numeric index: %v", nodeName, err)
+	}
+	return idx, nil
+}
+
+// hcaIndexFromNetworkID derives the HCA (rail) index from the trailing number of
+// the network id (e.g. "...-ib-net-3" -> 3).
+func hcaIndexFromNetworkID(networkID string) (int, error) {
+	parts := strings.Split(networkID, "-")
+	idx, err := strconv.Atoi(parts[len(parts)-1])
+	if err != nil {
+		return 0, fmt.Errorf("networkID %q does not end in a numeric rail index: %v", networkID, err)
+	}
+	return idx, nil
+}
+
+// computePredeterminedGUID maps (pkey, hca index, node index) to a deterministic GUID.
+// TODO(TCL-7011): implement the agreed deterministic hashing/encoding scheme.
+func computePredeterminedGUID(_ int, _ int, _ int) (guid.GUID, error) {
+	return 0, fmt.Errorf("computePredeterminedGUID is not yet implemented")
+}
+
 func syncGUIDPool(smClient plugins.SubnetManagerClient, guidPool guid.Pool) error {
 	usedGuids, err := smClient.ListGuidsInUse()
 	if err != nil {

pkg/daemon/daemon_test.go

@@ -844,4 +844,42 @@ var _ = Describe("Daemon", func() {
 			Expect(exists4).To(BeFalse(), "network4 should be removed from deleteMap")
 		})
 	})
+
+	Context("nodeIndexFromName", func() {
+		It("parses the trailing index from a node name", func() {
+			idx, err := nodeIndexFromName("gpu-dp-node-042")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(idx).To(Equal(42))
+		})
+		It("treats the suffix as the index even with leading zeros", func() {
+			idx, err := nodeIndexFromName("node-007")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(idx).To(Equal(7))
+		})
+		It("fails when the suffix is not numeric", func() {
+			_, err := nodeIndexFromName("gpu-dp-zsjr4-dkznf")
+			Expect(err).To(HaveOccurred())
+		})
+		It("fails when the node name is shorter than the index suffix", func() {
+			_, err := nodeIndexFromName("ab")
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Context("hcaIndexFromNetworkID", func() {
+		It("parses the trailing rail index from the network id", func() {
+			idx, err := hcaIndexFromNetworkID("ns_cluster-gpu-dp-mlnx-hca-ib-net-3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(idx).To(Equal(3))
+		})
+		It("parses a multi-digit rail index", func() {
+			idx, err := hcaIndexFromNetworkID("ns_cluster-ib-net-12")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(idx).To(Equal(12))
+		})
+		It("fails when the network id does not end in a number", func() {
+			_, err := hcaIndexFromNetworkID("ns_cluster-ib-net-foo")
+			Expect(err).To(HaveOccurred())
+		})
+	})
 })