apps/kubevpn
1
0
Fork 0
mirror of https://github.com/kubenetworks/kubevpn.git synced 2025-10-05 07:16:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: remove useless testcase

Browse Source
This commit is contained in:
fengcaiwen
2023-03-07 20:07:28 +08:00
committed by wencaiwulue
parent 5d622c19d3
commit 9ab86c3baf
11 changed files with 20 additions and 941 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
.github/workflows/test.yml vendored
View File

@@ -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

195
pkg/dns/dns_server_test.go
View File

@@ -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)
}
}

162
pkg/handler/connect_test.go
View File

@@ -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)
}

10
pkg/test/function_test.go → pkg/handler/function_test.go
View File

@@ -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 {

284
pkg/handler/remote_test.go
View File

@@ -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)
}

41
pkg/test/local.go
View File

@@ -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)
}

31
pkg/test/pod.yaml
View File

@@ -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

8
pkg/test/run.sh
View File

@@ -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

39
pkg/test/server/server.go
View File

@@ -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)
}
}

61
pkg/util/getcidr_test.go
View File

@@ -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))
}

123
pkg/util/util_test.go
View File

@@ -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)
}()
}
}