Function StartClient has 91 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func StartClient(ctx context.Context, localDir string, localAddr, remoteAddr string) error {
    if err := MakeSureGui(); err != nil {
        return err
    }
    err := cmdutil.SetConfigDataLocationsFromFlags(pkgconfig.GetSyncthingPath(), "", "")

Function handle has 90 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func handle(ctx context.Context, tcpConn net.Conn, udpConn *net.UDPConn) {
    defer udpConn.Close()
    log.Debugf("[TUN-UDP] %s <-> %s", tcpConn.RemoteAddr(), udpConn.LocalAddr())
    errChan := make(chan error, 2)
    go func() {

Function serve has 89 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func serve(w http.ResponseWriter, r *http.Request, admit admitHandler) {
    var body []byte
    if r.Body != nil {
        if data, err := io.ReadAll(r.Body); err == nil {
            body = data

Method Config.watchServiceToAddHosts has 89 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *Config) watchServiceToAddHosts(ctx context.Context, serviceInterface v13.ServiceInterface, hosts []Entry) {
    ticker := time.NewTicker(time.Second * 15)
    defer ticker.Stop()
    immediate := make(chan struct{}, 1)
    immediate <- struct{}{}

Method wsHandler.handle has 88 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (w *wsHandler) handle(c context.Context) {
    ctx, f := context.WithCancel(c)
    defer f()

    cli, err := pkgssh.DialSshRemote(ctx, w.sshConfig, ctx.Done())

Function SshJump has 28 return statements (exceeds 4 allowed).

Open

func SshJump(ctx context.Context, conf *SshConfig, flags *pflag.FlagSet, print bool) (path string, err error) {
    if conf.Addr == "" && conf.ConfigAlias == "" {
        if flags != nil {
            lookup := flags.Lookup("kubeconfig")
            if lookup != nil {

Method Options.Connect has 87 lines of code (exceeds 50 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 {

Function CmdClone has a Cognitive Complexity of 33 (exceeds 20 allowed). Consider refactoring.

Open

func CmdClone(f cmdutil.Factory) *cobra.Command {
    var options = handler.CloneOptions{}
    var sshConf = &pkgssh.SshConfig{}
    var extraRoute = &handler.ExtraRouteInfo{}
    var transferImage bool

• Read up
  Read up

UnimplementedDaemonServer has 22 methods (exceeds 20 allowed). Consider refactoring.

Open

type UnimplementedDaemonServer struct {
}

Method Server.redirectToSudoDaemon has 83 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (svr *Server) redirectToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServer) (e error) {
    cli := svr.GetClient(true)
    if cli == nil {
        return fmt.Errorf("sudo daemon not start")
    }

Function CmdSSH has 82 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func CmdSSH(_ cmdutil.Factory) *cobra.Command {
    var sshConf = &pkgssh.SshConfig{}
    var ExtraCIDR []string
    cmd := &cobra.Command{
        Use:   "ssh",

Function CmdGet has 82 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func CmdGet(f cmdutil.Factory) *cobra.Command {
    var printFlags = cmdget.NewGetPrintFlags()
    cmd := &cobra.Command{
        Use:    "get",
        Hidden: true,

Function legacyWaitExitOrRemoved has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.

Open

func legacyWaitExitOrRemoved(ctx context.Context, apiClient client.APIClient, containerID string, waitRemove bool) <-chan int {
    var removeErr error
    statusChan := make(chan int)
    exitCode := 125

• Read up
  Read up

Method Server.redirectConnectForkToSudoDaemon has 81 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (svr *Server) redirectConnectForkToSudoDaemon(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectServer) (err error) {
    cli := svr.GetClient(true)
    if cli == nil {
        return fmt.Errorf("sudo daemon not start")
    }

Method admissionReviewHandler.handleCreate has 80 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (h *admissionReviewHandler) handleCreate(ar v1.AdmissionReview) *v1.AdmissionResponse {
    raw := ar.Request.Object.Raw
    pod := corev1.Pod{}
    deserializer := codecs.UniversalDeserializer()
    if _, _, err := deserializer.Decode(raw, nil, &pod); err != nil {

File gssapi_ccache.go has 508 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package ssh

import (
    "bytes"
    "encoding/binary"

Method CCache.writeCredential has 24 return statements (exceeds 4 allowed).

Open

func (c *CCache) writeCredential(cred *Credential, endian *binary.ByteOrder) ([]byte, error) {
    var byteString bytes.Buffer
    var err error

    b := &byteString

daemonClient has 21 methods (exceeds 20 allowed). Consider refactoring.

Open

type daemonClient struct {
    cc grpc.ClientConnInterface
}

Function runContainer has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func runContainer(ctx context.Context, dockerCli command.Cli, runConfig *RunConfig) error {
    config := runConfig.config
    stdout, stderr := dockerCli.Out(), dockerCli.Err()
    apiClient := dockerCli.Client()

Method Server.ConnectFork has 79 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (svr *Server) ConnectFork(req *rpc.ConnectRequest, resp rpc.Daemon_ConnectForkServer) (err error) {
    defer func() {
        util.InitLoggerForServer(true)
        log.SetOutput(svr.LogFile)
        config.Debug = false