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

Open

func (daemon *Daemon) findAndAttachNetwork(container *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 client.createWindows has 147 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *client) createWindows(id string, spec *specs.Spec, runtimeOptions interface{}) (*container, error) {
    logger := c.logger.WithField("container", id)
    configuration := &hcsshim.ContainerConfig{
        SystemType:              "Container",
        Name:                    id,

Method Daemon.ContainerExecStart has 146 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (daemon *Daemon) ContainerExecStart(ctx context.Context, name string, options containertypes.ExecStartOptions) (err error) {
    var (
        cStdin           io.ReadCloser
        cStdout, cStderr io.Writer
    )

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

Open

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

Method Controller.reservePools has a Cognitive Complexity of 47 (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

Function WithNamespaces has a Cognitive Complexity of 47 (exceeds 20 allowed). Consider refactoring.

Open

func WithNamespaces(daemon *Daemon, c *container.Container) coci.SpecOpts {
    return func(ctx context.Context, _ coci.Client, _ *containers.Container, s *coci.Spec) error {
        userNS := false
        // user
        if c.HostConfig.UsernsMode.IsPrivate() {

• Read up
  Read up

Method ImageService.pruneUnused has a Cognitive Complexity of 47 (exceeds 20 allowed). Consider refactoring.

Open

func (i *ImageService) pruneUnused(ctx context.Context, filterFunc imageFilterFunc, danglingOnly bool) (*types.ImagesPruneReport, error) {
    report := types.ImagesPruneReport{}

    allImages, err := i.images.List(ctx)
    if err != nil {

• Read up
  Read up

Method Daemon.containerStart has a Cognitive Complexity of 47 (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) {
    start := time.Now()
    container.Lock()
    defer container.Unlock()

• Read up
  Read up

Method walker.walk has a Cognitive Complexity of 47 (exceeds 20 allowed). Consider refactoring.

Open

func (w *walker) walk(path string, i1, i2 os.FileInfo) (err error) {
    // Register these nodes with the return trees, unless we're still at the
    // (already-created) roots:
    if path != "/" {
        if err := walkchunk(path, i1, w.dir1, w.root1); err != nil {

• Read up
  Read up

Method PeerRecord.Unmarshal has 143 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method PluginPrivilege.Unmarshal has 143 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Function DefaultLinuxSpec has 142 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func DefaultLinuxSpec() specs.Spec {
    return specs.Spec{
        Version: specs.Version,
        Process: &specs.Process{
            Capabilities: &specs.LinuxCapabilities{

Method Daemon.buildSandboxOptions has 141 lines of code (exceeds 50 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() {

Method Cluster.CreateService has a Cognitive Complexity of 46 (exceeds 20 allowed). Consider refactoring.

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 {

• Read up
  Read up

Method driver.CreateEndpoint has 138 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo, epOptions map[string]interface{}) error {
    if ifInfo == nil {
        return errors.New("invalid interface info passed")
    }

Function compare has 137 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func compare(a, b *container.Config) bool {
    if a == nil || b == nil {
        return false
    }

Function includeContainerInList has 137 lines of code (exceeds 50 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 {

Method PortConfig.Unmarshal has 136 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Function withFetchProgress has a Cognitive Complexity of 45 (exceeds 20 allowed). Consider refactoring.

Open

func withFetchProgress(cs content.Store, out progress.Output, ref reference.Named) images.HandlerFunc {
    return func(ctx context.Context, desc ocispec.Descriptor) ([]ocispec.Descriptor, error) {
        switch desc.MediaType {
        case ocispec.MediaTypeImageManifest, images.MediaTypeDockerSchema2Manifest:
            tn := reference.TagNameOnly(ref)

• Read up
  Read up

Method Daemon.setupMounts has a Cognitive Complexity of 45 (exceeds 20 allowed). Consider refactoring.

Open

func (daemon *Daemon) setupMounts(ctx context.Context, c *container.Container) ([]container.Mount, func(context.Context) error, error) {
    var mounts []container.Mount
    // TODO: tmpfs mounts should be part of Mountpoints
    tmpfsMounts := make(map[string]bool)
    tmpfsMountInfo, err := c.TmpfsMounts()

• Read up
  Read up