Method containerRouter.getContainersJSON has 5 return statements (exceeds 4 allowed).

Open

func (s *containerRouter) getContainersJSON(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    if err := httputils.ParseForm(r); err != nil {
        return err
    }
    filter, err := filters.FromJSON(r.Form.Get("filters"))

Method Args.MatchKVList has 5 return statements (exceeds 4 allowed).

Open

func (args Args) MatchKVList(key string, sources map[string]string) bool {
    fieldValues := args.fields[key]

    // do not filter if there is no filter set or cannot determine filter
    if len(fieldValues) == 0 {

Method gitRepo.checkout has 5 return statements (exceeds 4 allowed).

Open

func (repo gitRepo) checkout(root string) (string, error) {
    // Try checking out by ref name first. This will work on branches and sets
    // .git/HEAD to the current branch name
    if output, err := repo.gitWithinDir(root, "checkout", repo.ref); err != nil {
        // If checking out by branch name fails check out the last fetched ref

Function FromArchive has 5 return statements (exceeds 4 allowed).

Open

func FromArchive(tarStream io.Reader) (builder.Source, error) {
    root, err := longpath.MkdirTemp("", "docker-builder")
    if err != nil {
        return nil, err
    }

Method Worker.ResolveSourceMetadata has 5 return statements (exceeds 4 allowed).

Open

func (w *Worker) ResolveSourceMetadata(ctx context.Context, op *pb.SourceOp, opt sourceresolver.Opt, sm *session.Manager, g session.Group) (*sourceresolver.MetaResponse, error) {
    if opt.SourcePolicies != nil {
        return nil, errors.New("source policies can not be set for worker")
    }

Method volumeRouter.putVolumesUpdate has 5 return statements (exceeds 4 allowed).

Open

func (v *volumeRouter) putVolumesUpdate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    if !v.cluster.IsManager() {
        return errdefs.Unavailable(errors.New("volume update only valid for cluster volumes, but swarm is unavailable"))
    }

Function getAccountIdentity has 5 return statements (exceeds 4 allowed).

Open

func getAccountIdentity(ctx context.Context, builder *Builder, accountName string, ctrRootPath string, state *dispatchState) (idtools.Identity, error) {
    // If this is potentially a string SID then attempt to convert it to verify
    // this, otherwise continue looking for the account.
    if strings.HasPrefix(accountName, "S-") || strings.HasPrefix(accountName, "s-") {
        sid, err := windows.StringToSid(accountName)

Method swarmRouter.updateService has 5 return statements (exceeds 4 allowed).

Open

func (sr *swarmRouter) updateService(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    var service types.ServiceSpec
    if err := httputils.ReadJSON(r, &service); err != nil {
        return err
    }

Function fixPermissionsWindows has 5 return statements (exceeds 4 allowed).

Open

func fixPermissionsWindows(source, destination, SID string) error {
    privileges := []string{winio.SeRestorePrivilege, idtools.SeTakeOwnershipPrivilege}

    err := winio.EnableProcessPrivileges(privileges)
    if err != nil {

Method swarmRouter.getServices has 5 return statements (exceeds 4 allowed).

Open

func (sr *swarmRouter) getServices(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    if err := httputils.ParseForm(r); err != nil {
        return err
    }
    filter, err := filters.FromJSON(r.Form.Get("filters"))

Method networkRouter.deleteNetwork has 5 return statements (exceeds 4 allowed).

Open

func (n *networkRouter) deleteNetwork(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    if err := httputils.ParseForm(r); err != nil {
        return err
    }

Function toBuildkitExtraHosts has 5 return statements (exceeds 4 allowed).

Open

func toBuildkitExtraHosts(inp []string, hostGatewayIP net.IP) (string, error) {
    if len(inp) == 0 {
        return "", nil
    }
    hosts := make([]string, 0, len(inp))

Method imageRouter.getImagesSearch has 5 return statements (exceeds 4 allowed).

Open

func (ir *imageRouter) getImagesSearch(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    if err := httputils.ParseForm(r); err != nil {
        return err
    }

Function dispatchTriggeredOnBuild has 5 return statements (exceeds 4 allowed).

Open

func dispatchTriggeredOnBuild(ctx context.Context, d dispatchRequest, triggers []string) error {
    fmt.Fprintf(d.builder.Stdout, "# Executing %d build trigger", len(triggers))
    if len(triggers) > 1 {
        fmt.Fprint(d.builder.Stdout, "s")
    }

Method task.Pause has 5 return statements (exceeds 4 allowed).

Open

func (t *task) Pause(_ context.Context) error {
    if t.ctr.ociSpec.Windows.HyperV == nil {
        return cerrdefs.ErrNotImplemented
    }

Function validateAddress has 5 return statements (exceeds 4 allowed).

Open

func validateAddress(address string, subnet netip.Prefix, subnetFamily ipFamily) error {
    if address == "" {
        return nil
    }
    addr, err := netip.ParseAddr(address)

Method container.createIO has 5 return statements (exceeds 4 allowed).

Open

func (c *container) createIO(fifos *cio.FIFOSet, stdinCloseSync chan containerd.Process, attachStdio libcontainerdtypes.StdioCallback) (cio.IO, error) {
    var (
        io  *cio.DirectIO
        err error
    )

Method task.Exec has 5 return statements (exceeds 4 allowed).

Open

func (t *task) Exec(ctx context.Context, processID string, spec *specs.Process, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (_ libcontainerdtypes.Process, retErr error) {
    hcsContainer, err := t.getHCSContainer()
    if err != nil {
        return nil, err
    }

Method task.Resume has 5 return statements (exceeds 4 allowed).

Open

func (t *task) Resume(ctx context.Context) error {
    if t.ctr.ociSpec.Windows.HyperV == nil {
        return errors.New("cannot resume Windows Server Containers")
    }

Method container.NewTask has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (c *container) NewTask(ctx context.Context, checkpointDir string, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (libcontainerdtypes.Task, error) {
    var (
        checkpoint     *types.Descriptor
        t              containerd.Task
        rio            cio.IO

• Read up
  Read up