OCPBUGS-63007: kubevirt: fix bad release of IPs of live migratable pods

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

@@ -272,7 +272,7 @@ func allocatePodAnnotationWithRollback(
 	err error) {
 
 	nadName := types.DefaultNetworkName
-	if netInfo.IsSecondary() {
+	if netInfo.IsUserDefinedNetwork() {
 		nadName = util.GetNADName(network.Namespace, network.Name)
 	}
 	podDesc := fmt.Sprintf("%s/%s/%s", nadName, pod.Namespace, pod.Name)
@@ -510,7 +510,7 @@ func AddRoutesGatewayIP(
 	// generate the nodeSubnets from the allocated IPs
 	nodeSubnets := util.IPsToNetworkIPs(podAnnotation.IPs...)
 
-	if netinfo.IsSecondary() {
+	if netinfo.IsUserDefinedNetwork() {
 		// for secondary network, see if its network-attachment's annotation has default-route key.
 		// If present, then we need to add default route for it
 		podAnnotation.Gateways = append(podAnnotation.Gateways, network.GatewayRequest...)

go-controller/pkg/clustermanager/clustermanager.go

@@ -27,13 +27,13 @@ import (
 
 // ClusterManager structure is the object which manages the cluster nodes.
 // It creates a default network controller for the default network and a
-// secondary network cluster controller manager to manage the multi networks.
+// user-defined network cluster controller manager to manage the multi networks.
 type ClusterManager struct {
 	client                      clientset.Interface
 	defaultNetClusterController *networkClusterController
 	zoneClusterController       *zoneClusterController
 	wf                          *factory.WatchFactory
-	secondaryNetClusterManager  *secondaryNetworkClusterManager
+	udnClusterManager           *userDefinedNetworkClusterManager
 	// Controller used for programming node allocation for egress IP
 	// The OVN DB setup is handled by egressIPZoneController that runs in ovnkube-controller
 	eIPC                          *egressIPClusterController
@@ -90,7 +90,7 @@ func NewClusterManager(
 			return nil, err
 		}
 
-		cm.secondaryNetClusterManager, err = newSecondaryNetworkClusterManager(ovnClient, wf, cm.networkManager.Interface(), recorder)
+		cm.udnClusterManager, err = newUserDefinedNetworkClusterManager(ovnClient, wf, cm.networkManager.Interface(), recorder)
 		if err != nil {
 			return nil, err
 		}
@@ -152,8 +152,8 @@ func NewClusterManager(
 			cm.recorder,
 		)
 		cm.userDefinedNetworkController = udnController
-		if cm.secondaryNetClusterManager != nil {
-			cm.secondaryNetClusterManager.SetNetworkStatusReporter(udnController.UpdateSubsystemCondition)
+		if cm.udnClusterManager != nil {
+			cm.udnClusterManager.SetNetworkStatusReporter(udnController.UpdateSubsystemCondition)
 		}
 	}
 
@@ -258,15 +258,15 @@ func (cm *ClusterManager) Stop() {
 }
 
 func (cm *ClusterManager) NewNetworkController(netInfo util.NetInfo) (networkmanager.NetworkController, error) {
-	return cm.secondaryNetClusterManager.NewNetworkController(netInfo)
+	return cm.udnClusterManager.NewNetworkController(netInfo)
 }
 
 func (cm *ClusterManager) GetDefaultNetworkController() networkmanager.ReconcilableNetworkController {
 	return cm.defaultNetClusterController
 }
 
 func (cm *ClusterManager) CleanupStaleNetworks(validNetworks ...util.NetInfo) error {
-	return cm.secondaryNetClusterManager.CleanupStaleNetworks(validNetworks...)
+	return cm.udnClusterManager.CleanupStaleNetworks(validNetworks...)
 }
 
 func (cm *ClusterManager) Reconcile(name string, old, new util.NetInfo) error {

go-controller/pkg/clustermanager/network_cluster_controller.go

@@ -154,7 +154,7 @@ func (ncc *networkClusterController) hasNodeAllocation() bool {
 		return config.OVNKubernetesFeature.EnableInterconnect
 	default:
 		// we need to allocate network IDs and subnets
-		return !ncc.IsSecondary()
+		return !ncc.IsUserDefinedNetwork()
 	}
 }
 
@@ -452,10 +452,10 @@ func (ncc *networkClusterController) newRetryFramework(objectType reflect.Type,
 	return objretry.NewRetryFramework(ncc.stopChan, ncc.wg, ncc.watchFactory, resourceHandler)
 }
 
-// Cleanup the subnet annotations from the node for the secondary networks
+// Cleanup the subnet annotations from the node for the User Defined Networks
 func (ncc *networkClusterController) Cleanup() error {
-	if !ncc.IsSecondary() {
-		return fmt.Errorf("default network can't be cleaned up")
+	if !ncc.IsUserDefinedNetwork() {
+		return fmt.Errorf("default network cannot be cleaned up")
 	}
 
 	if ncc.hasNodeAllocation() {

go-controller/pkg/clustermanager/node/node_allocator.go

@@ -124,11 +124,11 @@ func (na *NodeAllocator) CleanupStaleAnnotation() {
 
 func (na *NodeAllocator) hasHybridOverlayAllocation() bool {
 	// When config.HybridOverlay.ClusterSubnets is empty, assume the subnet allocation will be managed by an external component.
-	return config.HybridOverlay.Enabled && !na.netInfo.IsSecondary() && len(config.HybridOverlay.ClusterSubnets) > 0
+	return config.HybridOverlay.Enabled && !na.netInfo.IsUserDefinedNetwork() && len(config.HybridOverlay.ClusterSubnets) > 0
 }
 
 func (na *NodeAllocator) hasHybridOverlayAllocationUnmanaged() bool {
-	return config.HybridOverlay.Enabled && !na.netInfo.IsSecondary() && len(config.HybridOverlay.ClusterSubnets) == 0
+	return config.HybridOverlay.Enabled && !na.netInfo.IsUserDefinedNetwork() && len(config.HybridOverlay.ClusterSubnets) == 0
 }
 
 func (na *NodeAllocator) recordSubnetCount() {
@@ -595,7 +595,7 @@ func (na *NodeAllocator) allocateNodeSubnets(allocator SubnetAllocator, nodeName
 
 func (na *NodeAllocator) hasNodeSubnetAllocation() bool {
 	// we only allocate subnets for L3 secondary network or default network
-	return na.netInfo.TopologyType() == types.Layer3Topology || !na.netInfo.IsSecondary()
+	return na.netInfo.TopologyType() == types.Layer3Topology || !na.netInfo.IsUserDefinedNetwork()
 }
 
 func (na *NodeAllocator) markAllocatedNetworksForUnmanagedHONode(node *corev1.Node) error {

go-controller/pkg/clustermanager/secondary_network_cluster_manager.go → go-controller/pkg/clustermanager/user_defined_network_cluster_manager.go

@@ -14,10 +14,10 @@ import (
 	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/util"
 )
 
-// secondaryNetworkClusterManager object manages the multi net-attach-def controllers.
+// userDefinedNetworkClusterManager object manages the multi net-attach-def controllers.
 // It implements networkmanager.ControllerManager interface and can be used
 // by network manager to create and delete network controllers.
-type secondaryNetworkClusterManager struct {
+type userDefinedNetworkClusterManager struct {
 	// networkManager creates and deletes network controllers
 	networkManager networkmanager.Interface
 	ovnClient      *util.OVNClusterManagerClientset
@@ -29,14 +29,14 @@ type secondaryNetworkClusterManager struct {
 	errorReporter NetworkStatusReporter
 }
 
-func newSecondaryNetworkClusterManager(
+func newUserDefinedNetworkClusterManager(
 	ovnClient *util.OVNClusterManagerClientset,
 	wf *factory.WatchFactory,
 	networkManager networkmanager.Interface,
 	recorder record.EventRecorder,
-) (*secondaryNetworkClusterManager, error) {
-	klog.Infof("Creating secondary network cluster manager")
-	sncm := &secondaryNetworkClusterManager{
+) (*userDefinedNetworkClusterManager, error) {
+	klog.Infof("Creating user-defined network cluster manager")
+	sncm := &userDefinedNetworkClusterManager{
 		ovnClient:      ovnClient,
 		watchFactory:   wf,
 		networkManager: networkManager,
@@ -45,17 +45,17 @@ func newSecondaryNetworkClusterManager(
 	return sncm, nil
 }
 
-func (sncm *secondaryNetworkClusterManager) SetNetworkStatusReporter(errorReporter NetworkStatusReporter) {
+func (sncm *userDefinedNetworkClusterManager) SetNetworkStatusReporter(errorReporter NetworkStatusReporter) {
 	sncm.errorReporter = errorReporter
 }
 
-func (sncm *secondaryNetworkClusterManager) GetDefaultNetworkController() networkmanager.ReconcilableNetworkController {
+func (sncm *userDefinedNetworkClusterManager) GetDefaultNetworkController() networkmanager.ReconcilableNetworkController {
 	return nil
 }
 
 // NewNetworkController implements the networkmanager.ControllerManager
 // interface called by network manager to create or delete a network controller.
-func (sncm *secondaryNetworkClusterManager) NewNetworkController(nInfo util.NetInfo) (networkmanager.NetworkController, error) {
+func (sncm *userDefinedNetworkClusterManager) NewNetworkController(nInfo util.NetInfo) (networkmanager.NetworkController, error) {
 	if !sncm.isTopologyManaged(nInfo) {
 		return nil, networkmanager.ErrNetworkControllerTopologyNotManaged
 	}
@@ -73,7 +73,7 @@ func (sncm *secondaryNetworkClusterManager) NewNetworkController(nInfo util.NetI
 	return sncc, nil
 }
 
-func (sncm *secondaryNetworkClusterManager) isTopologyManaged(nInfo util.NetInfo) bool {
+func (sncm *userDefinedNetworkClusterManager) isTopologyManaged(nInfo util.NetInfo) bool {
 	switch nInfo.TopologyType() {
 	case ovntypes.Layer3Topology:
 		// we need to allocate subnets to each node regardless of configuration
@@ -93,7 +93,7 @@ func (sncm *secondaryNetworkClusterManager) isTopologyManaged(nInfo util.NetInfo
 // CleanupStaleNetworks cleans of stale data from the OVN database
 // corresponding to networks not included in validNetworks, which are considered
 // stale.
-func (sncm *secondaryNetworkClusterManager) CleanupStaleNetworks(validNetworks ...util.NetInfo) error {
+func (sncm *userDefinedNetworkClusterManager) CleanupStaleNetworks(validNetworks ...util.NetInfo) error {
 	existingNetworksMap := map[string]struct{}{}
 	for _, network := range validNetworks {
 		existingNetworksMap[network.GetNetworkName()] = struct{}{}
@@ -147,7 +147,7 @@ func (sncm *secondaryNetworkClusterManager) CleanupStaleNetworks(validNetworks .
 }
 
 // newDummyNetworkController creates a dummy network controller used to clean up specific network
-func (sncm *secondaryNetworkClusterManager) newDummyLayer3NetworkController(netName string) (networkmanager.NetworkController, error) {
+func (sncm *userDefinedNetworkClusterManager) newDummyLayer3NetworkController(netName string) (networkmanager.NetworkController, error) {
 	netInfo, _ := util.NewNetInfo(&ovncnitypes.NetConf{NetConf: types.NetConf{Name: netName}, Topology: ovntypes.Layer3Topology})
 	nc := newNetworkClusterController(
 		netInfo,

go-controller/pkg/clustermanager/secondary_network_unit_test.go → go-controller/pkg/clustermanager/user_defined_network_unit_test.go

@@ -57,8 +57,8 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 		wg.Wait()
 	})
 
-	ginkgo.Context("Secondary networks", func() {
-		ginkgo.It("Attach secondary layer3 network", func() {
+	ginkgo.Context("User-Defined Networks", func() {
+		ginkgo.It("Attach layer3 UDN", func() {
 			app.Action = func(ctx *cli.Context) error {
 				kubeFakeClient := fake.NewSimpleClientset(&corev1.NodeList{Items: nodes()})
 				fakeClient := &util.OVNClusterManagerClientset{
@@ -74,7 +74,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 				err = f.Start()
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-				sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+				sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 				netInfo, err := util.NewNetInfo(&ovncnitypes.NetConf{NetConf: types.NetConf{Name: "blue"}, Topology: ovntypes.Layer3Topology, Subnets: "192.168.0.0/16/24"})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
@@ -130,7 +130,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 			})
 
-			ginkgo.It("The secondary network controller starts successfully", func() {
+			ginkgo.It("The UDN controller starts successfully", func() {
 				app.Action = func(ctx *cli.Context) error {
 					gomega.Expect(
 						initConfig(ctx, config.OVNKubernetesFeatureConfig{
@@ -143,7 +143,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 					err = f.Start()
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-					sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+					sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 					config.OVNKubernetesFeature.EnableInterconnect = false
@@ -181,7 +181,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 					gomega.Expect(f.Start()).NotTo(gomega.HaveOccurred())
 
-					sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+					sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 					nc := newNetworkClusterController(
@@ -226,7 +226,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 			})
 
 			ginkgo.DescribeTable(
-				"the secondary network controller",
+				"the UDN controller",
 				func(netConf *ovncnitypes.NetConf, featureConfig config.OVNKubernetesFeatureConfig, expectedError error) {
 					var err error
 					netInfo, err = util.NewNetInfo(netConf)
@@ -240,7 +240,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 						err = f.Start()
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-						sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+						sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 						_, err = sncm.NewNetworkController(netInfo)
@@ -378,7 +378,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 
 				gomega.Eventually(checkNodeAnnotations).ShouldNot(gomega.HaveOccurred())
 
-				sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+				sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				// Create a fake nad controller for blue network so that the red network gets cleared
@@ -476,7 +476,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 						gomega.Expect(f.Start()).To(gomega.Succeed())
 
-						sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+						sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 						nc := newNetworkClusterController(
@@ -529,7 +529,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 						gomega.Expect(f.Start()).To(gomega.Succeed())
 
-						sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+						sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 						nc := newNetworkClusterController(
@@ -578,7 +578,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 						gomega.Expect(f.Start()).To(gomega.Succeed())
 
-						sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+						sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 						nc := newNetworkClusterController(
@@ -647,7 +647,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 						gomega.Expect(f.Start()).To(gomega.Succeed())
 
-						sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+						sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 						nc := newNetworkClusterController(
@@ -719,7 +719,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 						gomega.Expect(f.Start()).To(gomega.Succeed())
 
-						sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+						sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 						gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 						nc := newNetworkClusterController(
@@ -785,7 +785,7 @@ var _ = ginkgo.Describe("Cluster Controller Manager", func() {
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 					gomega.Expect(f.Start()).NotTo(gomega.HaveOccurred())
 
-					sncm, err := newSecondaryNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
+					sncm, err := newUserDefinedNetworkClusterManager(fakeClient, f, networkmanager.Default().Interface(), recorder)
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 					nc := newNetworkClusterController(

go-controller/pkg/cni/helper_linux.go

@@ -434,7 +434,7 @@ func ConfigureOVS(ctx context.Context, namespace, podName, hostIfaceName string,
 
 	ifaceID := util.GetIfaceId(namespace, podName)
 	if ifInfo.NetName != types.DefaultNetworkName {
-		ifaceID = util.GetSecondaryNetworkIfaceId(namespace, podName, ifInfo.NADName)
+		ifaceID = util.GetUDNIfaceId(namespace, podName, ifInfo.NADName)
 	}
 	initialPodUID := ifInfo.PodUID
 	ipStrs := make([]string, len(ifInfo.IPs))

go-controller/pkg/cni/types.go

@@ -164,7 +164,7 @@ type PodRequest struct {
 	// network name, for default network, this will be types.DefaultNetworkName
 	netName string
 
-	// for ovs interfaces plumbed for secondary networks, their iface-id's prefix is derived from the specific nadName;
+	// for ovs interfaces plumbed for UDNs, their iface-id's prefix is derived from the specific nadName;
 	// also, need to find the pod annotation, dpu pod connection/status annotations of the given NAD ("default"
 	// for default network).
 	nadName string

go-controller/pkg/cni/utils.go

@@ -139,7 +139,7 @@ func PodAnnotation2PodInfo(podAnnotation map[string]string, podNADAnnotation *ut
 	podInterfaceInfo := &PodInterfaceInfo{
 		PodAnnotation:        *podNADAnnotation,
 		MTU:                  mtu,
-		RoutableMTU:          config.Default.RoutableMTU, // TBD, configurable for secondary network?
+		RoutableMTU:          config.Default.RoutableMTU, // TBD, configurable for UDNs?
 		Ingress:              ingress,
 		Egress:               egress,
 		IsDPUHostMode:        config.OvnKubeNode.Mode == types.NodeModeDPUHost,