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 Daemon.buildSandboxOptions has a Cognitive Complexity of 55 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) buildSandboxOptions(cfg *config.Config, ctr *container.Container) ([]libnetwork.SandboxOption, error) {
    var sboxOptions []libnetwork.SandboxOption
    sboxOptions = append(sboxOptions, libnetwork.OptionHostname(ctr.Config.Hostname), libnetwork.OptionDomainname(ctr.Config.Domainname))

    if ctr.HostConfig.NetworkMode.IsHost() {

• Read up
  Read up

Method Daemon.findAndAttachNetwork has a Cognitive Complexity of 48 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) findAndAttachNetwork(ctr *container.Container, idOrName string, epConfig *networktypes.EndpointSettings) (*libnetwork.Network, *networktypes.NetworkingConfig, error) {
    id := getNetworkID(idOrName, epConfig)

    n, err := daemon.FindNetwork(id)
    if err != nil {

• Read up
  Read up

Method Daemon.buildSandboxOptions has 141 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (daemon *Daemon) buildSandboxOptions(cfg *config.Config, ctr *container.Container) ([]libnetwork.SandboxOption, error) {
    var sboxOptions []libnetwork.SandboxOption
    sboxOptions = append(sboxOptions, libnetwork.OptionHostname(ctr.Config.Hostname), libnetwork.OptionDomainname(ctr.Config.Domainname))

    if ctr.HostConfig.NetworkMode.IsHost() {

Method Daemon.connectToNetwork has a Cognitive Complexity of 37 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) connectToNetwork(ctx context.Context, cfg *config.Config, ctr *container.Container, idOrName string, endpointConfig *network.EndpointSettings, updateSettings bool) (retErr error) {
    containerName := strings.TrimPrefix(ctr.Name, "/")
    ctx, span := otel.Tracer("").Start(ctx, "daemon.connectToNetwork", trace.WithAttributes(
        attribute.String("container.ID", ctr.ID),
        attribute.String("container.name", containerName),

• Read up
  Read up

Method Daemon.connectToNetwork has 96 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (daemon *Daemon) connectToNetwork(ctx context.Context, cfg *config.Config, ctr *container.Container, idOrName string, endpointConfig *network.EndpointSettings, updateSettings bool) (retErr error) {
    containerName := strings.TrimPrefix(ctr.Name, "/")
    ctx, span := otel.Tracer("").Start(ctx, "daemon.connectToNetwork", trace.WithAttributes(
        attribute.String("container.ID", ctr.ID),
        attribute.String("container.name", containerName),

Function validateEndpointSettings has a Cognitive Complexity of 31 (exceeds 20 allowed). Consider refactoring.

Open

func validateEndpointSettings(nw *libnetwork.Network, nwName string, epConfig *networktypes.EndpointSettings) error {
    if epConfig == nil {
        return nil
    }

• Read up
  Read up

Method Daemon.allocateNetwork has a Cognitive Complexity of 31 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method Daemon.findAndAttachNetwork has 65 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (daemon *Daemon) findAndAttachNetwork(ctr *container.Container, idOrName string, epConfig *networktypes.EndpointSettings) (*libnetwork.Network, *networktypes.NetworkingConfig, error) {
    id := getNetworkID(idOrName, epConfig)

    n, err := daemon.FindNetwork(id)
    if err != nil {

Method Daemon.connectToNetwork has 16 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) connectToNetwork(ctx context.Context, cfg *config.Config, ctr *container.Container, idOrName string, endpointConfig *network.EndpointSettings, updateSettings bool) (retErr error) {
    containerName := strings.TrimPrefix(ctr.Name, "/")
    ctx, span := otel.Tracer("").Start(ctx, "daemon.connectToNetwork", trace.WithAttributes(
        attribute.String("container.ID", ctr.ID),
        attribute.String("container.name", containerName),

Method Daemon.allocateNetwork has 61 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Function validateEndpointSettings has 56 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func validateEndpointSettings(nw *libnetwork.Network, nwName string, epConfig *networktypes.EndpointSettings) error {
    if epConfig == nil {
        return nil
    }

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

Method Daemon.findAndAttachNetwork has 7 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) findAndAttachNetwork(ctr *container.Container, idOrName string, epConfig *networktypes.EndpointSettings) (*libnetwork.Network, *networktypes.NetworkingConfig, error) {
    id := getNetworkID(idOrName, epConfig)

    n, err := daemon.FindNetwork(id)
    if err != nil {

Avoid deeply nested control flow statements.

Open

                    if retryCount >= 5 {
                        return nil, nil, fmt.Errorf("could not find network %s after successful attachment", idOrName)
                    }

Method Daemon.DisconnectFromNetwork has 7 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) DisconnectFromNetwork(ctx context.Context, ctr *container.Container, networkName string, force bool) error {
    n, err := daemon.FindNetwork(networkName)
    ctr.Lock()
    defer ctr.Unlock()

Method Daemon.connectToNetwork has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (daemon *Daemon) connectToNetwork(ctx context.Context, cfg *config.Config, ctr *container.Container, idOrName string, endpointConfig *network.EndpointSettings, updateSettings bool) (retErr error) {

Method Daemon.buildSandboxOptions has 7 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) buildSandboxOptions(cfg *config.Config, ctr *container.Container) ([]libnetwork.SandboxOption, error) {
    var sboxOptions []libnetwork.SandboxOption
    sboxOptions = append(sboxOptions, libnetwork.OptionHostname(ctr.Config.Hostname), libnetwork.OptionDomainname(ctr.Config.Domainname))

    if ctr.HostConfig.NetworkMode.IsHost() {

Method Daemon.initializeNetworking has 6 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) initializeNetworking(ctx context.Context, cfg *config.Config, ctr *container.Container) error {
    if ctr.HostConfig.NetworkMode.IsContainer() {
        // we need to get the hosts files from the container to join
        nc, err := daemon.getNetworkedContainer(ctr.ID, ctr.HostConfig.NetworkMode.ConnectedContainer())
        if err != nil {

Method Daemon.updateNetworkSettings has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) updateNetworkSettings(ctr *container.Container, n *libnetwork.Network, endpointConfig *networktypes.EndpointSettings) error {
    if ctr.NetworkSettings == nil {
        ctr.NetworkSettings = &network.Settings{}
    }
    if ctr.NetworkSettings.Networks == nil {

Method Daemon.releaseNetwork has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) releaseNetwork(ctx context.Context, ctr *container.Container) {
    ctx = context.WithoutCancel(ctx)

    start := time.Now()
    // If live-restore is enabled, the daemon cleans up dead containers when it starts up. In that case, the

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

Open

func updateJoinInfo(networkSettings *network.Settings, n *libnetwork.Network, ep *libnetwork.Endpoint) error {
    if ep == nil {
        return errors.New("invalid enppoint whhile building portmap info")
    }

Method Daemon.updateNetwork has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) updateNetwork(cfg *config.Config, ctr *container.Container) error {
    var (
        start = time.Now()
        ctrl  = daemon.netController
        sid   = ctr.NetworkSettings.SandboxID

Method Daemon.getNetworkedContainer has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) getNetworkedContainer(containerID, connectedContainerID string) (*container.Container, error) {
    nc, err := daemon.GetContainer(connectedContainerID)
    if err != nil {
        return nil, err
    }

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    for _, port := range ports {
        portProto := types.ParseProtocol(port.Proto())
        portNum := uint16(port.Int())
        exposedPorts = append(exposedPorts, types.TransportPort{
            Proto: portProto,

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    if ctr.HostConfig.PortBindings != nil {
        for p, b := range ctr.HostConfig.PortBindings {
            bindings[p] = []nat.PortBinding{}
            for _, bb := range b {
                bindings[p] = append(bindings[p], nat.PortBinding{

• Read up
  Read up