Function New has 166 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func New(info logger.Info) (logger.Logger, error) {
    hostname, err := info.Hostname()
    if err != nil {
        return nil, fmt.Errorf("%s: cannot access hostname to set source field", driverName)
    }

Method Daemon.registerMountPoints has 166 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (daemon *Daemon) registerMountPoints(container *container.Container, hostConfig *containertypes.HostConfig, defaultReadOnlyNonRecursive bool) (retErr error) {
    binds := map[string]bool{}
    mountPoints := map[string]*volumemounts.MountPoint{}
    parser := volumemounts.NewParser()

Method Controller.reservePools has a Cognitive Complexity of 52 (exceeds 20 allowed). Consider refactoring.

Open

func (c *Controller) reservePools() {
    networks, err := c.getNetworks()
    if err != nil {
        log.G(context.TODO()).Warnf("Could not retrieve networks from local store during ipam allocation for existing networks: %v", err)
        return

• Read up
  Read up

Method ImageService.setupFilters has a Cognitive Complexity of 52 (exceeds 20 allowed). Consider refactoring.

Open

func (i *ImageService) setupFilters(ctx context.Context, imageFilters filters.Args) (filterFunc imageFilterFunc, outErr error) {
    var fltrs []imageFilterFunc
    err := imageFilters.WalkValues("before", func(value string) error {
        img, err := i.GetImage(ctx, value, backend.GetImageOpts{})
        if err != nil {

• Read up
  Read up

Function changes has a Cognitive Complexity of 52 (exceeds 20 allowed). Consider refactoring.

Open

func changes(layers []string, rw string, dc deleteChange, sc skipChange) ([]Change, error) {
    var (
        changes     []Change
        changedDirs = make(map[string]struct{})
    )

• Read up
  Read up

Method Plugin.Set has a Cognitive Complexity of 51 (exceeds 20 allowed). Consider refactoring.

Open

func (p *Plugin) Set(args []string) error {
    p.mu.Lock()
    defer p.mu.Unlock()

    if p.PluginObj.Enabled {

• Read up
  Read up

Method windowsParser.validateMountConfigReg has a Cognitive Complexity of 51 (exceeds 20 allowed). Consider refactoring.

Open

func (p *windowsParser) validateMountConfigReg(mnt *mount.Mount, additionalValidators ...mountValidator) error {
    if len(mnt.Target) == 0 {
        return &errMountConfig{mnt, errMissingField("Target")}
    }
    for _, v := range additionalValidators {

• Read up
  Read up

Method Info.ExtraAttributes has a Cognitive Complexity of 51 (exceeds 20 allowed). Consider refactoring.

Open

func (info *Info) ExtraAttributes(keyMod func(string) string) (map[string]string, error) {
    extra := make(map[string]string)
    labels, ok := info.Config["labels"]
    if ok && len(labels) > 0 {
        for _, l := range strings.Split(labels, ",") {

• Read up
  Read up

Method Daemon.containerStart has a Cognitive Complexity of 51 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) containerStart(ctx context.Context, daemonCfg *configStore, container *container.Container, checkpoint string, checkpointDir string, resetRestartManager bool) (retErr error) {
    ctx, span := otel.Tracer("").Start(ctx, "daemon.containerStart", trace.WithAttributes(
        attribute.String("container.ID", container.ID),
        attribute.String("container.Name", container.Name)))
    defer span.End()

• Read up
  Read up

Method tarSum.Read has a Cognitive Complexity of 51 (exceeds 20 allowed). Consider refactoring.

Open

func (ts *tarSum) Read(buf []byte) (int, error) {
    if ts.finished {
        return ts.bufWriter.Read(buf)
    }
    if len(ts.bufData) < len(buf) {

• Read up
  Read up

Controller has 40 methods (exceeds 20 allowed). Consider refactoring.

Open

type Controller struct {
    id               string
    drvRegistry      drvregistry.Networks
    ipamRegistry     drvregistry.IPAMs
    sandboxes        map[string]*Sandbox

Method EndpointRecord.Unmarshal has 61 return statements (exceeds 4 allowed).

Open

func (m *EndpointRecord) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx

Method linuxParser.validateMountConfigImpl has a Cognitive Complexity of 50 (exceeds 20 allowed). Consider refactoring.

Open

func (p *linuxParser) validateMountConfigImpl(mnt *mount.Mount, validateBindSourceExists bool) error {
    if len(mnt.Target) == 0 {
        return &errMountConfig{mnt, errMissingField("Target")}
    }

• Read up
  Read up

Method Daemon.ProcessEvent has a Cognitive Complexity of 50 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) ProcessEvent(id string, e libcontainerdtypes.EventType, ei libcontainerdtypes.EventInfo) error {
    c, err := daemon.GetContainer(id)
    if err != nil {
        return errors.Wrapf(err, "could not find container %s", id)
    }

• Read up
  Read up

Method containerRouter.postContainersCreate has 154 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

File client.go has 628 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package remote // import "github.com/docker/docker/libcontainerd/remote"

import (
    "context"
    "encoding/json"

Function withMounts has 151 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func withMounts(daemon *Daemon, daemonCfg *configStore, c *container.Container, mounts []container.Mount) coci.SpecOpts {
    return func(ctx context.Context, _ coci.Client, _ *containers.Container, s *coci.Spec) (err error) {
        sortMounts(mounts)

        userMounts := make(map[string]struct{})

Endpoint has 38 methods (exceeds 20 allowed). Consider refactoring.

Open

type Endpoint struct {
    name         string
    id           string
    network      *Network
    iface        *EndpointInterface

Method NetworkEntry.Unmarshal has 150 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (m *NetworkEntry) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx

Method NetworkEvent.Unmarshal has 149 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (m *NetworkEvent) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx