feat: remove useless testcase

.github/workflows/test.yml

@@ -20,6 +20,7 @@ jobs:
       - name: Push image to docker hub
         run: |
           echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USER }} --password-stdin
+          docker buildx create --use
           export VERSION=test
           make container
   linux:
@@ -83,7 +84,7 @@ jobs:
           sudo ln /usr/bin/resolvectl /usr/bin/systemd-resolve
 
       - name: Test
-        run: go test -v ./pkg/test/function_test.go
+        run: go test -v ./... -timeout=60m
 
   macos:
     runs-on: macos-10.15
@@ -156,7 +157,7 @@ jobs:
           netstat -anr
 
       - name: Test
-        run: go test -v ./pkg/test/function_test.go
+        run: go test -v ./... -timeout=60m
 
 #  windows:
 #    runs-on: windows-latest
@@ -195,5 +196,5 @@ jobs:
 #          ipconfig
 #
 #      - name: Test
-#        run: go test -v ./test/
+#        run: go test -v ./... -timeout=60m
 

pkg/dns/dns_server_test.go

@@ -1,195 +0,0 @@
-package dns
-
-import (
-	"context"
-	"fmt"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/docker/docker/libnetwork/resolvconf"
-	miekgdns "github.com/miekg/dns"
-	log "github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	testclient "k8s.io/client-go/kubernetes/fake"
-
-	"github.com/wencaiwulue/kubevpn/pkg/util"
-)
-
-func TestSetupDnsServer(t *testing.T) {
-	port := util.GetAvailableUDPPortOrDie()
-	clientConfig := &miekgdns.ClientConfig{
-		Servers: []string{"10.233.93.190"},
-		Search:  []string{"vke-system.svc.cluster.local", "svc.cluster.local", "cluster.local"},
-		Port:    "53",
-		Ndots:   0,
-	}
-	go func() { log.Fatal(NewDNSServer("udp", "127.0.0.1:"+strconv.Itoa(port), clientConfig)) }()
-	config := miekgdns.ClientConfig{
-		Servers: []string{"127.0.0.1"},
-		Search:  clientConfig.Search,
-		Port:    strconv.Itoa(port),
-		Ndots:   clientConfig.Ndots,
-		Timeout: 1,
-	}
-	_ = os.RemoveAll(filepath.Join("/", "etc", "resolver"))
-	if err := os.MkdirAll(filepath.Join("/", "etc", "resolver"), fs.ModePerm); err != nil {
-		panic(err)
-	}
-	for _, s := range strings.Split(clientConfig.Search[0], ".") {
-		filename := filepath.Join("/", "etc", "resolver", s)
-		err := os.WriteFile(filename, []byte(toString(config)), 0644)
-		if err != nil {
-			panic(err)
-		}
-	}
-	fmt.Println(port)
-	select {}
-}
-
-func TestFull(t *testing.T) {
-	type Question struct {
-		Q string
-	}
-	type person struct {
-		Name     string
-		age      *int
-		Question []Question
-	}
-
-	age := 22
-	p := &person{"Bob", &age, []Question{{"haha"}}}
-	fmt.Println(p)
-
-	p2 := new(person)
-	*p2 = *p
-	fmt.Println(p2)
-	p.Name = " zhangsan"
-	p.Question = append(p.Question, Question{"asdf"})
-	fmt.Println(p.Question)
-
-	fmt.Println(p2.Question)
-}
-
-func TestWriteHost(t *testing.T) {
-	clientset := testclient.NewSimpleClientset()
-	go AddServiceNameToHosts(context.Background(), clientset.CoreV1().Services("kube-system"))
-	time.AfterFunc(time.Second*2, func() {
-		for _, service := range getTestService() {
-			_, err := clientset.CoreV1().Services(service.Namespace).Create(context.Background(), &service, metav1.CreateOptions{})
-			assert.Nil(t, err)
-		}
-	})
-	select {}
-	CancelDNS()
-}
-
-func getTestService() (result []v1.Service) {
-	return []v1.Service{
-		{
-			TypeMeta: metav1.TypeMeta{
-				Kind:       "Service",
-				APIVersion: "v1",
-			},
-			ObjectMeta: metav1.ObjectMeta{
-				Name:              "authors",
-				Namespace:         "default",
-				CreationTimestamp: metav1.Now(),
-			},
-			Spec: v1.ServiceSpec{
-				ClusterIP:    "10.96.164.5",
-				ClusterIPs:   []string{"10.96.164.5"},
-				ExternalIPs:  nil,
-				ExternalName: "",
-			},
-		},
-		{
-			TypeMeta: metav1.TypeMeta{
-				Kind:       "Service",
-				APIVersion: "v1",
-			},
-			ObjectMeta: metav1.ObjectMeta{
-				Name:              "ratings",
-				Namespace:         "default",
-				CreationTimestamp: metav1.Now(),
-			},
-			Spec: v1.ServiceSpec{
-				ClusterIP:    "10.97.28.204",
-				ClusterIPs:   []string{"10.97.28.204"},
-				ExternalIPs:  nil,
-				ExternalName: "",
-			},
-		},
-		{
-			TypeMeta: metav1.TypeMeta{
-				Kind:       "Service",
-				APIVersion: "v1",
-			},
-			ObjectMeta: metav1.ObjectMeta{
-				Name:              "details",
-				Namespace:         "default",
-				CreationTimestamp: metav1.Now(),
-			},
-			Spec: v1.ServiceSpec{
-				ClusterIP:    "10.96.164.5",
-				ClusterIPs:   []string{"10.96.164.5"},
-				ExternalIPs:  nil,
-				ExternalName: "",
-			},
-		},
-		{
-			TypeMeta: metav1.TypeMeta{
-				Kind:       "Service",
-				APIVersion: "v1",
-			},
-			ObjectMeta: metav1.ObjectMeta{
-				Name:              "productpage",
-				Namespace:         "kube-system",
-				CreationTimestamp: metav1.Now(),
-			},
-			Spec: v1.ServiceSpec{
-				ClusterIP:    "10.97.21.170",
-				ClusterIPs:   []string{"10.97.21.170"},
-				ExternalIPs:  nil,
-				ExternalName: "productpage.io",
-			},
-		},
-	}
-}
-
-func TestRemoveWrittenHost(t *testing.T) {
-	err := updateHosts("")
-	assert.Nil(t, err)
-}
-
-func TestFix(t *testing.T) {
-	clientConfig := &miekgdns.ClientConfig{
-		Servers: []string{"10.233.93.190"},
-		Search:  []string{"vke-system.svc.cluster.local", "svc.cluster.local", "cluster.local"},
-		Port:    "53",
-		Ndots:   5,
-	}
-	for _, s := range clientConfig.NameList("productpage") {
-		println(s)
-	}
-}
-
-func TestName(t *testing.T) {
-	temp, _ := os.CreateTemp("", "")
-	temp.Close()
-	println(temp.Name())
-	_, err := resolvconf.Build(temp.Name(), []string{"10.233.0.3", "10.233.97.159", "10.233.122.162"}, []string{
-		"vke-system.svc.cluster.local",
-		"svc.cluster.local",
-		"cluster.local",
-	}, []string{"ndots:5", "timeout:5"})
-	if err != nil {
-		panic(err)
-	}
-}

pkg/handler/connect_test.go

@@ -1,162 +0,0 @@
-package handler
-
-import (
-	"context"
-	"crypto/md5"
-	"fmt"
-	"net"
-	"os/exec"
-	"testing"
-	"time"
-
-	probing "github.com/prometheus-community/pro-bing"
-	log "github.com/sirupsen/logrus"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/types"
-	net2 "k8s.io/apimachinery/pkg/util/net"
-	"k8s.io/cli-runtime/pkg/genericclioptions"
-	"k8s.io/cli-runtime/pkg/resource"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/clientcmd"
-	cmdutil "k8s.io/kubectl/pkg/cmd/util"
-
-	"github.com/wencaiwulue/kubevpn/pkg/util"
-)
-
-var (
-	clientConfig = clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
-		&clientcmd.ClientConfigLoadingRules{ExplicitPath: clientcmd.RecommendedHomeFile}, nil,
-	)
-	clientconfig, _  = clientConfig.ClientConfig()
-	clientsets, _    = kubernetes.NewForConfig(clientconfig)
-	namespaces, _, _ = clientConfig.Namespace()
-)
-
-func TestGetCIDR(t *testing.T) {
-	cidr, err := util.GetCIDRFromResourceUgly(clientsets, namespaces)
-	if err == nil {
-		for _, ipNet := range cidr {
-			fmt.Println(ipNet)
-		}
-	}
-}
-
-func TestPingUsingCommand(t *testing.T) {
-	list, _ := clientsets.CoreV1().Services(namespaces).List(context.Background(), metav1.ListOptions{})
-	for _, service := range list.Items {
-		for _, clusterIP := range service.Spec.ClusterIPs {
-			_ = exec.Command("ping", clusterIP, "-c", "4").Run()
-		}
-	}
-}
-
-func TestGetMacAddress(t *testing.T) {
-	interfaces, _ := net.Interfaces()
-	hostInterface, _ := net2.ChooseHostInterface()
-	for _, i := range interfaces {
-		//fmt.Printf("%s -> %s\n", i.Name, i.HardwareAddr.String())
-		addrs, _ := i.Addrs()
-		for _, addr := range addrs {
-			if hostInterface.Equal(addr.(*net.IPNet).IP) {
-				hash := md5.New()
-				hash.Write([]byte(i.HardwareAddr.String()))
-				sum := hash.Sum(nil)
-				toInt := util.BytesToInt(sum)
-				fmt.Println(toInt)
-			}
-		}
-	}
-}
-
-func TestPingUsingCode(t *testing.T) {
-	conn, err := net.DialTimeout("ip4:icmp", "www.baidu.com", time.Second*5)
-	if err != nil {
-		log.Print(err)
-		return
-	}
-	var msg [512]byte
-	msg[0] = 8
-	msg[1] = 0
-	msg[2] = 0
-	msg[3] = 0
-	msg[4] = 0
-	msg[5] = 13
-	msg[6] = 0
-	msg[7] = 37
-
-	length := 8
-	check := checkSum(msg[0:length])
-	msg[2] = byte(check >> 8)
-	msg[3] = byte(check & 255)
-	_, err = conn.Write(msg[0:length])
-	if err != nil {
-		log.Print(err)
-		return
-	}
-	conn.Read(msg[0:])
-	log.Println(msg[5] == 13)
-	log.Println(msg[7] == 37)
-}
-
-func checkSum(msg []byte) uint16 {
-	sum := 0
-	for n := 1; n < len(msg)-1; n += 2 {
-		sum += int(msg[n])*256 + int(msg[n+1])
-	}
-	sum = (sum >> 16) + (sum & 0xffff)
-	sum += sum >> 16
-	return uint16(^sum)
-}
-
-func TestPatchAnnotation(t *testing.T) {
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = &clientcmd.RecommendedHomeFile
-	factory := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
-	do := factory.NewBuilder().
-		Unstructured().
-		NamespaceParam("default").DefaultNamespace().AllNamespaces(false).
-		ResourceTypeOrNameArgs(true, "deployments/reviews").
-		ContinueOnError().
-		Latest().
-		Flatten().
-		TransformRequests(func(req *rest.Request) { req.Param("includeObject", "Object") }).
-		Do()
-	err := do.Err()
-	if err != nil {
-		panic(err)
-	}
-	infos, err := do.Infos()
-	if err != nil {
-		panic(err)
-	}
-	info := infos[0]
-	helper := resource.NewHelper(info.Client, info.Mapping)
-
-	object, err := helper.Patch(
-		info.Namespace,
-		info.Name,
-		types.JSONPatchType,
-		[]byte(`[{"op":"replace","path":"/metadata/annotations/dev.nocalhost","value":{"apiVersion":"apps/v1","kind":"Deployment","metadata":{"annotations":{"deployment.kubernetes.io/revision":"1","dev.nocalhost/application-name":"bookinfo","dev.nocalhost/application-namespace":"default"},"labels":{"app":"reviews","app.kubernetes.io/managed-by":"nocalhost"},"name":"reviews","namespace":"default","selfLink":"/apis/apps/v1/namespaces/default/deployments/reviews"},"spec":{"progressDeadlineSeconds":600,"replicas":1,"revisionHistoryLimit":10,"selector":{"matchLabels":{"app":"reviews"}},"strategy":{"rollingUpdate":{"maxSurge":"25%","maxUnavailable":"25%"},"type":"RollingUpdate"},"template":{"metadata":{"creationTimestamp":null,"labels":{"app":"reviews"}},"spec":{"containers":[{"env":[{"name":"LOG_DIR","value":"/tmp/logs"}],"image":"nocalhost-docker.pkg.coding.net/nocalhost/bookinfo/reviews:latest","imagePullPolicy":"Always","name":"reviews","ports":[{"containerPort":9080,"protocol":"TCP"}],"readinessProbe":{"failureThreshold":3,"initialDelaySeconds":5,"periodSeconds":10,"successThreshold":1,"tcpSocket":{"port":9080},"timeoutSeconds":1},"resources":{"limits":{"cpu":"1","memory":"512Mi"},"requests":{"cpu":"10m","memory":"32Mi"}},"terminationMessagePath":"/dev/termination-log","terminationMessagePolicy":"File","volumeMounts":[{"mountPath":"/tmp","name":"tmp"},{"mountPath":"/opt/ibm/wlp/output","name":"wlp-output"}]}],"dnsPolicy":"ClusterFirst","restartPolicy":"Always","schedulerName":"default-scheduler","securityContext":{},"terminationGracePeriodSeconds":30,"volumes":[{"emptyDir":{},"name":"wlp-output"},{"emptyDir":{},"name":"tmp"}]}}}}}]`),
-		&metav1.PatchOptions{})
-	if err != nil {
-		panic(err)
-	}
-	fmt.Println(object.(*unstructured.Unstructured).GetAnnotations())
-}
-
-func TestPing(t *testing.T) {
-	ip := "10.233.98.197"
-	pinger, err := probing.NewPinger(ip)
-	if err != nil {
-		panic(err)
-	}
-	pinger.Count = 3
-	err = pinger.Run() // Blocks until finished.
-	if err != nil {
-		panic(err)
-	}
-	stats := pinger.Statistics() // get send/receive/duplicate/rtt stats
-	fmt.Println(stats)
-}

pkg/handler/function_test.go

@@ -1,4 +1,4 @@
-package main
+package handler
 
 import (
 	"context"
@@ -32,7 +32,7 @@ var (
 	namespace  string
 	clientset  *kubernetes.Clientset
 	restclient *rest.RESTClient
-	config     *rest.Config
+	c          *rest.Config
 )
 
 func TestFunctions(t *testing.T) {
@@ -286,13 +286,13 @@ func init() {
 	configFlags.KubeConfig = &clientcmd.RecommendedHomeFile
 	f := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
 
-	if config, err = f.ToRESTConfig(); err != nil {
+	if c, err = f.ToRESTConfig(); err != nil {
 		log.Fatal(err)
 	}
-	if restclient, err = rest.RESTClientFor(config); err != nil {
+	if restclient, err = rest.RESTClientFor(c); err != nil {
 		log.Fatal(err)
 	}
-	if clientset, err = kubernetes.NewForConfig(config); err != nil {
+	if clientset, err = kubernetes.NewForConfig(c); err != nil {
 		log.Fatal(err)
 	}
 	if namespace, _, err = f.ToRawKubeConfigLoader().Namespace(); err != nil {

pkg/handler/remote_test.go

@@ -1,284 +0,0 @@
-package handler
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net"
-	"os/exec"
-	"path/filepath"
-	"testing"
-	"time"
-
-	log "github.com/sirupsen/logrus"
-	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/assert"
-	corev1 "k8s.io/api/core/v1"
-	k8serrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	k8sruntime "k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/cli-runtime/pkg/genericclioptions"
-	pkgresource "k8s.io/cli-runtime/pkg/resource"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/client-go/util/homedir"
-	"k8s.io/client-go/util/retry"
-	cmdutil "k8s.io/kubectl/pkg/cmd/util"
-	"k8s.io/utils/pointer"
-
-	"github.com/wencaiwulue/kubevpn/pkg/config"
-	"github.com/wencaiwulue/kubevpn/pkg/util"
-)
-
-//func TestCreateServer(t *testing.T) {
-//	clientConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
-//		&clientcmd.ClientConfigLoadingRules{ExplicitPath: clientcmd.RecommendedHomeFile}, nil,
-//	)
-//	config, err := clientConfig.ClientConfig()
-//	if err != nil {
-//		log.Fatal(err)
-//	}
-//	clientset, err := kubernetes.NewForConfig(config)
-//	if err != nil {
-//		log.Fatal(err)
-//	}
-//
-//	i := &net.IPNet{
-//		IP:   net.ParseIP("192.168.254.100"),
-//		Mask: net.IPv4Mask(255, 255, 255, 0),
-//	}
-//
-//	j := &net.IPNet{
-//		IP:   net.ParseIP("172.20.0.0"),
-//		Mask: net.IPv4Mask(255, 255, 0, 0),
-//	}
-//
-//	server, err := pkg.CreateOutboundPod(clientset, "test", i, []*net.IPNet{j})
-//	fmt.Println(server)
-//}
-
-func TestGetIp(t *testing.T) {
-	ip := &net.IPNet{
-		IP:   net.IPv4(192, 168, 254, 100),
-		Mask: net.IPv4Mask(255, 255, 255, 0),
-	}
-	fmt.Println(ip.String())
-}
-
-func TestGetIPFromDHCP(t *testing.T) {
-	clientConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
-		&clientcmd.ClientConfigLoadingRules{ExplicitPath: clientcmd.RecommendedHomeFile}, nil,
-	)
-	config, err := clientConfig.ClientConfig()
-	if err != nil {
-		log.Fatal(err)
-	}
-	clientset, err := kubernetes.NewForConfig(config)
-	if err != nil {
-		log.Fatal(err)
-	}
-	_, ipNet, err := net.ParseCIDR("192.168.1.100/24")
-	manager := NewDHCPManager(clientset.CoreV1().ConfigMaps("test"), "test", ipNet)
-	manager.InitDHCP(context.Background())
-	for i := 0; i < 10; i++ {
-		ipNet, err := manager.RentIPRandom()
-		ipNet2, err := manager.RentIPRandom()
-		if err != nil {
-			fmt.Println(err)
-			continue
-		} else {
-			fmt.Printf("%s->%s\n", ipNet.String(), ipNet2.String())
-		}
-		time.Sleep(time.Millisecond * 10)
-		err = manager.ReleaseIpToDHCP(ipNet)
-		err = manager.ReleaseIpToDHCP(ipNet2)
-		if err != nil {
-			fmt.Println(err)
-		}
-		time.Sleep(time.Millisecond * 10)
-	}
-}
-
-func TestGetTopController(t *testing.T) {
-	s := "/Users/naison/.kube/devpool"
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = &s
-	factory := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
-	controller, err := util.GetTopOwnerReference(factory, "nh90bwck", "pods/services-authors-shadow")
-	fmt.Println(controller.Name)
-	fmt.Println(controller.Mapping.Resource.Resource)
-	fmt.Println(err)
-}
-
-func TestGetTopControllerByLabel(t *testing.T) {
-	s := "/Users/naison/.kube/mesh"
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = &s
-	factory := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
-	controller, err := util.GetTopOwnerReferenceBySelector(factory, "default", "app=productpage")
-	fmt.Println(controller)
-	fmt.Println(err)
-}
-
-func TestPreCheck(t *testing.T) {
-	var cmd = &cobra.Command{
-		Use:   "kubevpn",
-		Short: "kubevpn",
-		Long:  `kubevpn`,
-	}
-	flags := cmd.PersistentFlags()
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.AddFlags(flags)
-	matchVersionFlags := cmdutil.NewMatchVersionFlags(configFlags)
-	matchVersionFlags.AddFlags(flags)
-	factory := cmdutil.NewFactory(matchVersionFlags)
-	options := ConnectOptions{
-		Namespace: "naison-test",
-		Workloads: []string{"services/authors"},
-	}
-	err := options.InitClient(factory)
-	assert.Nil(t, err)
-	options.PreCheckResource()
-	fmt.Println(options.Workloads)
-}
-
-func init() {
-	util.InitLogger(config.Debug)
-}
-
-func TestBackoff(t *testing.T) {
-	var last = time.Now()
-	retry.OnError(wait.Backoff{
-		Steps:    10,
-		Duration: 40 * time.Millisecond,
-		Factor:   2.0,
-		Jitter:   0.5,
-	}, func(err error) bool {
-		return true
-	}, func() error {
-		now := time.Now()
-		fmt.Printf("%vs\n", now.Sub(last).Seconds())
-		last = now
-		return errors.New("")
-	})
-}
-
-func TestGetCRD(t *testing.T) {
-	join := filepath.Join(homedir.HomeDir(), ".kube", "nocalhost.large")
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = &join
-	factory := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
-	Namespace, _, _ := factory.ToRawKubeConfigLoader().Namespace()
-	object, err := util.GetUnstructuredObject(factory, Namespace, "statefulsets.apps.kruise.io/sample-beta1")
-	fmt.Println(object)
-	fmt.Println(err)
-}
-
-func TestDeleteAndCreate(t *testing.T) {
-	file := clientcmd.RecommendedHomeFile
-	file = filepath.Join(homedir.HomeDir(), ".kube", "config")
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = &file
-	factory := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
-
-	Namespace, _, err := factory.ToRawKubeConfigLoader().Namespace()
-	object, err := util.GetUnstructuredObject(factory, Namespace, "pods/nginx")
-
-	u := object.Object.(*unstructured.Unstructured)
-	var pp corev1.Pod
-	marshal, err := json.Marshal(u)
-	err = json.Unmarshal(marshal, &pp)
-
-	helper := pkgresource.NewHelper(object.Client, object.Mapping)
-	if _, err = helper.DeleteWithOptions(object.Namespace, object.Name, &metav1.DeleteOptions{
-		GracePeriodSeconds: pointer.Int64(0),
-	}); err != nil {
-		log.Fatal(err)
-	}
-	_ = exec.Command("kubectl", "wait", "pods/nginx", "--for=delete").Run()
-
-	p := &corev1.Pod{ObjectMeta: pp.ObjectMeta, Spec: pp.Spec}
-	CleanupUselessInfo(p)
-	if err = retry.OnError(wait.Backoff{
-		Steps:    10,
-		Duration: 50 * time.Millisecond,
-		Factor:   5.0,
-		Jitter:   1,
-	}, func(err error) bool {
-		if !k8serrors.IsAlreadyExists(err) {
-			return true
-		}
-		clientset, err := factory.KubernetesClientSet()
-		get, err := clientset.CoreV1().Pods(p.Namespace).Get(context.Background(), p.Name, metav1.GetOptions{})
-		if err != nil || get.Status.Phase != corev1.PodRunning {
-			return true
-		}
-		return false
-	}, func() error {
-		_, err = helper.Create(object.Namespace, true, p)
-		if err != nil {
-			return err
-		}
-		return errors.New("")
-	}); !k8serrors.IsAlreadyExists(err) {
-		log.Fatal(err)
-	}
-}
-
-func TestReadiness(t *testing.T) {
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = &clientcmd.RecommendedHomeFile
-	factory := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
-	object, err := util.GetUnstructuredObject(factory, "default", "deployment/authors")
-	if err != nil {
-		panic(err)
-	}
-	podTemplateSpec, path, err := util.GetPodTemplateSpecPath(object.Object.(*unstructured.Unstructured))
-	if err != nil {
-		panic(err)
-	}
-	helper := pkgresource.NewHelper(object.Client, object.Mapping)
-	removePatch, restorePatch := patch(*podTemplateSpec, path)
-	marshal, _ := json.Marshal(removePatch)
-	bytes, _ := json.Marshal(restorePatch)
-	_, err = patchs(helper, object.Namespace, object.Name, marshal)
-	if err != nil {
-		panic(err)
-	}
-	_, err = patchs(helper, object.Namespace, object.Name, bytes)
-	if err != nil {
-		panic(err)
-	}
-}
-
-func patchs(helper *pkgresource.Helper, namespace, name string, p []byte) (k8sruntime.Object, error) {
-	return helper.Patch(
-		namespace,
-		name,
-		types.JSONPatchType,
-		p,
-		&metav1.PatchOptions{},
-	)
-}
-
-func TestSliceRemove(t *testing.T) {
-	a := []string{"a", "a", "b", "c"}
-	for i := 0; i < len(a); i++ {
-		if a[i] == "a" {
-			a = append(a[:i], a[i+1:]...)
-			//i--
-		}
-	}
-	fmt.Println(a)
-}
-
-func TestDHCP(t *testing.T) {
-	s := "AQ=="
-	decodeString, err := base64.StdEncoding.DecodeString(s)
-	fmt.Println(string(decodeString), err)
-}

pkg/test/local.go

@@ -1,41 +0,0 @@
-package main
-
-import (
-	"io"
-	"net"
-
-	"github.com/containernetworking/cni/pkg/types"
-	log "github.com/sirupsen/logrus"
-
-	"github.com/wencaiwulue/kubevpn/pkg/tun"
-)
-
-func main() {
-	ip := net.ParseIP("223.254.254.102")
-	listener, err := tun.Listener(tun.Config{
-		Addr: ip.String() + "/24",
-		MTU:  1350,
-		Routes: []types.Route{{
-			Dst: net.IPNet{
-				IP:   ip,
-				Mask: net.CIDRMask(24, 32),
-			},
-		}, {
-			Dst: net.IPNet{
-				IP:   net.ParseIP("192.168.0.0"),
-				Mask: net.CIDRMask(24, 32),
-			},
-		}},
-	})
-	if err != nil {
-		panic(err)
-	}
-	tunConn, err := listener.Accept()
-	defer tunConn.Close()
-	tcpConn, err := net.Dial("tcp", ":1080")
-	if err != nil {
-		log.Fatal(err)
-	}
-	go io.Copy(tunConn, tcpConn)
-	io.Copy(tcpConn, tunConn)
-}

pkg/test/pod.yaml

@@ -1,31 +0,0 @@
-apiVersion: v1
-kind: Pod
-metadata:
-  name: traffic-test
-  labels:
-    app: traffic-test
-spec:
-  terminationGracePeriodSeconds: 0
-  containers:
-    - name: traffic-test
-      image: naison/kubevpn:v1.1.4
-      imagePullPolicy: IfNotPresent
-      command:
-        - /bin/sh
-        - -c
-      args:
-        - |
-          sysctl net.ipv4.ip_forward=1
-          update-alternatives --set iptables /usr/sbin/iptables-legacy
-          iptables -F
-          iptables -P INPUT ACCEPT
-          iptables -P FORWARD ACCEPT
-          iptables -t nat -A POSTROUTING -s 223.254.254.0/24 -o eth0 -j MASQUERADE
-          iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o eth0 -j MASQUERADE
-          tail -f /dev/null
-      securityContext:
-        privileged: true
-        capabilities:
-          add:
-            - NET_ADMIN
-  restartPolicy: Always

pkg/test/run.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-kubectl apply -f pod.yaml
-kubectl wait --for=condition=Ready pod/traffic-test
-cd ./server && GOARCH=amd64 GOOS=linux go build -o main
-kubectl cp main traffic-test:/app/main
-rm -fr main
-kubectl port-forward pods/traffic-test 1080

pkg/test/server/server.go

@@ -1,39 +0,0 @@
-package main
-
-import (
-	"io"
-	"net"
-
-	log "github.com/sirupsen/logrus"
-
-	"github.com/wencaiwulue/kubevpn/pkg/tun"
-)
-
-func main() {
-	ip := net.ParseIP("223.254.254.100")
-	listener, err := tun.Listener(tun.Config{
-		Addr: ip.String() + "/24",
-		MTU:  1350,
-	})
-	if err != nil {
-		panic(err)
-	}
-
-	tunConn, _ := listener.Accept()
-
-	tcpListener, err := net.Listen("tcp", ":1080")
-	if err != nil {
-		log.Fatal(err)
-	}
-	for {
-		tcpConn, err := tcpListener.Accept()
-		if err != nil {
-			panic(err)
-		}
-		go func(tcpConn net.Conn) {
-			defer tcpConn.Close()
-			go io.Copy(tunConn, tcpConn)
-			io.Copy(tcpConn, tunConn)
-		}(tcpConn)
-	}
-}

pkg/util/getcidr_test.go

@@ -1,23 +1,27 @@
 package util
 
 import (
-	"encoding/base64"
 	"fmt"
 	"testing"
 
 	log "github.com/sirupsen/logrus"
-	"golang.org/x/text/encoding/simplifiedchinese"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/kubectl/pkg/cmd/util"
-	"k8s.io/utils/pointer"
+)
+
+var (
+	namespace  string
+	clientset  *kubernetes.Clientset
+	restclient *rest.RESTClient
+	restconfig *rest.Config
+	f          util.Factory
 )
 
 func before() {
 	var err error
 	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = pointer.String("/Users/bytedance/.kube/vestack_upgrade")
 	f = util.NewFactory(util.NewMatchVersionFlags(configFlags))
 
 	if restconfig, err = f.ToRESTConfig(); err != nil {
@@ -38,7 +42,7 @@ func TestByDumpClusterInfo(t *testing.T) {
 	before()
 	info, err := getCIDRByDumpClusterInfo(clientset)
 	if err != nil {
-		panic(err)
+		t.Error(err)
 	}
 	for _, ipNet := range info {
 		fmt.Println(ipNet.String())
@@ -49,7 +53,7 @@ func TestByCreateSvc(t *testing.T) {
 	before()
 	info, err := getServiceCIDRByCreateSvc(clientset.CoreV1().Services("default"))
 	if err != nil {
-		panic(err)
+		t.Error(err)
 	}
 	fmt.Println(info)
 }
@@ -58,52 +62,9 @@ func TestElegant(t *testing.T) {
 	before()
 	elegant, err := GetCIDRElegant(clientset, restclient, restconfig, namespace)
 	if err != nil {
-		panic(err)
+		t.Error(err)
 	}
 	for _, net := range elegant {
 		fmt.Println(net.String())
 	}
 }
-
-func TestCal(t *testing.T) {
-	ints := []int{
-		5, 26,
-		8, 22,
-		25, 8,
-		8, 10,
-		25, 23,
-		8, 22,
-		8, 24,
-		8, 23,
-	}
-	sum := 0
-	for _, i := range ints {
-		sum += i
-	}
-	println(sum)
-}
-
-func TestName222(t *testing.T) {
-	ss := `DQrDu9PQ0+vWuLaoserXvM/gxqXF5LXEuebU8qGjDQoNCg==`
-	out, err := base64.StdEncoding.DecodeString(ss)
-	if err != nil {
-		panic(err)
-	}
-	s := string(out)
-	var b []byte
-	b, err = simplifiedchinese.GB18030.NewDecoder().Bytes(out)
-	if err == nil {
-		s = string(b)
-		println(s)
-	}
-	b, err = simplifiedchinese.GBK.NewDecoder().Bytes(out)
-	if err == nil {
-		s = string(b)
-		println(s)
-	}
-	b, err = simplifiedchinese.HZGB2312.NewDecoder().Bytes(out)
-	if err == nil {
-		s = string(b)
-	}
-	println(string(s))
-}

pkg/util/util_test.go

@@ -1,75 +1,11 @@
 package util
 
 import (
-	"context"
 	"fmt"
-	"net"
 	"regexp"
 	"testing"
-
-	"github.com/kevinburke/ssh_config"
-	log "github.com/sirupsen/logrus"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/fields"
-	"k8s.io/cli-runtime/pkg/genericclioptions"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
-	"k8s.io/kubectl/pkg/cmd/util"
-	"k8s.io/utils/pointer"
 )
 
-var (
-	namespace  string
-	clientset  *kubernetes.Clientset
-	restclient *rest.RESTClient
-	restconfig *rest.Config
-	f          util.Factory
-)
-
-func TestShell(t *testing.T) {
-	var err error
-
-	configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	configFlags.KubeConfig = pointer.String("/Users/bytedance/.kube/vestack_upgrade")
-	f = util.NewFactory(util.NewMatchVersionFlags(configFlags))
-
-	if restconfig, err = f.ToRESTConfig(); err != nil {
-		log.Fatal(err)
-	}
-	if restclient, err = rest.RESTClientFor(restconfig); err != nil {
-		log.Fatal(err)
-	}
-	if clientset, err = kubernetes.NewForConfig(restconfig); err != nil {
-		log.Fatal(err)
-	}
-	if namespace, _, err = f.ToRawKubeConfigLoader().Namespace(); err != nil {
-		log.Fatal(err)
-	}
-
-	var cmd = "cat /etc/resolv.conf | grep nameserver | awk '{print$2}'"
-	var podName = "kubevpn-traffic-manager-588d5c8475-rj2cd"
-	out, err := Shell(clientset, restclient, restconfig, podName, "", "default", []string{"sh", "-c", cmd})
-	fmt.Println(out)
-	serviceList, err := clientset.CoreV1().Services(v1.NamespaceSystem).List(context.Background(), v1.ListOptions{
-		FieldSelector: fields.OneTermEqualSelector("metadata.name", "kube-dns").String(),
-	})
-
-	fmt.Println(out == serviceList.Items[0].Spec.ClusterIP)
-}
-
-func TestDeleteRule(t *testing.T) {
-	DeleteWindowsFirewallRule(context.Background())
-}
-
-func TestUDP(t *testing.T) {
-	relay, err := net.ListenUDP("udp", &net.UDPAddr{Port: 12345})
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println(relay.LocalAddr())
-	fmt.Println(relay.RemoteAddr())
-}
-
 func TestName(t *testing.T) {
 	var s = `
 {
@@ -110,62 +46,3 @@ func TestName(t *testing.T) {
 	fmt.Println(compile.FindAllString(s, -1))
 	fmt.Println(v6.FindAllString(s, -1))
 }
-
-func TestParse(t *testing.T) {
-	all, _ := ssh_config.GetAllStrict("ry-agd-of", "ProxyJump")
-	for _, s := range all {
-		println(s)
-	}
-}
-
-func TestGetProxyJump(t *testing.T) {
-	value := confList.Get("ry-agd-of", "ProxyJump")
-	println(value)
-}
-
-func TestJ(t *testing.T) {
-
-	//sshConfig := &ssh.ClientConfig{
-	//	// SSH connection username
-	//	User:            "root",
-	//	Auth:            []ssh.AuthMethod{publicKeyFile("/Users/bytedance/.ssh/byte.pem")},
-	//	HostKeyCallback: ssh.InsecureIgnoreHostKey(),
-	//}
-
-	// sClient is an ssh client connected to the service host, through the bastion host.
-
-	var lc net.ListenConfig
-	ctx := context.Background()
-	listen, err := lc.Listen(ctx, "tcp", "localhost:8088")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer listen.Close()
-	fmt.Println(listen.Addr().String())
-
-	sClient, err := jump(nil, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	dial, err := sClient.Dial("tcp", "10.1.1.22:5443")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// handle incoming connections on reverse forwarded tunnel
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-		}
-		accept, err := listen.Accept()
-		if err != nil {
-			log.Fatal(err)
-		}
-		go func() {
-			handleClient(accept, dial)
-		}()
-	}
-}