refactor: cniserver

cmd/cni/cni.go

@@ -30,7 +30,7 @@ func main() {
 func cmdAdd(args *skel.CmdArgs) error {
 	var err error
 
-	n, cniVersion, err := loadNetConf(args.StdinData)
+	netConf, cniVersion, err := loadNetConf(args.StdinData)
 	if err != nil {
 		return err
 	}
@@ -43,58 +43,62 @@ func cmdAdd(args *skel.CmdArgs) error {
 		return err
 	}
 
-	client := request.NewCniServerClient(n.ServerSocket)
+	client := request.NewCniServerClient(netConf.ServerSocket)
 
-	res, err := client.Add(request.PodRequest{
+	response, err := client.Add(request.CniRequest{
 		PodName:      podName,
 		PodNamespace: podNamespace,
 		ContainerID:  args.ContainerID,
 		NetNs:        args.Netns})
 	if err != nil {
 		return err
 	}
-	result := generateCNIResult(cniVersion, res)
+	result := generateCNIResult(cniVersion, response)
 	return types.PrintResult(&result, cniVersion)
 }
 
-func generateCNIResult(cniVersion string, podResponse *request.PodResponse) current.Result {
+func generateCNIResult(cniVersion string, cniResponse *request.CniResponse) current.Result {
 	result := current.Result{CNIVersion: cniVersion}
-	_, mask, _ := net.ParseCIDR(podResponse.CIDR)
-	switch podResponse.Protocol {
+	_, mask, _ := net.ParseCIDR(cniResponse.CIDR)
+	switch cniResponse.Protocol {
 	case kubeovnv1.ProtocolIPv4:
 		ip := current.IPConfig{
 			Version: "4",
-			Address: net.IPNet{IP: net.ParseIP(podResponse.IpAddress).To4(), Mask: mask.Mask},
-			Gateway: net.ParseIP(podResponse.Gateway).To4(),
+			Address: net.IPNet{IP: net.ParseIP(cniResponse.IpAddress).To4(), Mask: mask.Mask},
+			Gateway: net.ParseIP(cniResponse.Gateway).To4(),
 		}
 		result.IPs = []*current.IPConfig{&ip}
-		route := types.Route{}
-		route.Dst = net.IPNet{IP: net.ParseIP("0.0.0.0").To4(), Mask: net.CIDRMask(0, 32)}
-		route.GW = net.ParseIP(podResponse.Gateway).To4()
+
+		route := types.Route{
+			Dst: net.IPNet{IP: net.ParseIP("0.0.0.0").To4(), Mask: net.CIDRMask(0, 32)},
+			GW: net.ParseIP(cniResponse.Gateway).To4(),
+		}
 		result.Routes = []*types.Route{&route}
 	case kubeovnv1.ProtocolIPv6:
 		ip := current.IPConfig{
 			Version: "6",
-			Address: net.IPNet{IP: net.ParseIP(podResponse.IpAddress).To16(), Mask: mask.Mask},
-			Gateway: net.ParseIP(podResponse.Gateway).To16(),
+			Address: net.IPNet{IP: net.ParseIP(cniResponse.IpAddress).To16(), Mask: mask.Mask},
+			Gateway: net.ParseIP(cniResponse.Gateway).To16(),
 		}
 		result.IPs = []*current.IPConfig{&ip}
-		route := types.Route{}
-		route.Dst = net.IPNet{IP: net.ParseIP("::").To16(), Mask: net.CIDRMask(0, 128)}
-		route.GW = net.ParseIP(podResponse.Gateway).To16()
+
+		route := types.Route{
+			Dst: net.IPNet{IP: net.ParseIP("::").To16(), Mask: net.CIDRMask(0, 128)},
+			GW: net.ParseIP(cniResponse.Gateway).To16(),
+		}
 		result.Routes = []*types.Route{&route}
 	}
 
 	return result
 }
 
 func cmdDel(args *skel.CmdArgs) error {
-	n, _, err := loadNetConf(args.StdinData)
+	netConf, _, err := loadNetConf(args.StdinData)
 	if err != nil {
 		return err
 	}
 
-	client := request.NewCniServerClient(n.ServerSocket)
+	client := request.NewCniServerClient(netConf.ServerSocket)
 	podName, err := parseValueFromArgs("K8S_POD_NAME", args.Args)
 	if err != nil {
 		return err
@@ -104,7 +108,7 @@ func cmdDel(args *skel.CmdArgs) error {
 		return err
 	}
 
-	return client.Del(request.PodRequest{
+	return client.Del(request.CniRequest{
 		PodName:      podName,
 		PodNamespace: podNamespace,
 		ContainerID:  args.ContainerID,

cmd/daemon/cniserver.go

@@ -5,19 +5,16 @@ import (
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"net/http"
 	_ "net/http/pprof"
-	"time"
 
 	kubeovninformer "github.com/alauda/kube-ovn/pkg/client/informers/externalversions"
 	"github.com/alauda/kube-ovn/pkg/daemon"
-	"github.com/alauda/kube-ovn/pkg/ovs"
 	kubeinformers "k8s.io/client-go/informers"
 	"k8s.io/klog"
 	"k8s.io/sample-controller/pkg/signals"
 )
 
 func main() {
 	defer klog.Flush()
-	go gc()
 
 	config, err := daemon.ParseFlags()
 	if err != nil {
@@ -53,10 +50,3 @@ func main() {
 	}()
 	daemon.RunServer(config)
 }
-
-func gc() {
-	for {
-		ovs.CleanLostInterface()
-		time.Sleep(60 * time.Second)
-	}
-}

pkg/daemon/config.go

@@ -58,7 +58,6 @@ func ParseFlags() (*Configuration, error) {
 	logrus.SetLevel(logrus.WarnLevel)
 
 	flag.Set("alsologtostderr", "true")
-
 	klogFlags := flag.NewFlagSet("klog", flag.ExitOnError)
 	klog.InitFlags(klogFlags)
 
@@ -80,7 +79,6 @@ func ParseFlags() (*Configuration, error) {
 		klog.Errorf("env KUBE_NODE_NAME not exists")
 		return nil, fmt.Errorf("env KUBE_NODE_NAME not exists")
 	}
-
 	config := &Configuration{
 		Iface:                 *argIface,
 		MTU:                   *argMTU,
@@ -95,39 +93,44 @@ func ParseFlags() (*Configuration, error) {
 		NodeLocalDNSIP:        *argNodeLocalDnsIP,
 	}
 
+	if err := config.initNicConfig(); err != nil {
+		return nil, err
+	}
+
+	if err := config.initKubeClient(); err != nil {
+		return nil, err
+	}
+
+	klog.Infof("daemon config: %v", config)
+	return config, nil
+}
+
+func (config *Configuration) initNicConfig() error {
 	if config.Iface == "" {
-		iface, err := getDefaultGatewayIface()
+		i, err := getDefaultGatewayIface()
 		if err != nil {
-			return nil, err
+			return err
 		} else {
-			config.Iface = iface
+			config.Iface = i
 		}
 	}
+
 	iface, err := net.InterfaceByName(config.Iface)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	if config.MTU == 0 {
 		config.MTU = iface.MTU - util.GeneveHeaderLength
 	}
 
 	addrs, err := iface.Addrs()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get iface addr. %v", err)
+		return fmt.Errorf("failed to get iface addr. %v", err)
 	}
 	if len(addrs) == 0 {
-		return nil, fmt.Errorf("iface %s has no ip address", config.Iface)
-	}
-	if err := setEncapIP(strings.Split(addrs[0].String(), "/")[0]); err != nil {
-		return nil, err
+		return fmt.Errorf("iface %s has no ip address", config.Iface)
 	}
-
-	err = config.initKubeClient()
-	if err != nil {
-		return nil, err
-	}
-	klog.Infof("daemon config: %v", config)
-	return config, nil
+	return setEncapIP(strings.Split(addrs[0].String(), "/")[0])
 }
 
 func (config *Configuration) initKubeClient() error {