mirror of
https://github.com/kubenetworks/kubevpn.git
synced 2025-12-24 11:51:13 +08:00
289 lines
7.7 KiB
Go
289 lines
7.7 KiB
Go
package pkg
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
log "github.com/sirupsen/logrus"
|
|
"github.com/wencaiwulue/kubevpn/util"
|
|
v1 "k8s.io/api/apps/v1"
|
|
corev1 "k8s.io/api/core/v1"
|
|
k8serrors "k8s.io/apimachinery/pkg/api/errors"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
json2 "k8s.io/apimachinery/pkg/util/json"
|
|
"k8s.io/cli-runtime/pkg/genericclioptions"
|
|
"k8s.io/cli-runtime/pkg/printers"
|
|
"k8s.io/client-go/kubernetes"
|
|
"k8s.io/client-go/rest"
|
|
"k8s.io/client-go/tools/clientcmd"
|
|
cmdutil "k8s.io/kubectl/pkg/cmd/util"
|
|
"net"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
//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.CreateOutboundRouterPod(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)
|
|
}
|
|
|
|
manager := NewDHCPManager(clientset, "test", nil)
|
|
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 TestOwnerRef(t *testing.T) {
|
|
clientConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
|
|
&clientcmd.ClientConfigLoadingRules{ExplicitPath: clientcmd.RecommendedHomeFile}, nil,
|
|
)
|
|
config, _ := clientConfig.ClientConfig()
|
|
clientset, _ := kubernetes.NewForConfig(config)
|
|
//get, _ := clientset.CoreV1().Pods("test").Get(context.Background(), "tomcat-7449544d95-nv7gr", metav1.GetOptions{})
|
|
get, _ := clientset.CoreV1().Pods("test").Get(context.Background(), "mysql-0", metav1.GetOptions{})
|
|
|
|
of := metav1.GetControllerOf(get)
|
|
for of != nil {
|
|
b, err := clientset.AppsV1().RESTClient().Get().Namespace("test").
|
|
Name(of.Name).Resource(strings.ToLower(of.Kind) + "s").Do(context.Background()).Raw()
|
|
if k8serrors.IsNotFound(err) {
|
|
return
|
|
}
|
|
var replicaSet v1.ReplicaSet
|
|
if err = json.Unmarshal(b, &replicaSet); err == nil && len(replicaSet.Name) != 0 {
|
|
fmt.Printf("%s-%s\n", replicaSet.Kind, replicaSet.Name)
|
|
of = metav1.GetControllerOfNoCopy(&replicaSet)
|
|
continue
|
|
}
|
|
var statefulSet v1.StatefulSet
|
|
if err = json.Unmarshal(b, &statefulSet); err == nil && len(statefulSet.Name) != 0 {
|
|
fmt.Printf("%s-%s\n", statefulSet.Kind, statefulSet.Name)
|
|
of = metav1.GetControllerOfNoCopy(&statefulSet)
|
|
continue
|
|
}
|
|
var deployment v1.Deployment
|
|
if err = json.Unmarshal(b, &deployment); err == nil && len(deployment.Name) != 0 {
|
|
fmt.Printf("%s-%s\n", deployment.Kind, deployment.Name)
|
|
of = metav1.GetControllerOfNoCopy(&deployment)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGet(t *testing.T) {
|
|
configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
|
|
configFlags.KubeConfig = &clientcmd.RecommendedHomeFile
|
|
f := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
|
|
do := f.NewBuilder().
|
|
Unstructured().
|
|
NamespaceParam("test").DefaultNamespace().AllNamespaces(false).
|
|
ResourceTypeOrNameArgs(true, "deployment/productpage").
|
|
ContinueOnError().
|
|
Latest().
|
|
Flatten().
|
|
TransformRequests(func(req *rest.Request) { req.Param("includeObject", "Object") }).
|
|
Do()
|
|
if err := do.Err(); err != nil {
|
|
log.Warn(err)
|
|
}
|
|
infos, err := do.Infos()
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
for _, info := range infos {
|
|
printer, err := printers.NewJSONPathPrinter("{.spec.selector}")
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
err = printer.PrintObj(info.Object, buf)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
fmt.Println(buf.String())
|
|
l := &metav1.LabelSelector{}
|
|
err = json2.Unmarshal([]byte(buf.String()), l)
|
|
if err != nil || len(l.MatchLabels) == 0 {
|
|
m := map[string]string{}
|
|
_ = json2.Unmarshal([]byte(buf.String()), &m)
|
|
l = &metav1.LabelSelector{MatchLabels: m}
|
|
}
|
|
fmt.Println(l)
|
|
}
|
|
printer, err := printers.NewJSONPathPrinter("{.spec.template.spec.containers[0].ports}")
|
|
portPrinter, err := printers.NewJSONPathPrinter("{.spec.ports}")
|
|
var result []corev1.ContainerPort
|
|
for _, info := range infos {
|
|
buf := bytes.NewBuffer([]byte{})
|
|
err = printer.PrintObj(info.Object, buf)
|
|
if err != nil {
|
|
_ = portPrinter.PrintObj(info.Object, buf)
|
|
var ports []corev1.ServicePort
|
|
_ = json2.Unmarshal([]byte(buf.String()), &ports)
|
|
for _, port := range ports {
|
|
val := port.TargetPort.IntVal
|
|
if val == 0 {
|
|
val = port.Port
|
|
}
|
|
result = append(result, corev1.ContainerPort{
|
|
Name: port.Name,
|
|
ContainerPort: val,
|
|
Protocol: port.Protocol,
|
|
})
|
|
}
|
|
} else {
|
|
_ = json2.Unmarshal([]byte(buf.String()), &result)
|
|
}
|
|
fmt.Println(result)
|
|
}
|
|
}
|
|
|
|
func TestGetTopController(t *testing.T) {
|
|
configFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
|
|
configFlags.KubeConfig = &clientcmd.RecommendedHomeFile
|
|
factory := cmdutil.NewFactory(cmdutil.NewMatchVersionFlags(configFlags))
|
|
clientset, _ := factory.KubernetesClientSet()
|
|
controller := util.GetTopController(factory, clientset, "default", "pods/productpage-69cf486c4f-z8hb9")
|
|
fmt.Println(controller.Resource)
|
|
fmt.Println(controller.Name)
|
|
fmt.Println(controller.Scale)
|
|
}
|
|
|
|
func TestUDP(t *testing.T) {
|
|
go func() {
|
|
server()
|
|
}()
|
|
time.Sleep(time.Second * 1)
|
|
client()
|
|
}
|
|
|
|
func client() {
|
|
socket, err := net.DialUDP("udp4", nil, &net.UDPAddr{
|
|
IP: net.IPv4(172, 20, 225, 47),
|
|
Port: 55555,
|
|
})
|
|
if err != nil {
|
|
fmt.Println("连接失败!", err)
|
|
return
|
|
}
|
|
defer socket.Close()
|
|
|
|
// 发送数据
|
|
senddata := []byte("hello server!")
|
|
_, err = socket.Write(senddata)
|
|
if err != nil {
|
|
fmt.Println("发送数据失败!", err)
|
|
return
|
|
}
|
|
|
|
// 接收数据
|
|
data := make([]byte, 4096)
|
|
read, remoteAddr, err := socket.ReadFromUDP(data)
|
|
if err != nil {
|
|
fmt.Println("读取数据失败!", err)
|
|
return
|
|
}
|
|
fmt.Println(read, remoteAddr)
|
|
fmt.Printf("%s\n", data[0:read])
|
|
}
|
|
|
|
func server() {
|
|
// 创建监听
|
|
socket, err := net.ListenUDP("udp4", &net.UDPAddr{
|
|
IP: net.IPv4(0, 0, 0, 0),
|
|
Port: 55555,
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer socket.Close()
|
|
|
|
for {
|
|
data := make([]byte, 4096)
|
|
read, remoteAddr, err := socket.ReadFromUDP(data)
|
|
if err != nil {
|
|
fmt.Println("读取数据失败!", err)
|
|
continue
|
|
}
|
|
fmt.Println(read, remoteAddr)
|
|
fmt.Printf("%s\n\n", data[0:read])
|
|
|
|
senddata := []byte("hello client!")
|
|
_, err = socket.WriteToUDP(senddata, remoteAddr)
|
|
if err != nil {
|
|
fmt.Println("发送数据失败!", err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseEnvoy(t *testing.T) {
|
|
port := uint32(8080)
|
|
localAddress := "223.254.254.2"
|
|
config := getEnvoyConfig(port, localAddress)
|
|
fmt.Println(config)
|
|
}
|
|
|
|
func init() {
|
|
util.InitLogger(util.Debug)
|
|
}
|