Method ConnectOptions.addRouteDynamic has 78 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *ConnectOptions) addRouteDynamic(ctx context.Context) error {
    tunName, e := c.GetTunDeviceName()
    if e != nil {
        return e
    }

Method Options.Connect has a Cognitive Complexity of 31 (exceeds 20 allowed). Consider refactoring.

Open

func (option *Options) Connect(ctx context.Context, sshConfig *pkgssh.SshConfig, transferImage bool, portBindings nat.PortMap) error {
    switch option.ConnectMode {
    case ConnectModeHost:
        daemonCli := daemon.GetClient(false)
        if daemonCli == nil {

• Read up
  Read up

Method ConnectOptions.portForward has 77 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *ConnectOptions) portForward(ctx context.Context, portPair []string) error {
    firstCtx, firstCancelFunc := context.WithCancel(ctx)
    defer firstCancelFunc()
    var errChan = make(chan error, 1)
    go func() {

Method Options.CreateConnectContainer has 77 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (option *Options) CreateConnectContainer(portBindings nat.PortMap) (*RunConfig, error) {
    portMap, portSet, err := option.GetExposePort(portBindings)
    if err != nil {
        return nil, err
    }

Function createTun has 76 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func createTun(cfg Config) (conn net.Conn, itf *net.Interface, err error) {
    if cfg.Addr == "" && cfg.Addr6 == "" {
        err = fmt.Errorf("IPv4 address and IPv6 address can not be empty at same time")
        return
    }

Function NewKubeVPNCommand has 73 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func NewKubeVPNCommand() *cobra.Command {
    var cmd = &cobra.Command{
        Use:   "kubevpn",
        Short: i18n.T("KubeVPN offers a Cloud-Native Dev Environment that seamlessly connects to your Kubernetes cluster network."),
        Long: templates.LongDesc(`

Method ConnectOptions.startLocalTunServe has 73 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *ConnectOptions) startLocalTunServe(ctx context.Context, forwardAddress string, lite bool) (err error) {
    log.Debugf("IPv4: %s, IPv6: %s", c.localTunIPv4.IP.String(), c.localTunIPv6.IP.String())

    var cidrList []*net.IPNet
    if !lite {

Function run has 71 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func run(ctx context.Context, cli *client.Client, dockerCli *command.DockerCli, runConfig *RunConfig) (id string, err error) {
    rand.New(rand.NewSource(time.Now().UnixNano()))

    var config = runConfig.config
    var hostConfig = runConfig.hostConfig

Function createTun has 71 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func createTun(cfg Config) (conn net.Conn, itf *net.Interface, err error) {
    if cfg.Addr == "" && cfg.Addr6 == "" {
        err = fmt.Errorf("IPv4 address and IPv6 address can not be empty at same time")
        return
    }

Function file_dhcpserver_proto_init has 71 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func file_dhcpserver_proto_init() {
    if File_dhcpserver_proto != nil {
        return
    }
    if !protoimpl.UnsafeEnabled {

Function main has 70 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func main() {
    // git describe --tags `git rev-list --tags --max-count=1`
    commitId, err2 := exec.Command("git", "rev-list", "--tags", "--max-count=1").Output()
    if err2 != nil {
        panic(err2)

Function ConvertK8sApiServerToDomain has 69 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func ConvertK8sApiServerToDomain(kubeConfigPath string) (newPath string, err error) {
    var kubeConfigBytes []byte
    kubeConfigBytes, err = os.ReadFile(kubeConfigPath)
    if err != nil {
        return

Function init has 69 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func init() {
    http.Handle("/ws", websocket.Handler(func(conn *websocket.Conn) {
        var sshConfig pkgssh.SshConfig
        b := conn.Request().Header.Get("ssh")
        if err := json.Unmarshal([]byte(b), &sshConfig); err != nil {

Method CloneOptions.SyncDir has a Cognitive Complexity of 29 (exceeds 20 allowed). Consider refactoring.

Open

func (d *CloneOptions) SyncDir(ctx context.Context, labels string) error {
    list, err := util.GetRunningPodList(ctx, d.targetClientset, d.TargetNamespace, labels)
    if err != nil {
        return err
    }

• Read up
  Read up

Method Manager.RentIP has a Cognitive Complexity of 29 (exceeds 20 allowed). Consider refactoring.

Open

func (m *Manager) RentIP(ctx context.Context) (*net.IPNet, *net.IPNet, error) {
    addrs, _ := net.InterfaceAddrs()
    var isAlreadyExistedFunc = func(ip net.IP) bool {
        for _, addr := range addrs {
            if addr == nil {

• Read up
  Read up

Function CmdDisconnect has 68 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func CmdDisconnect(f cmdutil.Factory) *cobra.Command {
    var all = false
    var clusterIDs []string
    cmd := &cobra.Command{
        Use:   "disconnect",

Function InjectVPNSidecar has 68 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func InjectVPNSidecar(ctx1 context.Context, factory util.Factory, namespace, workload string, c util2.PodRouteConfig) error {
    object, err := util2.GetUnstructuredObject(factory, namespace, workload)
    if err != nil {
        return err
    }

Method Server.Get has 68 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (svr *Server) Get(ctx context.Context, req *rpc.GetRequest) (*rpc.GetResponse, error) {
    if svr.connect == nil || svr.connect.Context() == nil {
        return nil, errors.New("not connected")
    }
    if svr.resourceLists == nil {

Function NewStack has 68 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
    s := stack.New(stack.Options{
        NetworkProtocols: []stack.NetworkProtocolFactory{
            ipv4.NewProtocol,
            ipv6.NewProtocol,

Method PortForwarder.handleConnection has 67 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (pf *PortForwarder) handleConnection(conn net.Conn, port ForwardedPort) {
    defer conn.Close()

    if pf.out != nil {
        fmt.Fprintf(pf.out, "Handling connection for %d\n", port.Local)