Method containerRouter.postContainersCreate has a Cognitive Complexity of 99 (exceeds 20 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 {

• Read up
  Read up

File endpoint.go has 952 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// FIXME(thaJeztah): remove once we are a module; the go:build directive prevents go from downgrading language version to go1.16:
//go:build go1.21

package libnetwork

Method NodeEvent.Unmarshal has a Cognitive Complexity of 92 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method PartialLogEntryMetadata.Unmarshal has a Cognitive Complexity of 92 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

File container_operations.go has 926 lines of code (exceeds 500 allowed). Consider refactoring.

Open

// FIXME(thaJeztah): remove once we are a module; the go:build directive prevents go from downgrading language version to go1.16:
//go:build go1.21

package daemon // import "github.com/docker/docker/daemon"

Method EndpointRecord.Unmarshal has 325 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

File local_windows.go has 912 lines of code (exceeds 500 allowed). Consider refactoring.

Open

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

// This package contains the legacy in-proc calls in HCS using the v1 schema
// for Windows runtime purposes.

File oci_linux.go has 904 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package daemon // import "github.com/docker/docker/daemon"

import (
    "context"
    "fmt"

File network.go has 888 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package daemon // import "github.com/docker/docker/daemon"

import (
    "context"
    "errors"

File pull_v2.go has 874 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package distribution // import "github.com/docker/docker/distribution"

import (
    "context"
    "encoding/json"

Function includeContainerInList has a Cognitive Complexity of 84 (exceeds 20 allowed). Consider refactoring.

Open

func includeContainerInList(container *container.Snapshot, filter *listContext) iterationAction {
    // Do not include container if it's in the list before the filter container.
    // Set the filter container to nil to include the rest of containers after this one.
    if filter.beforeFilter != nil {
        if container.ID == filter.beforeFilter.ID {

• Read up
  Read up

Function setupSeccomp has a Cognitive Complexity of 82 (exceeds 20 allowed). Consider refactoring.

Open

func setupSeccomp(config *Seccomp, rs *specs.Spec) (*specs.LinuxSeccomp, error) {
    if config == nil {
        return nil, nil
    }

• Read up
  Read up

Method LayerDownloadManager.makeDownloadFunc has a Cognitive Complexity of 82 (exceeds 20 allowed). Consider refactoring.

Open

func (ldm *LayerDownloadManager) makeDownloadFunc(descriptor DownloadDescriptor, parentLayer layer.ChainID, parentDownload *downloadTransfer) doFunc {
    return func(progressChan chan<- progress.Progress, start <-chan struct{}, inactive chan<- struct{}) transfer {
        d := &downloadTransfer{
            transfer:   newTransfer(),
            layerStore: ldm.layerStore,

• Read up
  Read up

Method Controller.NewNetwork has a Cognitive Complexity of 80 (exceeds 20 allowed). Consider refactoring.

Open

func (c *Controller) NewNetwork(networkType, name string, id string, options ...NetworkOption) (_ *Network, retErr error) {
    if id != "" {
        c.networkLocker.Lock(id)
        defer c.networkLocker.Unlock(id) //nolint:errcheck

• Read up
  Read up

Function skipOverlay has a Cognitive Complexity of 78 (exceeds 20 allowed). Consider refactoring.

Open

func skipOverlay(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        var wire uint64

• Read up
  Read up

File controller.go has 829 lines of code (exceeds 500 allowed). Consider refactoring.

Open

/*
Package libnetwork provides the basic functionality and extension points to
create network namespaces and allocate interfaces for containers to use.

    networkType := "bridge"

File default_linux.go has 824 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package seccomp // import "github.com/docker/docker/profiles/seccomp"

import (
    "github.com/opencontainers/runtime-spec/specs-go"
    "golang.org/x/sys/unix"

Method GossipMessage.Unmarshal has a Cognitive Complexity of 77 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method TableEvent.Unmarshal has 266 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method Daemon.initNetworkController has a Cognitive Complexity of 75 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) initNetworkController(daemonCfg *config.Config, activeSandboxes map[string]interface{}) error {
    netOptions, err := daemon.networkOptions(daemonCfg, nil, daemon.id, nil)
    if err != nil {
        return err
    }

• Read up
  Read up