Method buildRouter.postPrune has 5 return statements (exceeds 4 allowed).

Open

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

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

Open

func lookupGroup(groupStr, filepath string) (int, error) {
    // if the string is actually a gid integer, parse to int and return
    // as we don't need to translate with the help of files
    gid, err := strconv.Atoi(groupStr)
    if err == nil {

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

Open

func resolveCmdLine(cmd instructions.ShellDependantCmdLine, runConfig *container.Config, os, command, original string) ([]string, bool) {
    // Make sure we return an empty array if there is no cmd.CmdLine
    if len(cmd.CmdLine) == 0 {
        return []string{}, runConfig.ArgsEscaped
    }

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

Open

func GetWithStatusError(address string) (resp *http.Response, err error) {
    resp, err = http.Get(address) // #nosec G107 -- ignore G107: Potential HTTP request made with variable url
    if err != nil {
        if uerr, ok := err.(*url.Error); ok {
            if derr, ok := uerr.Err.(*net.DNSError); ok && !derr.IsTimeout {

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
    }

Method v1Endpoint.ping has 5 return statements (exceeds 4 allowed).

Open

func (e *v1Endpoint) ping() (v1PingResult, error) {
    if e.String() == IndexServer {
        // Skip the check, we know this one is valid
        // (and we never want to fallback to http in case of error)
        return v1PingResult{}, nil

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

Open

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

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

Open

func lookupUser(userStr, filepath string) (int, error) {
    // if the string is actually a uid integer, parse to int and return
    // as we don't need to translate with the help of files
    uid, err := strconv.Atoi(userStr)
    if err == nil {

Method Builder.build has 5 return statements (exceeds 4 allowed).

Open

func (b *Builder) build(ctx context.Context, source builder.Source, dockerfile *parser.Result) (*builder.Result, error) {
    defer b.imageSources.Unmount()

    stages, metaArgs, err := instructions.Parse(dockerfile.AST, nil)
    if err != nil {

Method grpcRouter.serveGRPC has 5 return statements (exceeds 4 allowed).

Open

func (gr *grpcRouter) serveGRPC(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    h, ok := w.(http.Hijacker)
    if !ok {
        return errors.New("handler does not support hijack")
    }

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

Open

func (ctr *container) NewTask(_ context.Context, _ string, withStdin bool, attachStdio libcontainerdtypes.StdioCallback) (_ libcontainerdtypes.Task, retErr error) {
    ctr.mu.Lock()
    defer ctr.mu.Unlock()

    switch {

• Read up
  Read up

Method ImageService.getBestPresentImageManifest has 5 return statements (exceeds 4 allowed).

Open

func (i *ImageService) getBestPresentImageManifest(ctx context.Context, img containerdimages.Image, pm platforms.MatchComparer) (*ImageManifest, error) {
    var best *ImageManifest
    var bestPlatform ocispec.Platform

    err := i.walkImageManifests(ctx, img, func(im *ImageManifest) error {

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

Method ImageService.PushImage has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (i *ImageService) PushImage(ctx context.Context, sourceRef reference.Named, platform *ocispec.Platform, metaHeaders map[string][]string, authConfig *registry.AuthConfig, outStream io.Writer) (retErr error) {
    start := time.Now()
    defer func() {
        if retErr == nil {
            dimages.ImageActions.WithValues("push").UpdateSince(start)

• Read up
  Read up

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

Open

func GetTimestamp(value string, reference time.Time) (string, error) {
    if d, err := time.ParseDuration(value); value != "0" && err == nil {
        return strconv.FormatInt(reference.Add(-d).Unix(), 10), nil
    }

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 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 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 containerRouter.getContainersJSON has 5 return statements (exceeds 4 allowed).

Open

func (c *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 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
    }