Add specific interface for GetActiveNetworkForNamespace

Signed-off-by: Jaime Caamaño Ruiz <[email protected]>

go-controller/pkg/clustermanager/endpointslicemirror/endpointslice_mirror_controller.go

@@ -43,7 +43,7 @@ type Controller struct {
 	endpointSlicesSynced cache.InformerSynced
 	podLister            corelisters.PodLister
 	podsSynced           cache.InformerSynced
-	nadController        networkAttachDefController.NADController
+	networkManager       networkAttachDefController.NetworkManager
 	cancel               context.CancelFunc
 }
 
@@ -111,14 +111,14 @@ func (c *Controller) onEndpointSliceAdd(obj interface{}) {
 
 func NewController(
 	ovnClient *util.OVNClusterManagerClientset,
-	wf *factory.WatchFactory, nadController networkAttachDefController.NADController) (*Controller, error) {
+	wf *factory.WatchFactory, networkManager networkAttachDefController.NetworkManager) (*Controller, error) {
 
 	wg := &sync.WaitGroup{}
 	c := &Controller{
-		kubeClient:    ovnClient.KubeClient,
-		wg:            wg,
-		name:          types.EndpointSliceMirrorControllerName,
-		nadController: nadController,
+		kubeClient:     ovnClient.KubeClient,
+		wg:             wg,
+		name:           types.EndpointSliceMirrorControllerName,
+		networkManager: networkManager,
 	}
 
 	c.queue = workqueue.NewTypedRateLimitingQueueWithConfig(
@@ -244,7 +244,7 @@ func (c *Controller) syncDefaultEndpointSlice(ctx context.Context, key string) e
 		return err
 	}
 
-	namespacePrimaryNetwork, err := c.nadController.GetActiveNetworkForNamespace(namespace)
+	namespacePrimaryNetwork, err := c.networkManager.GetActiveNetworkForNamespace(namespace)
 	if err != nil {
 		return err
 	}

go-controller/pkg/clustermanager/endpointslicemirror/endpointslice_mirror_controller_test.go

@@ -17,20 +17,18 @@ import (
 
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/config"
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/factory"
-	nad "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/network-attach-def-controller"
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/testing"
-	kubetest "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/testing"
 	fakenad "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/testing/nad"
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/types"
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/util"
 )
 
 var _ = ginkgo.Describe("Cluster manager EndpointSlice mirror controller", func() {
 	var (
-		app           *cli.App
-		controller    *Controller
-		fakeClient    *util.OVNClusterManagerClientset
-		nadController nad.NADController
+		app                *cli.App
+		controller         *Controller
+		fakeClient         *util.OVNClusterManagerClientset
+		fakeNetworkManager fakenad.FakeNetworkManager
 	)
 
 	start := func(objects ...runtime.Object) {
@@ -40,17 +38,13 @@ var _ = ginkgo.Describe("Cluster manager EndpointSlice mirror controller", func(
 		fakeClient = util.GetOVNClientset(objects...).GetClusterManagerClientset()
 		wf, err := factory.NewClusterManagerWatchFactory(fakeClient)
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
-		nadController, err = nad.NewClusterNADController("test", &fakenad.FakeNetworkControllerManager{}, wf, nil)
-		gomega.Expect(err).NotTo(gomega.HaveOccurred())
-		controller, err = NewController(fakeClient, wf, nadController)
+		fakeNetworkManager = fakenad.FakeNetworkManager{}
+		controller, err = NewController(fakeClient, wf, &fakeNetworkManager)
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		err = wf.Start()
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-		err = nadController.Start()
-		gomega.Expect(err).NotTo(gomega.HaveOccurred())
-
 		err = controller.Start(context.Background(), 1)
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 	}
@@ -70,9 +64,7 @@ var _ = ginkgo.Describe("Cluster manager EndpointSlice mirror controller", func(
 		if controller != nil {
 			controller.Stop()
 		}
-		if nadController != nil {
-			nadController.Stop()
-		}
+		fakeNetworkManager.PrimaryNetworks = map[string]util.NetInfo{}
 	})
 
 	ginkgo.Context("on startup repair", func() {
@@ -108,7 +100,7 @@ var _ = ginkgo.Describe("Cluster manager EndpointSlice mirror controller", func(
 						},
 					},
 				}
-				staleEndpointSlice := kubetest.MirrorEndpointSlice(&defaultEndpointSlice, "l3-network", false)
+				staleEndpointSlice := testing.MirrorEndpointSlice(&defaultEndpointSlice, "l3-network", false)
 				staleEndpointSlice.Labels[types.LabelSourceEndpointSlice] = "non-existing-endpointslice"
 
 				objs := []runtime.Object{
@@ -133,12 +125,10 @@ var _ = ginkgo.Describe("Cluster manager EndpointSlice mirror controller", func(
 				start(objs...)
 
 				nad := testing.GenerateNAD("l3-network", "l3-network", namespaceT.Name, types.Layer3Topology, "10.132.2.0/16/24", types.NetworkRolePrimary)
-
-				_, err := fakeClient.NetworkAttchDefClient.K8sCniCncfIoV1().NetworkAttachmentDefinitions(namespaceT.Name).Create(
-					context.TODO(),
-					nad,
-					metav1.CreateOptions{})
+				netInfo, err := util.ParseNADInfo(nad)
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
+				netInfo.SetNADs(nad.Namespace + "/" + nad.Name)
+				fakeNetworkManager.PrimaryNetworks = map[string]util.NetInfo{"testns": netInfo}
 
 				var mirroredEndpointSlices *discovery.EndpointSliceList
 				gomega.Eventually(func() error {
@@ -314,7 +304,7 @@ var _ = ginkgo.Describe("Cluster manager EndpointSlice mirror controller", func(
 						},
 					},
 				}
-				mirroredEndpointSlice := kubetest.MirrorEndpointSlice(&defaultEndpointSlice, "l3-network", false)
+				mirroredEndpointSlice := testing.MirrorEndpointSlice(&defaultEndpointSlice, "l3-network", false)
 				objs := []runtime.Object{
 					&v1.PodList{
 						Items: []v1.Pod{
@@ -337,20 +327,13 @@ var _ = ginkgo.Describe("Cluster manager EndpointSlice mirror controller", func(
 				start(objs...)
 
 				nad := testing.GenerateNAD("l3-network", "l3-network", namespaceT.Name, types.Layer3Topology, "10.132.2.0/16/24", types.NetworkRolePrimary)
-				_, err := fakeClient.NetworkAttchDefClient.K8sCniCncfIoV1().NetworkAttachmentDefinitions(namespaceT.Name).Create(
-					context.TODO(),
-					nad,
-					metav1.CreateOptions{})
+				netInfo, err := util.ParseNADInfo(nad)
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
+				netInfo.SetNADs(nad.Namespace + "/" + nad.Name)
+				fakeNetworkManager.PrimaryNetworks = map[string]util.NetInfo{"testns": netInfo}
 
 				var mirroredEndpointSlices *discovery.EndpointSliceList
 				gomega.Eventually(func() error {
-					// nad should exist
-					_, err := fakeClient.NetworkAttchDefClient.K8sCniCncfIoV1().NetworkAttachmentDefinitions(namespaceT.Name).Get(context.TODO(), "l3-network", metav1.GetOptions{})
-					if err != nil {
-						return err
-					}
-
 					// defaultEndpointSlice should exist
 					_, err = fakeClient.KubeClient.DiscoveryV1().EndpointSlices(namespaceT.Name).Get(context.TODO(), defaultEndpointSlice.Name, metav1.GetOptions{})
 					if err != nil {

go-controller/pkg/clustermanager/fake_cluster_manager_test.go

@@ -16,8 +16,8 @@ import (
 	egresssvc "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/crd/egressservice/v1"
 	egresssvcfake "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/crd/egressservice/v1/apis/clientset/versioned/fake"
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/factory"
-	nad "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/network-attach-def-controller"
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/ovn/healthcheck"
+	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/testing/nad"
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/util"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/kubernetes/fake"
@@ -90,9 +90,8 @@ func (o *FakeClusterManager) init() {
 		gomega.Expect(err).ToNot(gomega.HaveOccurred())
 	}
 	if util.IsNetworkSegmentationSupportEnabled() {
-		nadController, err := nad.NewClusterNADController("test", nil, o.watcher, nil)
-		gomega.Expect(err).NotTo(gomega.HaveOccurred())
-		o.epsMirror, err = endpointslicemirror.NewController(o.fakeClient, o.watcher, nadController)
+		fakeNetworkManager := &nad.FakeNetworkManager{}
+		o.epsMirror, err = endpointslicemirror.NewController(o.fakeClient, o.watcher, fakeNetworkManager)
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		err = o.epsMirror.Start(context.TODO(), 1)

go-controller/pkg/clustermanager/network_cluster_controller.go

@@ -62,15 +62,15 @@ type networkClusterController struct {
 	ipamClaimReconciler *persistentips.IPAMClaimReconciler
 	subnetAllocator     subnet.Allocator
 
-	nadController networkAttachDefController.NADController
+	networkManager networkAttachDefController.NetworkManager
 
 	// event recorder used to post events to k8s
 	recorder record.EventRecorder
 
 	util.NetInfo
 }
 
-func newNetworkClusterController(networkIDAllocator idallocator.NamedAllocator, netInfo util.NetInfo, ovnClient *util.OVNClusterManagerClientset, wf *factory.WatchFactory, recorder record.EventRecorder, nadController networkAttachDefController.NADController) *networkClusterController {
+func newNetworkClusterController(networkIDAllocator idallocator.NamedAllocator, netInfo util.NetInfo, ovnClient *util.OVNClusterManagerClientset, wf *factory.WatchFactory, recorder record.EventRecorder, networkManager networkAttachDefController.NADController) *networkClusterController {
 	kube := &kube.KubeOVN{
 		Kube: kube.Kube{
 			KClient: ovnClient.KubeClient,
@@ -88,7 +88,7 @@ func newNetworkClusterController(networkIDAllocator idallocator.NamedAllocator,
 		wg:                 wg,
 		networkIDAllocator: networkIDAllocator,
 		recorder:           recorder,
-		nadController:      nadController,
+		networkManager:     networkManager,
 	}
 
 	return ncc
@@ -193,7 +193,7 @@ func (ncc *networkClusterController) init() error {
 		)
 
 		ncc.podAllocator = pod.NewPodAllocator(ncc.NetInfo, podAllocationAnnotator, ipAllocator,
-			ipamClaimsReconciler, ncc.nadController, ncc.recorder)
+			ipamClaimsReconciler, ncc.networkManager, ncc.recorder)
 		if err := ncc.podAllocator.Init(); err != nil {
 			return fmt.Errorf("failed to initialize pod ip allocator: %w", err)
 		}

go-controller/pkg/clustermanager/pod/allocator.go

@@ -41,7 +41,7 @@ type PodAllocator struct {
 
 	ipamClaimsReconciler persistentips.PersistentAllocations
 
-	nadController nad.NADController
+	networkManager nad.NetworkManager
 
 	// event recorder used to post events to k8s
 	recorder record.EventRecorder
@@ -58,15 +58,15 @@ func NewPodAllocator(
 	podAnnotationAllocator *pod.PodAnnotationAllocator,
 	ipAllocator subnet.Allocator,
 	claimsReconciler persistentips.PersistentAllocations,
-	nadController nad.NADController,
+	networkManager nad.NetworkManager,
 	recorder record.EventRecorder,
 ) *PodAllocator {
 	podAllocator := &PodAllocator{
 		netInfo:                netInfo,
 		releasedPods:           map[string]sets.Set[string]{},
 		releasedPodsMutex:      sync.Mutex{},
 		podAnnotationAllocator: podAnnotationAllocator,
-		nadController:          nadController,
+		networkManager:         networkManager,
 		recorder:               recorder,
 	}
 
@@ -109,7 +109,7 @@ func (a *PodAllocator) Init() error {
 // getActiveNetworkForNamespace returns the active network for the given pod's namespace
 // and is a wrapper around GetActiveNetworkForNamespace
 func (a *PodAllocator) getActiveNetworkForPod(pod *corev1.Pod) (util.NetInfo, error) {
-	activeNetwork, err := a.nadController.GetActiveNetworkForNamespace(pod.Namespace)
+	activeNetwork, err := a.networkManager.GetActiveNetworkForNamespace(pod.Namespace)
 	if err != nil {
 		if util.IsUnprocessedActiveNetworkError(err) {
 			a.recordPodErrorEvent(pod, err)

go-controller/pkg/clustermanager/pod/allocator_test.go

@@ -592,7 +592,7 @@ func TestPodAllocator_reconcileForNAD(t *testing.T) {
 				}
 			}
 
-			nadController := &nad.FakeNADController{PrimaryNetworks: nadNetworks}
+			fakeNetworkManager := &nad.FakeNetworkManager{PrimaryNetworks: nadNetworks}
 
 			fakeRecorder := record.NewFakeRecorder(10)
 
@@ -608,7 +608,7 @@ func TestPodAllocator_reconcileForNAD(t *testing.T) {
 				releasedPodsMutex:      sync.Mutex{},
 				ipamClaimsReconciler:   ipamClaimsReconciler,
 				recorder:               fakeRecorder,
-				nadController:          nadController,
+				networkManager:         fakeNetworkManager,
 			}
 
 			var old, new *corev1.Pod

go-controller/pkg/cni/cni.go

@@ -107,11 +107,11 @@ func (pr *PodRequest) checkOrUpdatePodUID(pod *kapi.Pod) error {
 }
 
 func (pr *PodRequest) cmdAdd(kubeAuth *KubeAPIAuth, clientset *ClientSet,
-	nadController nad.NADController) (*Response, error) {
-	return pr.cmdAddWithGetCNIResultFunc(kubeAuth, clientset, getCNIResult, nadController)
+	networkManager nad.NetworkManager) (*Response, error) {
+	return pr.cmdAddWithGetCNIResultFunc(kubeAuth, clientset, getCNIResult, networkManager)
 }
 func (pr *PodRequest) cmdAddWithGetCNIResultFunc(kubeAuth *KubeAPIAuth, clientset *ClientSet,
-	getCNIResultFn getCNIResultFunc, nadController nad.NADController) (*Response, error) {
+	getCNIResultFn getCNIResultFunc, networkManager nad.NetworkManager) (*Response, error) {
 	namespace := pr.PodNamespace
 	podName := pr.PodName
 	if namespace == "" || podName == "" {
@@ -144,7 +144,7 @@ func (pr *PodRequest) cmdAddWithGetCNIResultFunc(kubeAuth *KubeAPIAuth, clientse
 	// Get the IP address and MAC address of the pod
 	// for DPU, ensure connection-details is present
 
-	primaryUDN := udn.NewPrimaryNetwork(nadController)
+	primaryUDN := udn.NewPrimaryNetwork(networkManager)
 	if util.IsNetworkSegmentationSupportEnabled() {
 		annotCondFn = primaryUDN.WaitForPrimaryAnnotationFn(namespace, annotCondFn)
 	}
@@ -293,15 +293,15 @@ func (pr *PodRequest) cmdCheck() error {
 // Argument '*PodRequest' encapsulates all the necessary information
 // kclient is passed in so that clientset can be reused from the server
 // Return value is the actual bytes to be sent back without further processing.
-func HandlePodRequest(request *PodRequest, clientset *ClientSet, kubeAuth *KubeAPIAuth, nadController nad.NADController) ([]byte, error) {
+func HandlePodRequest(request *PodRequest, clientset *ClientSet, kubeAuth *KubeAPIAuth, networkManager nad.NetworkManager) ([]byte, error) {
 	var result, resultForLogging []byte
 	var response *Response
 	var err, err1 error
 
 	klog.Infof("%s %s starting CNI request %+v", request, request.Command, request)
 	switch request.Command {
 	case CNIAdd:
-		response, err = request.cmdAdd(kubeAuth, clientset, nadController)
+		response, err = request.cmdAdd(kubeAuth, clientset, networkManager)
 	case CNIDel:
 		response, err = request.cmdDel(clientset)
 	case CNICheck:

go-controller/pkg/cni/cni_test.go

@@ -57,7 +57,7 @@ var _ = Describe("Network Segmentation", func() {
 		}
 		prInterfaceOpsStub                            = &podRequestInterfaceOpsStub{}
 		enableMultiNetwork, enableNetworkSegmentation bool
-		nadController                                 *ovntest.FakeNADController
+		fakeNetworkManager                            *ovntest.FakeNetworkManager
 	)
 
 	BeforeEach(func() {
@@ -153,13 +153,13 @@ var _ = Describe("Network Segmentation", func() {
 						},
 					},
 				}
-				nadController = &ovntest.FakeNADController{
+				fakeNetworkManager = &ovntest.FakeNetworkManager{
 					PrimaryNetworks: make(map[string]util.NetInfo),
 				}
 			})
 			It("should not fail at cmdAdd", func() {
 				podNamespaceLister.On("Get", pr.PodName).Return(pod, nil)
-				Expect(pr.cmdAddWithGetCNIResultFunc(kubeAuth, clientSet, getCNIResultStub, nadController)).NotTo(BeNil())
+				Expect(pr.cmdAddWithGetCNIResultFunc(kubeAuth, clientSet, getCNIResultStub, fakeNetworkManager)).NotTo(BeNil())
 				Expect(obtainedPodIterfaceInfos).ToNot(BeEmpty())
 			})
 			It("should not fail at cmdDel", func() {
@@ -233,16 +233,16 @@ var _ = Describe("Network Segmentation", func() {
 				nadLister.On("NetworkAttachmentDefinitions", "foo-ns").Return(nadNamespaceLister)
 				nadNetwork, err := util.ParseNADInfo(nad)
 				Expect(err).NotTo(HaveOccurred())
-				nadController = &ovntest.FakeNADController{
+				fakeNetworkManager = &ovntest.FakeNetworkManager{
 					PrimaryNetworks: make(map[string]util.NetInfo),
 				}
-				nadController.PrimaryNetworks[nad.Namespace] = nadNetwork
+				fakeNetworkManager.PrimaryNetworks[nad.Namespace] = nadNetwork
 				getCNIResultStub = dummyGetCNIResult
 			})
 
 			It("should return the information of both the default net and the primary UDN in the result", func() {
 				podNamespaceLister.On("Get", pr.PodName).Return(pod, nil)
-				response, err := pr.cmdAddWithGetCNIResultFunc(kubeAuth, clientSet, getCNIResultStub, nadController)
+				response, err := pr.cmdAddWithGetCNIResultFunc(kubeAuth, clientSet, getCNIResultStub, fakeNetworkManager)
 				Expect(err).NotTo(HaveOccurred())
 				// for every interface added, we return 2 interfaces; the host side of the
 				// veth, then the pod side of the veth.

go-controller/pkg/cni/cniserver.go

@@ -50,7 +50,7 @@ import (
 
 // NewCNIServer creates and returns a new Server object which will listen on a socket in the given path
 func NewCNIServer(factory factory.NodeWatchFactory, kclient kubernetes.Interface,
-	nadController nad.NADController) (*Server, error) {
+	networkManager nad.NetworkManager) (*Server, error) {
 	if config.OvnKubeNode.Mode == types.NodeModeDPU {
 		return nil, fmt.Errorf("unsupported ovnkube-node mode for CNI server: %s", config.OvnKubeNode.Mode)
 	}
@@ -75,7 +75,7 @@ func NewCNIServer(factory factory.NodeWatchFactory, kclient kubernetes.Interface
 	}
 
 	if util.IsNetworkSegmentationSupportEnabled() {
-		s.nadController = nadController
+		s.networkManager = networkManager
 	}
 
 	if len(config.Kubernetes.CAData) > 0 {
@@ -221,7 +221,7 @@ func (s *Server) handleCNIRequest(r *http.Request) ([]byte, error) {
 	}
 	defer req.cancel()
 
-	result, err := s.handlePodRequestFunc(req, s.clientSet, s.kubeAuth, s.nadController)
+	result, err := s.handlePodRequestFunc(req, s.clientSet, s.kubeAuth, s.networkManager)
 	if err != nil {
 		// Prefix error with request information for easier debugging
 		return nil, fmt.Errorf("%s %v", req, err)

go-controller/pkg/cni/cniserver_test.go

@@ -49,7 +49,7 @@ func clientDoCNI(t *testing.T, client *http.Client, req *Request) ([]byte, int)
 
 var expectedResult cnitypes.Result
 
-func serverHandleCNI(request *PodRequest, clientset *ClientSet, kubeAuth *KubeAPIAuth, nadController nad.NADController) ([]byte, error) {
+func serverHandleCNI(request *PodRequest, clientset *ClientSet, kubeAuth *KubeAPIAuth, networkManager nad.NetworkManager) ([]byte, error) {
 	if request.Command == CNIAdd {
 		return json.Marshal(&expectedResult)
 	} else if request.Command == CNIDel || request.Command == CNIUpdate || request.Command == CNICheck {