refactor: split routeWatcher into watcher and handler components

calico-vpp-agent/cmd/calico_vpp_dataplane.go

@@ -147,6 +147,9 @@ func main() {
 	cniServer := watchers.NewCNIServer(felixServer.GetFelixServerEventChan(), log.WithFields(logrus.Fields{"component": "cni"}))
 	serviceServer := watchers.NewServiceServer(felixServer.GetFelixServerEventChan(), k8sclient, log.WithFields(logrus.Fields{"component": "services"}))
 
+	felixServer.GetRouteHandler().SetRouteWatcher(routeWatcher)
+	netWatcher.SetRouteHandler(felixServer.GetRouteHandler())
+
 	err = watchers.InstallFelixPlugin()
 	if err != nil {
 		log.Fatalf("could not install felix plugin: %s", err)

calico-vpp-agent/common/pubsub.go

@@ -27,7 +27,6 @@ const (
 	ChanSize = 500
 
 	PeerNodeStateChanged CalicoVppEventType = "PeerNodeStateChanged"
-	IpamConfChanged      CalicoVppEventType = "IpamConfChanged"
 	BGPConfChanged       CalicoVppEventType = "BGPConfChanged"
 
 	ConnectivityAdded   CalicoVppEventType = "ConnectivityAdded"
@@ -61,7 +60,6 @@ const (
 
 	NetAddedOrUpdated CalicoVppEventType = "NetAddedOrUpdated"
 	NetDeleted        CalicoVppEventType = "NetDeleted"
-	NetsSynced        CalicoVppEventType = "NetsSynced"
 
 	IpamPoolUpdate CalicoVppEventType = "IpamPoolUpdate"
 	IpamPoolRemove CalicoVppEventType = "IpamPoolRemove"

calico-vpp-agent/felix/felix_server.go

@@ -59,6 +59,7 @@ type Server struct {
 	cniHandler          *cni.CNIHandler
 	connectivityHandler *connectivity.ConnectivityHandler
 	serviceHandler      *services.ServiceHandler
+	routeHandler        *RouteHandler
 }
 
 // NewFelixServer creates a felix server
@@ -77,6 +78,7 @@ func NewFelixServer(vpp *vpplink.VppLink, clientv3 calicov3cli.Interface, log *l
 		cniHandler:          cni.NewCNIHandler(vpp, cache, log),
 		connectivityHandler: connectivity.NewConnectivityHandler(vpp, cache, clientv3, log),
 		serviceHandler:      services.NewServiceHandler(vpp, cache, log),
+		routeHandler:        NewRouteHandler(log),
 	}
 
 	reg := common.RegisterHandler(server.felixServerEventChan, "felix server events")
@@ -96,6 +98,10 @@ func NewFelixServer(vpp *vpplink.VppLink, clientv3 calicov3cli.Interface, log *l
 	return server
 }
 
+func (s *Server) GetRouteHandler() *RouteHandler {
+	return s.routeHandler
+}
+
 func (s *Server) GetFelixServerEventChan() chan any {
 	return s.felixServerEventChan
 }

calico-vpp-agent/felix/ipam.go

@@ -21,8 +21,6 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/projectcalico/calico/felix/proto"
-
-	"github.com/projectcalico/vpp-dataplane/v3/calico-vpp-agent/common"
 )
 
 func (s *Server) handleIpamPoolUpdate(msg *proto.IPAMPoolUpdate) (err error) {
@@ -49,11 +47,12 @@ func (s *Server) handleIpamPoolUpdate(msg *proto.IPAMPoolUpdate) (err error) {
 			}
 			s.connectivityHandler.OnIpamConfChanged(oldIpamPool, newIpamPool)
 			s.cniHandler.OnIpamConfChanged(oldIpamPool, newIpamPool)
-			common.SendEvent(common.CalicoVppEvent{
-				Type: common.IpamConfChanged,
-				Old:  ipamPoolCopy(oldIpamPool),
-				New:  ipamPoolCopy(newIpamPool),
-			})
+			if s.routeHandler != nil {
+				err := s.routeHandler.OnIpamConfChanged(oldIpamPool, newIpamPool)
+				if err != nil {
+					s.log.Errorf("Failed to handle IPAM update in RouteHandler: %v", err)
+				}
+			}
 		}
 	} else {
 		s.log.Infof("Adding pool: %s, nat:%t", msg.GetId(), newIpamPool.GetMasquerade())
@@ -65,10 +64,12 @@ func (s *Server) handleIpamPoolUpdate(msg *proto.IPAMPoolUpdate) (err error) {
 		}
 		s.connectivityHandler.OnIpamConfChanged(nil /*old*/, newIpamPool)
 		s.cniHandler.OnIpamConfChanged(nil /*old*/, newIpamPool)
-		common.SendEvent(common.CalicoVppEvent{
-			Type: common.IpamConfChanged,
-			New:  ipamPoolCopy(newIpamPool),
-		})
+		if s.routeHandler != nil {
+			err := s.routeHandler.OnIpamConfChanged(nil, newIpamPool)
+			if err != nil {
+				s.log.Errorf("Failed to handle IPAM addition in RouteHandler: %v", err)
+			}
+		}
 	}
 	return nil
 }
@@ -88,13 +89,14 @@ func (s *Server) handleIpamPoolRemove(msg *proto.IPAMPoolRemove) (err error) {
 		if err != nil {
 			return errors.Wrap(err, "error handling ipam deletion")
 		}
-		common.SendEvent(common.CalicoVppEvent{
-			Type: common.IpamConfChanged,
-			Old:  ipamPoolCopy(oldIpamPool),
-			New:  nil,
-		})
 		s.connectivityHandler.OnIpamConfChanged(oldIpamPool, nil /* new */)
 		s.cniHandler.OnIpamConfChanged(oldIpamPool, nil /* new */)
+		if s.routeHandler != nil {
+			err := s.routeHandler.OnIpamConfChanged(oldIpamPool, nil)
+			if err != nil {
+				s.log.Errorf("Failed to handle IPAM deletion in RouteHandler: %v", err)
+			}
+		}
 	} else {
 		s.log.Warnf("Deleting unknown ippool")
 		return nil

calico-vpp-agent/felix/route_handler.go

@@ -0,0 +1,149 @@
+// Copyright (C) 2025 Cisco Systems Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+// implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package felix
+
+import (
+	"net"
+	"syscall"
+
+	"github.com/pkg/errors"
+	"github.com/projectcalico/calico/felix/proto"
+	"github.com/sirupsen/logrus"
+	"github.com/vishvananda/netlink"
+
+	"github.com/projectcalico/vpp-dataplane/v3/calico-vpp-agent/common"
+	"github.com/projectcalico/vpp-dataplane/v3/calico-vpp-agent/watchers"
+)
+
+// RouteHandler handles network and IPAM events by updating VPP routing configuration
+type RouteHandler struct {
+	log          *logrus.Entry
+	routeWatcher *watchers.RouteWatcher
+}
+
+// NewRouteHandler creates a new RouteHandler instance
+func NewRouteHandler(log *logrus.Entry) *RouteHandler {
+	return &RouteHandler{
+		log:          log,
+		routeWatcher: nil,
+	}
+}
+
+// SetRouteWatcher sets the route watcher for performing route operations
+func (h *RouteHandler) SetRouteWatcher(routeWatcher *watchers.RouteWatcher) {
+	h.routeWatcher = routeWatcher
+}
+
+// OnNetDeleted handles network deletion events
+func (h *RouteHandler) OnNetDeleted(netDef *common.NetworkDefinition) error {
+	key := netDef.Range
+	routes, err := h.getNetworkRoute(key, netDef.PhysicalNetworkName)
+	if err != nil {
+		h.log.Errorf("Error getting route from network deletion: %v", err)
+		return err
+	}
+	for _, route := range routes {
+		err = h.routeWatcher.DelRoute(route)
+		if err != nil {
+			h.log.Errorf("Cannot delete pool route %s through vpp tap: %v", key, err)
+			return err
+		}
+	}
+	return nil
+}
+
+// OnNetAddedOrUpdated handles network addition/update events
+func (h *RouteHandler) OnNetAddedOrUpdated(netDef *common.NetworkDefinition) error {
+	key := netDef.Range
+	routes, err := h.getNetworkRoute(key, netDef.PhysicalNetworkName)
+	if err != nil {
+		h.log.Errorf("Error getting route from network addition/update: %v", err)
+		return err
+	}
+	for _, route := range routes {
+		err = h.routeWatcher.AddRoute(route)
+		if err != nil {
+			h.log.Errorf("Cannot add pool route %s through vpp tap: %v", key, err)
+			return err
+		}
+	}
+	return nil
+}
+
+// OnIpamConfChanged handles IPAM configuration changes
+func (h *RouteHandler) OnIpamConfChanged(oldPool, newPool *proto.IPAMPool) error {
+	h.log.Debugf("Received IPAM config update in route handler old:%+v new:%+v", oldPool, newPool)
+	if newPool == nil && oldPool != nil {
+		routes, err := h.getNetworkRoute(oldPool.Cidr, "")
+		if err != nil {
+			h.log.Errorf("Error getting route from ipam update: %v", err)
+			return err
+		}
+		for _, route := range routes {
+			err = h.routeWatcher.DelRoute(route)
+			if err != nil {
+				h.log.Errorf("Cannot delete pool route %s through vpp tap: %v", oldPool.Cidr, err)
+				return err
+			}
+		}
+	} else if newPool != nil {
+		routes, err := h.getNetworkRoute(newPool.Cidr, "")
+		if err != nil {
+			h.log.Errorf("Error getting route from ipam update: %v", err)
+			return err
+		}
+		for _, route := range routes {
+			err = h.routeWatcher.AddRoute(route)
+			if err != nil {
+				h.log.Errorf("Cannot add pool route %s through vpp tap: %v", newPool.Cidr, err)
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (h *RouteHandler) getNetworkRoute(network string, physicalNet string) (route []*netlink.Route, err error) {
+	_, cidr, err := net.ParseCIDR(network)
+	if err != nil {
+		return nil, errors.Wrapf(err, "error parsing %s", network)
+	}
+	var routes []*netlink.Route
+	var order int
+	for _, uplinkStatus := range common.VppManagerInfo.UplinkStatuses {
+		if uplinkStatus.PhysicalNetworkName == physicalNet {
+			gw := uplinkStatus.FakeNextHopIP4
+			if cidr.IP.To4() == nil {
+				gw = uplinkStatus.FakeNextHopIP6
+			}
+			var priority int
+			if uplinkStatus.IsMain {
+				priority = 0
+			} else {
+				order += 1
+				priority = order
+			}
+			routes = append(routes, &netlink.Route{
+				Dst:      cidr,
+				Gw:       gw,
+				Protocol: syscall.RTPROT_STATIC,
+				MTU:      watchers.GetUplinkMtu(),
+				Priority: priority,
+			})
+		}
+	}
+	return routes, nil
+}