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

Open

func kernelSupportsRecursivelyReadOnly() error {
    fn := func() error {
        tmpMnt, err := os.MkdirTemp("", "moby-detect-rro")
        if err != nil {
            return fmt.Errorf("failed to create a temp directory: %w", err)

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

Open

func (i *ImageService) GetImage(ctx context.Context, refOrID string, options backend.GetImageOpts) (*image.Image, error) {
    desc, err := i.resolveImage(ctx, refOrID)
    if err != nil {
        return nil, err
    }

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

Open

func (i *ImageService) ImagesPrune(ctx context.Context, fltrs filters.Args) (*image.PruneReport, error) {
    if !i.pruneRunning.CompareAndSwap(false, true) {
        return nil, errPruneRunning
    }
    defer i.pruneRunning.Store(false)

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

Open

func monitor(d *Daemon, c *container.Container, stop chan struct{}, probe probe) {
    probeInterval := timeoutWithDefault(c.Config.Healthcheck.Interval, defaultProbeInterval)
    startInterval := timeoutWithDefault(c.Config.Healthcheck.StartInterval, defaultStartInterval)
    startPeriod := timeoutWithDefault(c.Config.Healthcheck.StartPeriod, defaultStartPeriod)

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

Open

func readConfig(ctx context.Context, store content.Provider, desc ocispec.Descriptor, out interface{}) error {
    data, err := content.ReadBlob(ctx, store, desc)
    if err != nil {
        err = errors.Wrapf(err, "failed to read config content")
        if cerrdefs.IsNotFound(err) {

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.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

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

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)

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

Open

func getUser(c *container.Container, username string) (specs.User, error) {
    var usr specs.User
    passwdPath, err := resourcePath(c, user.GetPasswdPath)
    if err != nil {
        return usr, err

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

Open

func newROLayerForImage(ctx context.Context, imgDesc *ocispec.Descriptor, i *ImageService, platform *ocispec.Platform) (builder.ROLayer, error) {
    if imgDesc == nil {
        return nil, fmt.Errorf("can't make an RO layer for a nil image :'(")
    }

Function NodeFromGRPC has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func NodeFromGRPC(n swarmapi.Node) types.Node {
    node := types.Node{
        ID: n.ID,
        Spec: types.NodeSpec{
            Role:         types.NodeRole(strings.ToLower(n.Spec.DesiredRole.String())),

• Read up
  Read up

Method Controller.Start has 5 return statements (exceeds 4 allowed).

Open

func (p *Controller) Start(ctx context.Context) error {
    p.logger.Debug("Start")

    pl, err := p.backend.Get(p.pluginID)
    if err != nil {

Method Cluster.GetUnlockKey has 5 return statements (exceeds 4 allowed).

Open

func (c *Cluster) GetUnlockKey() (string, error) {
    var resp *swarmapi.GetUnlockKeyResponse
    if err := c.lockedManagerAction(func(ctx context.Context, state nodeState) error {
        client := swarmapi.NewCAClient(state.grpcConn)

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

Open

func convertSelector(ctx context.Context, cc swarmapi.ControlClient, selector *backend.LogSelector) (*swarmapi.LogSelector, error) {
    // don't rely on swarmkit to resolve IDs, do it ourselves
    swarmSelector := &swarmapi.LogSelector{}
    for _, s := range selector.Services {
        service, err := getService(ctx, cc, s, false)

Method Controller.Remove has 5 return statements (exceeds 4 allowed).

Open

func (p *Controller) Remove(ctx context.Context) error {
    p.logger.Debug("Remove")

    pl, err := p.backend.Get(p.pluginID)
    if err != nil {

Method executor.Describe has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (e *executor) Describe(ctx context.Context) (*api.NodeDescription, error) {
    info, err := e.backend.SystemInfo(ctx)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Method controller.Remove has 5 return statements (exceeds 4 allowed).

Open

func (r *controller) Remove(ctx context.Context) error {
    if err := r.checkClosed(); err != nil {
        return err
    }

Method Cluster.Info has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (c *Cluster) Info(ctx context.Context) types.Info {
    info := types.Info{
        NodeAddr: c.GetAdvertiseAddress(),
    }
    c.mu.RLock()

• Read up
  Read up

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

Open

func getNode(ctx context.Context, c swarmapi.ControlClient, input string) (*swarmapi.Node, error) {
    // GetNode to match via full ID.
    if rg, err := c.GetNode(ctx, &swarmapi.GetNodeRequest{NodeID: input}); err == nil {
        return rg.Node, nil
    }

Method containerConfig.setTask has 5 return statements (exceeds 4 allowed).

Open

func (c *containerConfig) setTask(t *api.Task, node *api.NodeDescription) error {
    if t.Spec.GetContainer() == nil && t.Spec.GetAttachment() == nil {
        return exec.ErrRuntimeUnsupported
    }