keep ip for kubevirt pod

dist/images/install.sh

@@ -932,7 +932,24 @@ rules:
       - create
       - patch
       - update
-
+  - apiGroups:
+      - "k8s.cni.cncf.io"
+    resources:
+      - network-attachment-definitions
+    verbs:
+      - create
+      - delete
+      - get
+      - list
+      - update
+  - apiGroups:
+      - "kubevirt.io"
+    resources:
+      - virtualmachines
+      - virtualmachineinstances
+    verbs:
+      - get
+      - list
 ---
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
@@ -1428,6 +1445,14 @@ rules:
       - get
       - list
       - update
+  - apiGroups:
+      - "kubevirt.io"
+    resources:
+      - virtualmachines
+      - virtualmachineinstances
+    verbs:
+      - get
+      - list
 ---
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding

go.mod

@@ -36,7 +36,6 @@ require (
 	github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b // indirect
 	github.com/sirupsen/logrus v1.6.0
 	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.6.3 // indirect
 	github.com/stretchr/testify v1.6.1
 	github.com/vishvananda/netlink v1.1.0
 	golang.org/x/crypto v0.0.0-20201216223049-8b5274cf687f // indirect
@@ -48,15 +47,22 @@ require (
 	google.golang.org/protobuf v1.27.1 // indirect
 	k8s.io/api v0.20.4
 	k8s.io/apimachinery v0.20.4
-	k8s.io/client-go v0.20.4
+	k8s.io/client-go v12.0.0+incompatible
 	k8s.io/klog v1.0.0
 	k8s.io/klog/v2 v2.4.0
 	k8s.io/sample-controller v0.0.0-20190326030654-b8f621986e45
-	sigs.k8s.io/controller-runtime v0.7.0
+	kubevirt.io/client-go v0.49.0
+	sigs.k8s.io/controller-runtime v0.8.3
 )
 
 replace (
 	github.com/gogo/protobuf => github.com/gogo/protobuf v1.3.2
 	github.com/greenpau/ovsdb => github.com/alauda/ovsdb v0.0.0-20210113100339-040cf3e76c28
+	github.com/openshift/api => github.com/openshift/api v0.0.0-20210428205234-a8389931bee7
+	github.com/openshift/client-go => github.com/openshift/client-go v0.0.0-20210112165513-ebc401615f47
+	github.com/openshift/library-go => github.com/mhenriks/library-go v0.0.0-20210511195009-51ba86622560
 	k8s.io/client-go => k8s.io/client-go v0.20.4
+	kubevirt.io/api => kubevirt.io/api v0.49.0
+	kubevirt.io/client-go => kubevirt.io/client-go v0.49.0
+	kubevirt.io/containerized-data-importer => kubevirt.io/kubevirt-containerized-data-importer v1.42.1
 )

pkg/controller/config.go

@@ -14,6 +14,7 @@ import (
 
 	clientset "github.com/kubeovn/kube-ovn/pkg/client/clientset/versioned"
 	"github.com/kubeovn/kube-ovn/pkg/util"
+	"kubevirt.io/client-go/kubecli"
 )
 
 // Configuration is the controller conf
@@ -27,6 +28,7 @@ type Configuration struct {
 	KubeClient      kubernetes.Interface
 	KubeOvnClient   clientset.Interface
 	AttachNetClient attacnetclientset.Interface
+	KubevirtClient  kubecli.KubevirtClient
 
 	DefaultLogicalSwitch string
 	DefaultCIDR          string
@@ -60,6 +62,7 @@ type Configuration struct {
 	EnableNP          bool
 	EnableExternalVpc bool
 	EnableEcmp        bool
+	EnableKeepVmIP    bool
 }
 
 // ParseFlags parses cmd args then init kubeclient and conf
@@ -99,18 +102,19 @@ func ParseFlags() (*Configuration, error) {
 		argEnableNP             = pflag.Bool("enable-np", true, "Enable network policy support, default: true")
 		argEnableExternalVpc    = pflag.Bool("enable-external-vpc", true, "Enable external vpc support, default: true")
 		argEnableEcmp           = pflag.Bool("enable-ecmp", false, "Enable ecmp route for centralized subnet")
+		argKeepVmIP             = pflag.Bool("keep-vm-ip", false, "Whether to keep ip for kubevirt pod when pod is rebuild")
 	)
 
 	klogFlags := flag.NewFlagSet("klog", flag.ExitOnError)
 	klog.InitFlags(klogFlags)
 
 	// Sync the glog and klog flags.
-	flag.CommandLine.VisitAll(func(f1 *flag.Flag) {
+	pflag.CommandLine.VisitAll(func(f1 *pflag.Flag) {
 		f2 := klogFlags.Lookup(f1.Name)
 		if f2 != nil {
 			value := f1.Value.String()
 			if err := f2.Value.Set(value); err != nil {
-				klog.Fatalf("failed to set flag, %v", err)
+				klog.Fatalf("failed to set pflag, %v", err)
 			}
 		}
 	})
@@ -150,6 +154,7 @@ func ParseFlags() (*Configuration, error) {
 		EnableNP:                      *argEnableNP,
 		EnableExternalVpc:             *argEnableExternalVpc,
 		EnableEcmp:                    *argEnableEcmp,
+		EnableKeepVmIP:                *argKeepVmIP,
 	}
 
 	if config.NetworkType == util.NetworkTypeVlan && config.DefaultHostInterface == "" {
@@ -209,6 +214,14 @@ func (config *Configuration) initKubeClient() error {
 	}
 	config.AttachNetClient = AttachNetClient
 
+	// get the kubevirt client, using which kubevirt resources can be managed.
+	virtClient, err := kubecli.GetKubevirtClientFromRESTConfig(cfg)
+	if err != nil {
+		klog.Errorf("init kubevirt client failed %v", err)
+		return err
+	}
+	config.KubevirtClient = virtClient
+
 	kubeOvnClient, err := clientset.NewForConfig(cfg)
 	if err != nil {
 		klog.Errorf("init kubeovn client failed %v", err)

pkg/controller/gc.go

@@ -212,6 +212,7 @@ func (c *Controller) markAndCleanLSP() error {
 		} else if !isPodAlive(pod) {
 			continue
 		}
+		podName := c.getNameByPod(pod)
 
 		for k, v := range pod.Annotations {
 			if !strings.Contains(k, util.AllocatedAnnotationSuffix) || v != "true" {
@@ -225,7 +226,7 @@ func (c *Controller) markAndCleanLSP() error {
 			if !isProviderOvn {
 				continue
 			}
-			ipNames = append(ipNames, ovs.PodNameToPortName(pod.Name, pod.Namespace, providerName))
+			ipNames = append(ipNames, ovs.PodNameToPortName(podName, pod.Namespace, providerName))
 		}
 	}
 	for _, node := range nodes {

pkg/controller/init.go

@@ -288,21 +288,22 @@ func (c *Controller) InitIPAM() error {
 	}
 	for _, pod := range pods {
 		if isPodAlive(pod) && pod.Annotations[util.AllocatedAnnotation] == "true" {
+			podName := c.getNameByPod(pod)
 			if pod.Annotations[util.LogicalSwitchAnnotation] != "" {
 				_, _, _, err := c.ipam.GetStaticAddress(
-					fmt.Sprintf("%s/%s", pod.Namespace, pod.Name),
+					fmt.Sprintf("%s/%s", pod.Namespace, podName),
 					pod.Annotations[util.IpAddressAnnotation],
 					pod.Annotations[util.MacAddressAnnotation],
 					pod.Annotations[util.LogicalSwitchAnnotation])
 				if err != nil {
-					klog.Errorf("failed to init pod %s.%s address %s: %v", pod.Name, pod.Namespace, pod.Annotations[util.IpAddressAnnotation], err)
+					klog.Errorf("failed to init pod %s.%s address %s: %v", podName, pod.Namespace, pod.Annotations[util.IpAddressAnnotation], err)
 				}
 			}
 			attachNetworks := pod.Annotations[util.AttachmentNetworkAnnotation]
 			if attachNetworks != "" {
 				attachments, err := util.ParsePodNetworkAnnotation(attachNetworks, pod.Namespace)
 				if err != nil {
-					klog.Errorf("failed to parse attach net for pod '%s', %v", pod.Name, err)
+					klog.Errorf("failed to parse attach net for pod '%s', %v", podName, err)
 					continue
 				}
 				for _, attach := range attachments {
@@ -316,17 +317,17 @@ func (c *Controller) InitIPAM() error {
 					}
 
 					_, _, _, err := c.ipam.GetStaticAddress(
-						fmt.Sprintf("%s/%s", pod.Namespace, pod.Name),
+						fmt.Sprintf("%s/%s", pod.Namespace, podName),
 						pod.Annotations[fmt.Sprintf(util.IpAddressAnnotationTemplate, builder.String())],
 						pod.Annotations[fmt.Sprintf(util.MacAddressAnnotationTemplate, builder.String())],
 						pod.Annotations[fmt.Sprintf(util.LogicalSwitchAnnotationTemplate, builder.String())])
 					if err != nil {
-						klog.Errorf("failed to init pod %s.%s address %s: %v", pod.Name, pod.Namespace, pod.Annotations[util.IpAddressAnnotation], err)
+						klog.Errorf("failed to init pod %s.%s address %s: %v", podName, pod.Namespace, pod.Annotations[util.IpAddressAnnotation], err)
 					}
 				}
 			}
 			if err = c.initAppendPodExternalIds(pod); err != nil {
-				klog.Errorf("failed to init append pod %s.%s externalIds: %v", pod.Name, pod.Namespace, err)
+				klog.Errorf("failed to init append pod %s.%s externalIds: %v", podName, pod.Namespace, err)
 			}
 		}
 	}
@@ -582,23 +583,24 @@ func (c *Controller) initAppendPodExternalIds(pod *v1.Pod) error {
 		return err
 	}
 
+	podName := c.getNameByPod(pod)
 	for _, podNet := range podNets {
 		if !strings.HasSuffix(podNet.ProviderName, util.OvnProvider) {
 			continue
 		}
-		portName := ovs.PodNameToPortName(pod.Name, pod.Namespace, podNet.ProviderName)
+		portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)
 		externalIds, err := c.ovnClient.OvnGet("logical_switch_port", portName, "external_ids", "")
 		if err != nil {
-			klog.Errorf("failed to get lsp external_ids for pod %s/%s, %v", pod.Namespace, pod.Name, err)
+			klog.Errorf("failed to get lsp external_ids for pod %s/%s, %v", pod.Namespace, podName, err)
 			return err
 		}
 		if strings.Contains(externalIds, "pod") || strings.Contains(externalIds, "vendor") {
 			continue
 		}
 
-		ovnCommand := []string{"set", "logical_switch_port", portName, fmt.Sprintf("external_ids:pod=%s/%s", pod.Namespace, pod.Name), fmt.Sprintf("external_ids:vendor=%s", util.CniTypeName)}
+		ovnCommand := []string{"set", "logical_switch_port", portName, fmt.Sprintf("external_ids:pod=%s/%s", pod.Namespace, podName), fmt.Sprintf("external_ids:vendor=%s", util.CniTypeName)}
 		if err = c.ovnClient.SetLspExternalIds(ovnCommand); err != nil {
-			klog.Errorf("failed to set lsp external_ids for pod %s/%s, %v", pod.Namespace, pod.Name, err)
+			klog.Errorf("failed to set lsp external_ids for pod %s/%s, %v", pod.Namespace, podName, err)
 			return err
 		}
 	}

pkg/controller/inspection.go

@@ -3,6 +3,7 @@ package controller
 import (
 	"context"
 	"fmt"
+
 	"github.com/kubeovn/kube-ovn/pkg/ovs"
 	"github.com/kubeovn/kube-ovn/pkg/util"
 	v1 "k8s.io/api/core/v1"
@@ -28,14 +29,16 @@ func (c *Controller) inspectPod() error {
 		if pod.Spec.HostNetwork {
 			continue
 		}
+		podName := c.getNameByPod(pod)
 		podNets, err := c.getPodKubeovnNets(pod)
 		if err != nil {
 			klog.Errorf("failed to list pod subnets, %v", err)
 			return err
 		}
+
 		for _, podNet := range filterSubnets(pod, podNets) {
 			if podNet.Type != providerTypeIPAM {
-				portName := ovs.PodNameToPortName(pod.Name, pod.Namespace, podNet.ProviderName)
+				portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)
 				isLspExist := false
 				for _, lsp := range lsps {
 					if portName == lsp {

pkg/controller/network_policy.go

@@ -566,8 +566,9 @@ func (c *Controller) fetchSelectedPorts(namespace string, selector *metav1.Label
 		if !isPodAlive(pod) {
 			continue
 		}
+		podName := c.getNameByPod(pod)
 		if !pod.Spec.HostNetwork && pod.Annotations[util.AllocatedAnnotation] == "true" {
-			ports = append(ports, fmt.Sprintf("%s.%s", pod.Name, pod.Namespace))
+			ports = append(ports, fmt.Sprintf("%s.%s", podName, pod.Namespace))
 		}
 	}
 	return ports, nil

pkg/controller/node.go

@@ -798,9 +798,10 @@ func (c *Controller) fetchPodsOnNode(nodeName string) ([]string, error) {
 		if !isPodAlive(pod) || pod.Spec.HostNetwork || pod.Spec.NodeName != nodeName || pod.Annotations[util.LogicalRouterAnnotation] != util.DefaultVpc {
 			continue
 		}
+		podName := c.getNameByPod(pod)
 
 		if pod.Annotations[util.AllocatedAnnotation] == "true" {
-			ports = append(ports, fmt.Sprintf("%s.%s", pod.Name, pod.Namespace))
+			ports = append(ports, fmt.Sprintf("%s.%s", podName, pod.Namespace))
 		}
 	}
 	return ports, nil