Method ImageService.ImageHistory has 9 return statements (exceeds 4 allowed).

Open

func (i *ImageService) ImageHistory(ctx context.Context, name string, platform *ocispec.Platform) ([]*imagetype.HistoryResponseItem, error) {
    start := time.Now()
    img, err := i.resolveImage(ctx, name)
    if err != nil {
        return nil, err

Method Cluster.UpdateService has 9 return statements (exceeds 4 allowed).

Open

func (c *Cluster) UpdateService(serviceIDOrName string, version uint64, spec swarm.ServiceSpec, flags types.ServiceUpdateOptions, queryRegistry bool) (*swarm.ServiceUpdateResponse, error) {
    var resp *swarm.ServiceUpdateResponse

    err := c.lockedManagerAction(func(ctx context.Context, state nodeState) error {
        err := c.populateNetworkID(ctx, state.controlClient, &spec)

Method controller.Logs has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (r *controller) Logs(ctx context.Context, publisher exec.LogPublisher, options api.LogSubscriptionOptions) error {
    if err := r.checkClosed(); err != nil {
        return err
    }

• Read up
  Read up

Method Cluster.imageWithDigestString has 9 return statements (exceeds 4 allowed).

Open

func (c *Cluster) imageWithDigestString(ctx context.Context, image string, authConfig *registry.AuthConfig) (string, error) {
    ref, err := reference.ParseAnyReference(image)
    if err != nil {
        return "", err
    }

Method Cluster.CreateService has 9 return statements (exceeds 4 allowed).

Open

func (c *Cluster) CreateService(s swarm.ServiceSpec, encodedAuth string, queryRegistry bool) (*swarm.ServiceCreateResponse, error) {
    var resp *swarm.ServiceCreateResponse
    err := c.lockedManagerAction(func(ctx context.Context, state nodeState) error {
        err := c.populateNetworkID(ctx, state.controlClient, &s)
        if err != nil {

Method ImageService.pruneAll has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (i *ImageService) pruneAll(ctx context.Context, imagesToPrune map[string]containerdimages.Image) (*image.PruneReport, error) {
    report := image.PruneReport{}

    ctx, span := tracing.StartSpan(ctx, "ImageService.pruneAll")
    span.SetAttributes(tracing.Attribute("count", len(imagesToPrune)))

• Read up
  Read up

Function getTailReader has 9 return statements (exceeds 4 allowed).

Open

func getTailReader(ctx context.Context, r loggerutils.SizeReaderAt, req int) (loggerutils.SizeReaderAt, int, error) {
    size := r.Size()
    if req < 0 {
        return nil, 0, errdefs.InvalidParameter(errors.Errorf("invalid number of lines to tail: %d", req))
    }

Function ValidateLogOpt has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func ValidateLogOpt(cfg map[string]string) error {
    address, err := parseAddress(cfg["gelf-address"])
    if err != nil {
        return err
    }

• Read up
  Read up

Method Daemon.localNetworksPrune has 9 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) localNetworksPrune(ctx context.Context, pruneFilters filters.Args) *network.PruneReport {
    rep := &network.PruneReport{}

    until, _ := getUntilFromPruneFilters(pruneFilters)

Method Daemon.allocateNetwork has 9 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) allocateNetwork(ctx context.Context, cfg *config.Config, ctr *container.Container) (retErr error) {
    if daemon.netController == nil {
        return nil
    }

Method Daemon.update has 9 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) update(name string, hostConfig *container.HostConfig) error {
    if hostConfig == nil {
        return nil
    }

Method Daemon.ContainersPrune has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (*container.PruneReport, error) {
    if !daemon.pruneRunning.CompareAndSwap(false, true) {
        return nil, errPruneRunning
    }
    defer daemon.pruneRunning.Store(false)

• Read up
  Read up

Method ImageService.CommitImage has 9 return statements (exceeds 4 allowed).

Open

func (i *ImageService) CommitImage(ctx context.Context, c backend.CommitConfig) (image.ID, error) {
    if err := ctx.Err(); err != nil {
        return "", err
    }

Method Daemon.setWindowsCredentialSpec has 9 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) setWindowsCredentialSpec(c *container.Container, s *specs.Spec) error {
    if c.HostConfig == nil || c.HostConfig.SecurityOpt == nil {
        return nil
    }

Method Daemon.logNodeEvent has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) logNodeEvent(action swarmapi.WatchActionKind, node *swarmapi.Node, oldNode *swarmapi.Node) {
    name := node.Spec.Annotations.Name
    if name == "" && node.Description != nil {
        name = node.Description.Hostname
    }

• Read up
  Read up

Method Daemon.disconnectFromNetwork has 9 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) disconnectFromNetwork(ctx context.Context, ctr *container.Container, n *libnetwork.Network, force bool) error {
    var (
        ep   *libnetwork.Endpoint
        sbox *libnetwork.Sandbox
    )

Function readFrozenImageList has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func readFrozenImageList(ctx context.Context, dockerfilePath string, images []string) (map[string]string, error) {
    f, err := os.Open(dockerfilePath)
    if err != nil {
        return nil, errors.Wrap(err, "error reading dockerfile")
    }

• Read up
  Read up

Method walker.walk has 9 return statements (exceeds 4 allowed).

Open

func (w *walker) walk(path string, i1, i2 os.FileInfo) (err error) {
    // Register these nodes with the return trees, unless we're still at the
    // (already-created) roots:
    if path != "/" {
        if err := walkchunk(path, i1, w.dir1, w.root1); err != nil {

Method layerStore.registerWithDescriptor has 9 return statements (exceeds 4 allowed).

Open

func (ls *layerStore) registerWithDescriptor(ts io.Reader, parent ChainID, descriptor distribution.Descriptor) (Layer, error) {
    // cErr is used to hold the error which will always trigger
    // cleanup of creates sources but may not be an error returned
    // to the caller (already exists).
    var cErr error

Method layerStore.RegisterByGraphID has 9 return statements (exceeds 4 allowed).

Open

func (ls *layerStore) RegisterByGraphID(graphID string, parent ChainID, diffID DiffID, tarDataFile string, size int64) (Layer, error) {
    // err is used to hold the error which will always trigger
    // cleanup of creates sources but may not be an error returned
    // to the caller (already exists).
    var err error