apps/kubevpn
1
0
Fork 0
mirror of https://github.com/kubenetworks/kubevpn.git synced 2025-12-24 11:51:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

optimize code

Browse Source
This commit is contained in:
wencaiwulue
2021-09-05 22:35:45 +08:00
parent 8ce8283fb1
commit dd06c7a076
2 changed files with 77 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
pkg/main.go
View File

@@ -27,7 +27,7 @@ import (
)
var (
baseCfg route
nodeConfig route
kubeconfigpath string
namespace string
services string
@@ -80,8 +80,7 @@ func prepare() {
Mask: net.CIDRMask(24, 32),
}
err = remote.InitDHCP(clientset, namespace, &trafficManager)
if err != nil {
if err = remote.InitDHCP(clientset, namespace, &trafficManager); err != nil {
log.Fatal(err)
}
tunIp, err := remote.GetIpFromDHCP(clientset, namespace)
@@ -129,8 +128,8 @@ func prepare() {
list = append(list, trafficManager.String())
baseCfg.ChainNodes = "socks5://127.0.0.1:10800?notls=true"
baseCfg.ServeNodes = fmt.Sprintf("tun://:8421/127.0.0.1:8421?net=%s&route=%s", tunIp.String(), strings.Join(list, ","))
nodeConfig.ChainNodes = "socks5://127.0.0.1:10800?notls=true"
nodeConfig.ServeNodes = fmt.Sprintf("tun://:8421/127.0.0.1:8421?net=%s&route=%s", tunIp.String(), strings.Join(list, ","))
log.Info("your ip is " + tunIp.String())
@@ -186,7 +185,6 @@ func main() {
log.Info("dns service ok")
_ = exec.Command("ping", "-c", "4", "223.254.254.100").Run()
//time.Sleep(time.Second * 5)
dnsServiceIp := dns.GetDNSServiceIpFromPod(clientset, restclient, config, util.TrafficManager, namespace)
if err := dns.DNS(dnsServiceIp, namespace); err != nil {
log.Fatal(err)
@@ -195,7 +193,7 @@ func main() {
}
func start() error {
routers, err := baseCfg.GenRouters()
routers, err := nodeConfig.GenRouters()
if err != nil {
return err
}
@@ -213,8 +211,7 @@ func start() error {
return nil
}
func getCIDR(clientset *kubernetes.Clientset, ns string) (result []*net.IPNet, err error) {
result = make([]*net.IPNet, 0)
func getCIDR(clientset *kubernetes.Clientset, namespace string) ([]*net.IPNet, error) {
var cidrs []*net.IPNet
if nodeList, err := clientset.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{}); err == nil {
for _, node := range nodeList.Items {
@@ -222,11 +219,10 @@ func getCIDR(clientset *kubernetes.Clientset, ns string) (result []*net.IPNet, e
ip.Mask = net.CIDRMask(16, 32)
ip.IP = ip.IP.Mask(ip.Mask)
cidrs = append(cidrs, ip)
err = nil
}
}
}
if serviceList, err := clientset.CoreV1().Services(ns).List(context.TODO(), metav1.ListOptions{}); err == nil {
if serviceList, err := clientset.CoreV1().Services(namespace).List(context.TODO(), metav1.ListOptions{}); err == nil {
for _, service := range serviceList.Items {
if ip := net.ParseIP(service.Spec.ClusterIP); ip != nil {
mask := net.CIDRMask(16, 32)
@@ -234,7 +230,7 @@ func getCIDR(clientset *kubernetes.Clientset, ns string) (result []*net.IPNet, e
}
}
}
if podList, err := clientset.CoreV1().Pods(ns).List(context.TODO(), metav1.ListOptions{}); err == nil {
if podList, err := clientset.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{}); err == nil {
for _, pod := range podList.Items {
if ip := net.ParseIP(pod.Status.PodIP); ip != nil {
mask := net.CIDRMask(16, 32)
@@ -242,6 +238,7 @@ func getCIDR(clientset *kubernetes.Clientset, ns string) (result []*net.IPNet, e
}
}
}
result := make([]*net.IPNet, 0)
tempMap := make(map[string]*net.IPNet)
for _, cidr := range cidrs {
if _, found := tempMap[cidr.String()]; !found {
@@ -250,27 +247,7 @@ func getCIDR(clientset *kubernetes.Clientset, ns string) (result []*net.IPNet, e
}
}
if len(result) != 0 {
return
return result, nil
}
return nil, fmt.Errorf("can not found cidr")
}
func RenameNic() {
interfaces, _ := net.Interfaces()
for _, i := range interfaces {
if strings.Contains(i.Name, " ") {
cmd := exec.Command("netsh", []string{
"interface",
"set",
"interface",
fmt.Sprintf("name='%s'", i.Name),
"newname=" + strings.ReplaceAll(i.Name, " ", ""),
}...)
out, err := cmd.CombinedOutput()
if err != nil {
log.Warnf("rename %s --> %s failed, out: %s, error: %v, command: %s",
i.Name, strings.ReplaceAll(i.Name, " ", ""), string(out), err, cmd.Args)
}
}
}
}

135
pkg/route.go
View File

@@ -1,9 +1,8 @@
package main
import (
gost2 "kubevpn/gost"
"github.com/go-log/log"
"kubevpn/gost"
"net"
"strings"
)
@@ -14,12 +13,12 @@ type route struct {
Retries int
}
func (r *route) parseChain() (*gost2.Chain, error) {
chain := gost2.NewChain()
func (r *route) parseChain() (*gost.Chain, error) {
chain := gost.NewChain()
chain.Retries = r.Retries
gid := 1 // group ID
ngroup := gost2.NewNodeGroup()
ngroup := gost.NewNodeGroup()
ngroup.ID = gid
gid++
@@ -37,14 +36,14 @@ func (r *route) parseChain() (*gost2.Chain, error) {
ngroup.AddNode(nodes...)
ngroup.SetSelector(nil,
gost2.WithFilter(
&gost2.FailFilter{
gost.WithFilter(
&gost.FailFilter{
MaxFails: nodes[0].GetInt("max_fails"),
FailTimeout: nodes[0].GetDuration("fail_timeout"),
},
&gost2.InvalidFilter{},
&gost.InvalidFilter{},
),
gost2.WithStrategy(gost2.NewStrategy(nodes[0].Get("strategy"))),
gost.WithStrategy(gost.NewStrategy(nodes[0].Get("strategy"))),
)
chain.AddNodeGroup(ngroup)
@@ -52,8 +51,8 @@ func (r *route) parseChain() (*gost2.Chain, error) {
return chain, nil
}
func parseChainNode(ns string) (nodes []gost2.Node, err error) {
node, err := gost2.ParseNode(ns)
func parseChainNode(ns string) (nodes []gost.Node, err error) {
node, err := gost.ParseNode(ns)
if err != nil {
return
}
@@ -63,28 +62,28 @@ func parseChainNode(ns string) (nodes []gost2.Node, err error) {
}
timeout := node.GetDuration("timeout")
var tr gost2.Transporter
var tr gost.Transporter
switch node.Transport {
case "ssh":
if node.Protocol == "direct" || node.Protocol == "remote" {
tr = gost2.SSHForwardTransporter()
tr = gost.SSHForwardTransporter()
} else {
tr = gost2.SSHTunnelTransporter()
tr = gost.SSHTunnelTransporter()
}
default:
tr = gost2.TCPTransporter()
tr = gost.TCPTransporter()
}
var connector gost2.Connector
var connector gost.Connector
switch node.Protocol {
case "ssu":
connector = gost2.ShadowUDPConnector(node.User)
connector = gost.ShadowUDPConnector(node.User)
case "direct":
connector = gost2.SSHDirectForwardConnector()
connector = gost.SSHDirectForwardConnector()
case "remote":
connector = gost2.SSHRemoteForwardConnector()
connector = gost.SSHRemoteForwardConnector()
default:
connector = gost2.AutoConnector(node.User)
connector = gost.AutoConnector(node.User)
}
host := node.Get("host")
@@ -93,25 +92,25 @@ func parseChainNode(ns string) (nodes []gost2.Node, err error) {
}
node.DialOptions = append(node.DialOptions,
gost2.TimeoutDialOption(timeout),
gost2.HostDialOption(host),
gost.TimeoutDialOption(timeout),
gost.HostDialOption(host),
)
node.ConnectOptions = []gost2.ConnectOption{
gost2.UserAgentConnectOption(node.Get("agent")),
gost2.NoTLSConnectOption(node.GetBool("notls")),
gost2.NoDelayConnectOption(node.GetBool("nodelay")),
node.ConnectOptions = []gost.ConnectOption{
gost.UserAgentConnectOption(node.Get("agent")),
gost.NoTLSConnectOption(node.GetBool("notls")),
gost.NoDelayConnectOption(node.GetBool("nodelay")),
}
handshakeOptions := []gost2.HandshakeOption{
gost2.AddrHandshakeOption(node.Addr),
gost2.HostHandshakeOption(host),
gost2.IntervalHandshakeOption(node.GetDuration("ping")),
gost2.TimeoutHandshakeOption(timeout),
gost2.RetryHandshakeOption(node.GetInt("retry")),
handshakeOptions := []gost.HandshakeOption{
gost.AddrHandshakeOption(node.Addr),
gost.HostHandshakeOption(host),
gost.IntervalHandshakeOption(node.GetDuration("ping")),
gost.TimeoutHandshakeOption(timeout),
gost.RetryHandshakeOption(node.GetInt("retry")),
}
node.Client = &gost2.Client{
node.Client = &gost.Client{
Connector: connector,
Transporter: tr,
}
@@ -121,13 +120,13 @@ func parseChainNode(ns string) (nodes []gost2.Node, err error) {
nd := node.Clone()
nd.Addr = ip
// override the default node address
nd.HandshakeOptions = append(handshakeOptions, gost2.AddrHandshakeOption(ip))
nd.HandshakeOptions = append(handshakeOptions, gost.AddrHandshakeOption(ip))
// One node per IP
nodes = append(nodes, nd)
}
if len(ips) == 0 {
node.HandshakeOptions = handshakeOptions
nodes = []gost2.Node{node}
nodes = []gost.Node{node}
}
return
@@ -139,7 +138,7 @@ func (r *route) GenRouters() (*router, error) {
return nil, err
}
node, err := gost2.ParseNode(r.ServeNodes)
node, err := gost.ParseNode(r.ServeNodes)
if err != nil {
return nil, err
}
@@ -154,23 +153,23 @@ func (r *route) GenRouters() (*router, error) {
}
}
var ln gost2.Listener
var ln gost.Listener
switch node.Transport {
case "tcp":
// Directly use SSH port forwarding if the last chain node is forward+ssh
if chain.LastNode().Protocol == "forward" && chain.LastNode().Transport == "ssh" {
chain.Nodes()[len(chain.Nodes())-1].Client.Connector = gost2.SSHDirectForwardConnector()
chain.Nodes()[len(chain.Nodes())-1].Client.Transporter = gost2.SSHForwardTransporter()
chain.Nodes()[len(chain.Nodes())-1].Client.Connector = gost.SSHDirectForwardConnector()
chain.Nodes()[len(chain.Nodes())-1].Client.Transporter = gost.SSHForwardTransporter()
}
ln, err = gost2.TCPListener(node.Addr)
ln, err = gost.TCPListener(node.Addr)
case "udp":
ln, err = gost2.UDPListener(node.Addr, &gost2.UDPListenConfig{
ln, err = gost.UDPListener(node.Addr, &gost.UDPListenConfig{
TTL: ttl,
Backlog: node.GetInt("backlog"),
QueueSize: node.GetInt("queue"),
})
case "tun":
cfg := gost2.TunConfig{
cfg := gost.TunConfig{
Name: node.Get("name"),
Addr: node.Get("net"),
Peer: node.Get("peer"),
@@ -178,57 +177,57 @@ func (r *route) GenRouters() (*router, error) {
Routes: tunRoutes,
Gateway: node.Get("gw"),
}
ln, err = gost2.TunListener(cfg)
ln, err = gost.TunListener(cfg)
case "tap":
cfg := gost2.TapConfig{
cfg := gost.TapConfig{
Name: node.Get("name"),
Addr: node.Get("net"),
MTU: node.GetInt("mtu"),
Routes: strings.Split(node.Get("route"), ","),
Gateway: node.Get("gw"),
}
ln, err = gost2.TapListener(cfg)
ln, err = gost.TapListener(cfg)
default:
ln, err = gost2.TCPListener(node.Addr)
ln, err = gost.TCPListener(node.Addr)
}
if err != nil {
return nil, err
}
var handler gost2.Handler
var handler gost.Handler
switch node.Protocol {
case "tcp":
handler = gost2.TCPDirectForwardHandler(node.Remote)
handler = gost.TCPDirectForwardHandler(node.Remote)
case "udp":
handler = gost2.UDPDirectForwardHandler(node.Remote)
handler = gost.UDPDirectForwardHandler(node.Remote)
case "tun":
handler = gost2.TunHandler()
handler = gost.TunHandler()
case "tap":
handler = gost2.TapHandler()
handler = gost.TapHandler()
case "dns":
handler = gost2.DNSHandler(node.Remote)
handler = gost.DNSHandler(node.Remote)
default:
// start from 2.5, if remote is not empty, then we assume that it is a forward tunnel.
if node.Remote != "" {
handler = gost2.TCPDirectForwardHandler(node.Remote)
handler = gost.TCPDirectForwardHandler(node.Remote)
} else {
handler = gost2.AutoHandler()
handler = gost.AutoHandler()
}
}
handler.Init(
gost2.AddrHandlerOption(ln.Addr().String()),
gost2.ChainHandlerOption(chain),
gost2.RetryHandlerOption(node.GetInt("retry")), // override the global retry option.
gost2.TimeoutHandlerOption(timeout),
gost2.NodeHandlerOption(node),
gost2.TCPModeHandlerOption(node.GetBool("tcp")),
gost2.IPRoutesHandlerOption(tunRoutes...),
gost.AddrHandlerOption(ln.Addr().String()),
gost.ChainHandlerOption(chain),
gost.RetryHandlerOption(node.GetInt("retry")), // override the global retry option.
gost.TimeoutHandlerOption(timeout),
gost.NodeHandlerOption(node),
gost.TCPModeHandlerOption(node.GetBool("tcp")),
gost.IPRoutesHandlerOption(tunRoutes...),
)
rt := router{
node: node,
server: &gost2.Server{Listener: ln},
server: &gost.Server{Listener: ln},
handler: handler,
chain: chain,
}
@@ -237,12 +236,12 @@ func (r *route) GenRouters() (*router, error) {
}
type router struct {
node gost2.Node
server *gost2.Server
handler gost2.Handler
chain *gost2.Chain
resolver gost2.Resolver
hosts *gost2.Hosts
node gost.Node
server *gost.Server
handler gost.Handler
chain *gost.Chain
resolver gost.Resolver
hosts *gost.Hosts
}
func (r *router) Serve() error {