Method ImageService.ImagesPrune has 102 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (i *ImageService) ImagesPrune(ctx context.Context, pruneFilters filters.Args) (*imagetypes.PruneReport, error) {
    if !atomic.CompareAndSwapInt32(&i.pruneRunning, 0, 1) {
        return nil, errPruneRunning
    }
    defer atomic.StoreInt32(&i.pruneRunning, 0)

Method Endpoint.UnmarshalJSON has 101 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (ep *Endpoint) UnmarshalJSON(b []byte) (err error) {
    ep.mu.Lock()
    defer ep.mu.Unlock()

    var epMap map[string]interface{}

Method ImageService.pruneUnused has 101 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

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

Method Daemon.ContainerLogs has 101 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (daemon *Daemon) ContainerLogs(ctx context.Context, containerName string, config *containertypes.LogsOptions) (messages <-chan *backend.LogMessage, isTTY bool, retErr error) {
    lg := log.G(ctx).WithFields(log.Fields{
        "module":    "daemon",
        "method":    "(*Daemon).ContainerLogs",
        "container": containerName,

Method Copier.copySrc has 101 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *Copier) copySrc(name string, src io.Reader) {
    defer c.copyJobs.Done()

    bufSize := defaultBufSize
    if sizedLogger, ok := c.dst.(SizedLogger); ok {

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

Open

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

import (
    "bytes"
    "context"

• Read up
  Read up

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

Open

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

import (
    "bytes"
    "context"

• Read up
  Read up

Method GossipMessage.Unmarshal has 100 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

Method Controller.sandboxCleanup has 100 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (c *Controller) sandboxCleanup(activeSandboxes map[string]interface{}) error {
    sandboxStates, err := c.store.List(&sbState{c: c})
    if err != nil {
        if err == datastore.ErrKeyNotFound {
            // It's normal for no sandboxes to be found. Just bail out.

State has 26 methods (exceeds 20 allowed). Consider refactoring.

Open

type State struct {
    sync.Mutex
    // Note that `Running` and `Paused` are not mutually exclusive:
    // When pausing a container (on Linux), the freezer cgroup is used to suspend
    // all processes in the container. Freezing the process requires the process to

Method LogEntry.Unmarshal has 34 return statements (exceeds 4 allowed).

Open

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

Method ImageService.setupFilters has 100 lines of code (exceeds 50 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 {

Method Cluster.UpdateService has 100 lines of code (exceeds 50 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)

Method pusher.pushTag has 99 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (p *pusher) pushTag(ctx context.Context, ref reference.NamedTagged, id digest.Digest) error {
    log.G(ctx).Debugf("Pushing repository: %s", reference.FamiliarString(ref))

    imgConfig, err := p.config.ImageStore.Get(ctx, id)
    if err != nil {

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

Open

func (d *driver) CreateEndpoint(ctx context.Context, nid, eid string, ifInfo driverapi.InterfaceInfo, epOptions map[string]interface{}) error {
    var err error
    if err = validateID(nid, eid); err != nil {
        return err
    }

Function newImageBuildOptions has 98 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func newImageBuildOptions(ctx context.Context, r *http.Request) (*types.ImageBuildOptions, error) {
    options := &types.ImageBuildOptions{
        Version:        types.BuilderV1, // Builder V1 is the default, but can be overridden
        Dockerfile:     r.FormValue("dockerfile"),
        SuppressOutput: httputils.BoolValue(r, "q"),

Method LayerDownloadManager.Download has a Cognitive Complexity of 36 (exceeds 20 allowed). Consider refactoring.

Open

func (ldm *LayerDownloadManager) Download(ctx context.Context, initialRootFS image.RootFS, layers []DownloadDescriptor, progressOutput progress.Output) (image.RootFS, func(), error) {
    var (
        topLayer       layer.Layer
        topDownload    *downloadTransfer
        watcher        *watcher

• Read up
  Read up

Method Endpoint.sbLeave has a Cognitive Complexity of 36 (exceeds 20 allowed). Consider refactoring.

Open

func (ep *Endpoint) sbLeave(ctx context.Context, sb *Sandbox, force bool) error {
    n, err := ep.getNetworkFromStore()
    if err != nil {
        return fmt.Errorf("failed to get network from store during leave: %v", err)
    }

• Read up
  Read up

Method BulkSyncMessage.Unmarshal has 33 return statements (exceeds 4 allowed).

Open

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

Method networkConfiguration.fromLabels has a Cognitive Complexity of 36 (exceeds 20 allowed). Consider refactoring.

Open

func (c *networkConfiguration) fromLabels(labels map[string]string) error {
    var err error
    for label, value := range labels {
        switch label {
        case BridgeName:

• Read up
  Read up