Method Daemon.openContainerFS has a Cognitive Complexity of 60 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) openContainerFS(container *container.Container) (_ *containerFSView, err error) {
    ctx := context.TODO()

    if err := daemon.Mount(container); err != nil {
        return nil, err

• Read up
  Read up

Method PluginSpec.Unmarshal has 197 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method CompoundMessage.Unmarshal has a Cognitive Complexity of 59 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method CompoundMessage_SimpleMessage.Unmarshal has a Cognitive Complexity of 59 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method ImageService.Images has 190 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (i *ImageService) Images(ctx context.Context, opts imagetypes.ListOptions) ([]*imagetypes.Summary, error) {
    if err := opts.Filters.Validate(acceptedImageFilterTags); err != nil {
        return nil, err
    }

Method Cluster.UpdateService has a Cognitive Complexity of 58 (exceeds 20 allowed). Consider refactoring.

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)

• Read up
  Read up

Function ServiceSpecToGRPC has a Cognitive Complexity of 58 (exceeds 20 allowed). Consider refactoring.

Open

func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) {
    name := s.Name
    if name == "" {
        name = namesgenerator.GetRandomName(0)
    }

• Read up
  Read up

File container_routes.go has 690 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package container // import "github.com/docker/docker/api/server/router/container"

import (
    "context"
    "encoding/json"

Method LogEntry.Unmarshal has 188 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method Builder.Build has 186 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (b *Builder) Build(ctx context.Context, opt backend.BuildConfig) (*builder.Result, error) {
    if len(opt.Options.Outputs) > 1 {
        return nil, errors.Errorf("multiple outputs not supported")
    }

Method pushDescriptor.Upload has a Cognitive Complexity of 57 (exceeds 20 allowed). Consider refactoring.

Open

func (pd *pushDescriptor) Upload(ctx context.Context, progressOutput progress.Output) (distribution.Descriptor, error) {
    // Skip foreign layers unless this registry allows nondistributable artifacts.
    if !pd.endpoint.AllowNondistributableArtifacts {
        if fs, ok := pd.layer.(distribution.Describable); ok {
            if d := fs.Descriptor(); len(d.URLs) > 0 {

• Read up
  Read up

Method BulkSyncMessage.Unmarshal has 184 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

File networkallocator.go has 678 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package cnmallocator

import (
    "context"
    "fmt"

Method Cluster.ServiceLogs has a Cognitive Complexity of 56 (exceeds 20 allowed). Consider refactoring.

Open

func (c *Cluster) ServiceLogs(ctx context.Context, selector *backend.LogSelector, config *container.LogsOptions) (<-chan *backend.LogMessage, error) {
    c.mu.RLock()
    defer c.mu.RUnlock()

    state := c.currentNodeState()

• Read up
  Read up

Method Daemon.ContainerRename has a Cognitive Complexity of 56 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) ContainerRename(oldName, newName string) (retErr error) {
    if oldName == "" || newName == "" {
        return errdefs.InvalidParameter(errors.New("Neither old nor new names may be empty"))
    }

• Read up
  Read up

File backend_linux.go has 676 lines of code (exceeds 500 allowed). Consider refactoring.

Open

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

import (
    "archive/tar"
    "bytes"

Method Cluster.resolveSystemAddrViaSubnetCheck has a Cognitive Complexity of 55 (exceeds 20 allowed). Consider refactoring.

Open

func (c *Cluster) resolveSystemAddrViaSubnetCheck() (net.IP, error) {
    // Use the system's only IP address, or fail if there are
    // multiple addresses to choose from. Skip interfaces which
    // are managed by docker via subnet check.
    interfaces, err := net.Interfaces()

• Read up
  Read up

Method Daemon.buildSandboxOptions has a Cognitive Complexity of 55 (exceeds 20 allowed). Consider refactoring.

Open

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

    if container.HostConfig.NetworkMode.IsHost() {

• Read up
  Read up

Function ServiceSpecToGRPC has 175 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) {
    name := s.Name
    if name == "" {
        name = namesgenerator.GetRandomName(0)
    }

Method Reader.TestFollow has 173 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (tr Reader) TestFollow(t *testing.T) {
    // Reader sends all logs and closes after logger is closed
    // - Starting from empty log (like run)
    for i, tail := range []int{-1, 0, 1, 42} {
        i, tail := i, tail