Method driver.CreateNetwork has 9 return statements (exceeds 4 allowed).

Open

func (d *driver) CreateNetwork(nid string, option map[string]interface{}, nInfo driverapi.NetworkInfo, ipV4Data, ipV6Data []driverapi.IPAMData) error {
    kv, err := kernel.GetKernelVersion()
    if err != nil {
        return fmt.Errorf("failed to check kernel version for ipvlan driver support: %v", err)
    }

Method distributionRouter.fetchManifest has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

func (s *distributionRouter) fetchManifest(ctx context.Context, distrepo distribution.Repository, namedRef reference.Named) (registry.DistributionInspect, error) {
    var distributionInspect registry.DistributionInspect
    if canonicalRef, ok := namedRef.(reference.Canonical); !ok {
        namedRef = reference.TagNameOnly(namedRef)

• Read up
  Read up

Method State.String has 9 return statements (exceeds 4 allowed).

Open

func (s *State) String() string {
    if s.Running {
        if s.Paused {
            return fmt.Sprintf("Up %s (Paused)", units.HumanDuration(time.Now().UTC().Sub(s.StartedAt)))
        }

Method imageRouter.getImagesJSON has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

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

Open

func (i *ImageService) PrepareSnapshot(ctx context.Context, id string, parentImage string, platform *ocispec.Platform, setupInit func(string) error) error {
    var parentSnapshot string
    if parentImage != "" {
        img, err := i.resolveImage(ctx, parentImage)
        if err != nil {

Method container.NewTask has 9 return statements (exceeds 4 allowed).

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

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

Open

func (daemon *Daemon) cleanupMountsFromReaderByID(reader io.Reader, id string, unmount func(target string) error) error {
    if daemon.root == "" {
        return nil
    }
    var errs []string

• Read up
  Read up

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

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 ImageService.verifyImagesProvidePlatform has 9 return statements (exceeds 4 allowed).

Open

func (i *ImageService) verifyImagesProvidePlatform(ctx context.Context, imgs []containerdimages.Image, platform ocispec.Platform, pm platforms.Matcher) error {
    if len(imgs) == 0 {
        return errdefs.NotFound(fmt.Errorf("no images providing the requested platform %s found", platforms.FormatAll(platform)))
    }
    var incompleteImgs []string

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

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))
    }

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