Fix: Ensure prompt initial DHCP cache sync on agent startup

This commit addresses a potential delay in the agent's DHCP lease cache
synchronization upon startup or leader election. Previously, the cache might
only populate after an explicit update to the watched IPPool CR.

Changes:
- Added an `AddFunc` to the IPPool informer in the agent's event handler
  (`pkg/agent/ippool/event.go`). This ensures that IPPools listed during
  the informer's initial LIST operation are queued for processing.
- Modified the agent's local IPPool controller (`pkg/agent/ippool/controller.go`)
  to handle these "ADD" events identically to "UPDATE" events. This involves
  calling the `Update` method to populate the DHCPAllocator's cache and then
  signaling on the `initialSyncDone` channel.

These changes ensure that the agent primes its lease cache as soon as the
IPPool information is available from the informer, allowing the DHCP server
to start with accurate lease data more promptly.

Author: google-labs-jules[bot]

pkg/agent/ippool/controller.go

@@ -85,21 +85,29 @@ func (c *Controller) sync(event Event) (err error) {
 	}
 
 	switch event.action {
-	case UPDATE:
+	case ADD, UPDATE: // Handle ADD and UPDATE identically for cache priming
 		ipPool, ok := obj.(*networkv1.IPPool)
 		if !ok {
-			logrus.Error("(controller.sync) failed to assert obj during UPDATE")
+			logrus.Errorf("(controller.sync) failed to assert obj during %s event for key %s", event.action, event.key)
+			return nil // Don't requeue if type assertion fails
 		}
-		logrus.Infof("(controller.sync) UPDATE %s/%s", ipPool.Namespace, ipPool.Name)
+		logrus.Infof("(controller.sync) %s %s/%s", event.action, ipPool.Namespace, ipPool.Name)
 		if err := c.Update(ipPool); err != nil {
-			logrus.Errorf("(controller.sync) failed to update DHCP lease store for IPPool %s/%s: %s", ipPool.Namespace, ipPool.Name, err.Error())
+			logrus.Errorf("(controller.sync) failed to update DHCP lease store for IPPool %s/%s during %s event: %s", ipPool.Namespace, ipPool.Name, event.action, err.Error())
 			return err // Return error to requeue
 		}
 		// If update was successful, this is a good place to signal initial sync
+		// This will be called for the first ADD or UPDATE event that successfully processes.
 		c.initialSyncOnce.Do(func() {
-			logrus.Infof("Initial sync completed for IPPool %s/%s, signaling DHCP server.", ipPool.Namespace, ipPool.Name)
+			logrus.Infof("Initial sync processing completed for IPPool %s/%s (triggered by %s event), signaling DHCP server.", ipPool.Namespace, ipPool.Name, event.action)
 			close(c.initialSyncDone)
 		})
+	// Potentially handle DELETE if needed in the future
+	// case DELETE:
+	// logrus.Infof("(controller.sync) DELETE %s", event.key)
+	// // Perform cleanup if necessary, e.g., clearing leases from dhcpAllocator
+	// // if this agent is supposed to stop serving this pool.
+	// // However, for a single watched IPPool, deletion might mean the agent has no work.
 	}
 
 	return

pkg/agent/ippool/event.go

@@ -105,17 +105,34 @@ func (e *EventHandler) EventListener(ctx context.Context) {
 	queue := workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter())
 
 	indexer, informer := cache.NewIndexerInformer(watcher, &networkv1.IPPool{}, 0, cache.ResourceEventHandlerFuncs{
+		AddFunc: func(obj interface{}) {
+			key, err := cache.MetaNamespaceKeyFunc(obj)
+			if err == nil {
+				ipPool := obj.(*networkv1.IPPool)
+				queue.Add(Event{
+					key:             key,
+					action:          ADD, // Use ADD action
+					poolName:        ipPool.ObjectMeta.Name,
+					poolNetworkName: ipPool.Spec.NetworkName,
+				})
+				logrus.Debugf("(eventhandler.EventListener) AddFunc: Queued ADD event for IPPool %s", key)
+			}
+		},
 		UpdateFunc: func(old interface{}, new interface{}) {
 			key, err := cache.MetaNamespaceKeyFunc(new)
 			if err == nil {
+				ipPool := new.(*networkv1.IPPool)
 				queue.Add(Event{
 					key:             key,
 					action:          UPDATE,
-					poolName:        new.(*networkv1.IPPool).ObjectMeta.Name,
-					poolNetworkName: new.(*networkv1.IPPool).Spec.NetworkName,
+					poolName:        ipPool.ObjectMeta.Name,
+					poolNetworkName: ipPool.Spec.NetworkName,
 				})
+				logrus.Debugf("(eventhandler.EventListener) UpdateFunc: Queued UPDATE event for IPPool %s", key)
 			}
 		},
+		// Consider adding DeleteFunc if agent needs to react to IPPool deletion,
+		// though for a single watched IPPool, this might mean the agent stops.
 	}, cache.Indexers{})
 
 	controller := NewController(queue, indexer, informer, e.poolRef, e.dhcpAllocator, e.poolCache, e.InitialSyncDone, &e.initialSyncOnce)