Add GetActiveNetworkForNamespaceFast to network manager

GetActiveNetworkForNamespaceFast returns the primary network for the
namespace if any or the default network otherwise. It is faster than
GetActiveNetworkForNamespace because it does not copy the network and it
does not verify against UDNs. To be used by controllers capable of
reconciling primary network changes.

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

Author: jcaamano

go-controller/pkg/networkmanager/api.go

@@ -20,8 +20,22 @@ const (
 // Interface is the main package entrypoint and provides network related
 // information to the rest of the project.
 type Interface interface {
+	// GetActiveNetworkForNamespace returns a copy of the primary network for
+	// the namespace if any or the default network otherwise. If there is a
+	// primary UDN defined but the NAD has not been processed yet, returns
+	// ErrNetworkControllerTopologyNotManaged. Used for controllers that are not
+	// capable of reconciling primary network changes. If unsure, use this one
+	// and not GetActiveNetworkForNamespaceFast.
 	GetActiveNetworkForNamespace(namespace string) (util.NetInfo, error)
 
+	// GetActiveNetworkForNamespaceFast returns the primary network for the
+	// namespace if any or the default network otherwise. It is faster than
+	// GetActiveNetworkForNamespace because it does not copy the network and it
+	// does not verify against UDNs. However, it is recommended to be used only
+	// by controllers capable of reconciling primary network changes. If unsure,
+	// use GetActiveNetworkForNamespace.
+	GetActiveNetworkForNamespaceFast(namespace string) util.NetInfo
+
 	// GetNetwork returns the network of the given name or nil if unknown
 	GetNetwork(name string) util.NetInfo
 
@@ -171,6 +185,10 @@ func (nm defaultNetworkManager) GetActiveNetworkForNamespace(string) (util.NetIn
 	return &util.DefaultNetInfo{}, nil
 }
 
+func (nm defaultNetworkManager) GetActiveNetworkForNamespaceFast(string) util.NetInfo {
+	return &util.DefaultNetInfo{}
+}
+
 func (nm defaultNetworkManager) GetNetwork(name string) util.NetInfo {
 	if name != types.DefaultNetworkName {
 		return nil

go-controller/pkg/networkmanager/nad_controller.go

@@ -70,7 +70,7 @@ type nadController struct {
 	// nads to network mapping
 	nads map[string]string
 
-	// primaryNADs holds a mapping of namespace to primary NAD names
+	// primaryNADs holds a mapping of namespace to NAD of primary UDNs
 	primaryNADs map[string]string
 
 	networkIDAllocator id.Allocator
@@ -425,26 +425,15 @@ func (c *nadController) GetActiveNetworkForNamespace(namespace string) (util.Net
 		return &util.DefaultNetInfo{}, nil
 	}
 
-	c.RLock()
-	defer c.RUnlock()
-	primaryNAD := c.primaryNADs[namespace]
-	if primaryNAD != "" {
-		// we have a primary NAD, no need to check for NS UDN annotation because NAD would not have existed otherwise
-		// get the network
-		netName := c.nads[primaryNAD]
-		if netName == "" {
-			// this should never happen where we have a nad keyed in the primaryNADs
-			// map, but it doesn't exist in the nads map
-			panic("NAD Controller broken consistency between primary NADs and cached NADs")
-		}
-		network := c.networkController.getNetwork(netName)
-		n := util.NewMutableNetInfo(network)
-		// update the returned netInfo copy to only have the primary NAD for this namespace
-		n.SetNADs(primaryNAD)
-		return n, nil
+	network, nad := c.getActiveNetworkForNamespace(namespace)
+	if network != nil && network.IsPrimaryNetwork() {
+		// primary UDN found
+		copy := util.NewMutableNetInfo(network)
+		copy.SetNADs(nad)
+		return copy, nil
 	}
 
-	// no primary network found, make sure we just haven't processed it yet and no UDN / CUDN exists
+	// no primary UDN found, make sure we just haven't processed it yet and no UDN / CUDN exists
 	udns, err := c.udnLister.UserDefinedNetworks(namespace).List(labels.Everything())
 	if err != nil {
 		return nil, fmt.Errorf("error getting user defined networks: %w", err)
@@ -482,6 +471,38 @@ func (c *nadController) GetActiveNetworkForNamespace(namespace string) (util.Net
 	return nil, util.NewInvalidPrimaryNetworkError(namespace)
 }
 
+func (c *nadController) GetActiveNetworkForNamespaceFast(namespace string) util.NetInfo {
+	network, _ := c.getActiveNetworkForNamespace(namespace)
+	return network
+}
+
+func (c *nadController) getActiveNetworkForNamespace(namespace string) (util.NetInfo, string) {
+	c.RLock()
+	defer c.RUnlock()
+
+	var network util.NetInfo
+	primaryNAD := c.primaryNADs[namespace]
+	switch primaryNAD {
+	case "":
+		// default network
+		network = c.networkController.getNetwork(types.DefaultNetworkName)
+		if network == nil {
+			network = &util.DefaultNetInfo{}
+		}
+	default:
+		// we have a primary network
+		netName := c.nads[primaryNAD]
+		if netName == "" {
+			// this should never happen where we have a nad keyed in the primaryNADs
+			// map, but it doesn't exist in the nads map
+			panic("NAD Controller broken consistency between primary NADs and cached NADs")
+		}
+		network = c.networkController.getNetwork(netName)
+	}
+
+	return network, primaryNAD
+}
+
 func (c *nadController) GetNetwork(name string) util.NetInfo {
 	network := c.networkController.getNetwork(name)
 	if network == nil && name == types.DefaultNetworkName {

go-controller/pkg/testing/networkmanager/fake.go

@@ -54,24 +54,28 @@ func (fnm *FakeNetworkManager) Start() error { return nil }
 func (fnm *FakeNetworkManager) Stop() {}
 
 func (fnm *FakeNetworkManager) GetActiveNetworkForNamespace(namespace string) (util.NetInfo, error) {
+	return fnm.GetActiveNetworkForNamespaceFast(namespace), nil
+}
+
+func (fnm *FakeNetworkManager) GetActiveNetworkForNamespaceFast(namespace string) util.NetInfo {
 	if primaryNetworks, ok := fnm.PrimaryNetworks[namespace]; ok && primaryNetworks != nil {
-		return primaryNetworks, nil
+		return primaryNetworks
 	}
-	return &util.DefaultNetInfo{}, nil
+	return &util.DefaultNetInfo{}
 }
 
-func (nc *FakeNetworkManager) GetNetwork(networkName string) util.NetInfo {
-	for _, ni := range nc.PrimaryNetworks {
+func (fnm *FakeNetworkManager) GetNetwork(networkName string) util.NetInfo {
+	for _, ni := range fnm.PrimaryNetworks {
 		if ni.GetNetworkName() == networkName {
 			return ni
 		}
 	}
 	return &util.DefaultNetInfo{}
 }
 
-func (nc *FakeNetworkManager) GetActiveNetworkNamespaces(networkName string) ([]string, error) {
+func (fnm *FakeNetworkManager) GetActiveNetworkNamespaces(networkName string) ([]string, error) {
 	namespaces := make([]string, 0)
-	for namespaceName, primaryNAD := range nc.PrimaryNetworks {
+	for namespaceName, primaryNAD := range fnm.PrimaryNetworks {
 		nadNetworkName := primaryNAD.GetNADs()[0]
 		if nadNetworkName != networkName {
 			continue
@@ -81,9 +85,9 @@ func (nc *FakeNetworkManager) GetActiveNetworkNamespaces(networkName string) ([]
 	return namespaces, nil
 }
 
-func (nc *FakeNetworkManager) DoWithLock(f func(network util.NetInfo) error) error {
+func (fnm *FakeNetworkManager) DoWithLock(f func(network util.NetInfo) error) error {
 	var errs []error
-	for _, ni := range nc.PrimaryNetworks {
+	for _, ni := range fnm.PrimaryNetworks {
 		if err := f(ni); err != nil {
 			errs = append(errs, err)
 		}