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

Method ImageService.ImageInspect has 62 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (i *ImageService) ImageInspect(ctx context.Context, refOrID string, _ backend.ImageInspectOpts) (*imagetypes.InspectResponse, error) {
    img, err := i.GetImage(ctx, refOrID, backend.GetImageOpts{})
    if err != nil {
        return nil, err
    }

Function New has 62 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func New(c testing.TB, name string, files map[string]string, enforceLocalServer bool) *FakeGit {
    c.Helper()
    ctx := fakecontext.New(c, "", fakecontext.WithFiles(files))
    defer ctx.Close()
    curdir, err := os.Getwd()

Method ResolvConf.Generate has 61 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (rc *ResolvConf) Generate(comments bool) ([]byte, error) {
    s := struct {
        Md          *metadata
        NameServers []netip.Addr
        Search      []string

Function setupIPChains has 61 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func setupIPChains(config configuration, version iptables.IPVersion) (natChain *iptables.ChainInfo, filterChain *iptables.ChainInfo, isolationChain1 *iptables.ChainInfo, isolationChain2 *iptables.ChainInfo, retErr error) {
    // Sanity check.
    if version == iptables.IPv4 && !config.EnableIPTables {
        return nil, nil, nil, nil, errors.New("cannot create new chains, iptables is disabled")
    }

Method Service.lookupV2Endpoints has 61 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (s *Service) lookupV2Endpoints(hostname string) (endpoints []APIEndpoint, err error) {
    ana := s.config.allowNondistributableArtifacts(hostname)

    if hostname == DefaultNamespace || hostname == IndexHostname {
        for _, mirror := range s.config.Mirrors {

Method ImageService.getPushDescriptor has 61 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (i *ImageService) getPushDescriptor(ctx context.Context, img containerdimages.Image, platform *ocispec.Platform) (ocispec.Descriptor, error) {
    pm := i.matchRequestedOrDefault(platforms.OnlyStrict, platform)

    anyMissing := false

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
    }

Method pushDescriptor.layerAlreadyExists has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring.

Open

func (pd *pushDescriptor) layerAlreadyExists(
    ctx context.Context,
    progressOutput progress.Output,
    diffID layer.DiffID,
    checkOtherRepositories bool,

• Read up
  Read up

Method layerDescriptor.Download has 15 return statements (exceeds 4 allowed).

Open

func (ld *layerDescriptor) Download(ctx context.Context, progressOutput progress.Output) (io.ReadCloser, int64, error) {
    log.G(ctx).Debugf("pulling blob %q", ld.digest)

    var (
        err    error

Method tarexporter.legacyLoadImage has 15 return statements (exceeds 4 allowed).

Open

func (l *tarexporter) legacyLoadImage(oldID, sourceDir string, loadedMap map[string]image.ID, progressOutput progress.Output) error {
    if _, loaded := loadedMap[oldID]; loaded {
        return nil
    }
    configPath, err := safePath(sourceDir, filepath.Join(oldID, legacyConfigFileName))

Method CompoundMessage_SimpleMessage.Unmarshal has 15 return statements (exceeds 4 allowed).

Open

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

Method driver.Join has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring.

Open

func (d *driver) Join(ctx context.Context, nid, eid string, sboxKey string, jinfo driverapi.JoinInfo, options map[string]interface{}) error {
    ctx, span := otel.Tracer("").Start(ctx, "libnetwork.drivers.overlay.Join", trace.WithAttributes(
        attribute.String("nid", nid),
        attribute.String("eid", eid),
        attribute.String("sboxKey", sboxKey)))

• Read up
  Read up

Function skipOverlay has 15 return statements (exceeds 4 allowed).

Open

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

Method snapshotter.EnsureLayer has 15 return statements (exceeds 4 allowed).

Open

func (s *snapshotter) EnsureLayer(ctx context.Context, key string) ([]layer.DiffID, error) {
    s.layerCreateLocker.Lock(key)
    defer s.layerCreateLocker.Unlock(key)

    diffIDs, err := s.GetDiffIDs(ctx, key)

Method imageExporterInstance.Export has 15 return statements (exceeds 4 allowed).

Open

func (e *imageExporterInstance) Export(ctx context.Context, inp *exporter.Source, inlineCache exptypes.InlineCache, sessionID string) (map[string]string, exporter.DescriptorReference, error) {
    if len(inp.Refs) > 1 {
        return nil, nil, fmt.Errorf("exporting multiple references to image store is currently unsupported")
    }

Method controller.Start has 15 return statements (exceeds 4 allowed).

Open

func (r *controller) Start(ctx context.Context) error {
    if err := r.checkClosed(); err != nil {
        return err
    }

Method ImageService.ImageHistory has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring.

Open

func (i *ImageService) ImageHistory(ctx context.Context, name string, platform *ocispec.Platform) ([]*imagetype.HistoryResponseItem, error) {
    start := time.Now()
    img, err := i.resolveImage(ctx, name)
    if err != nil {
        return nil, err

• Read up
  Read up

Method ImageService.getPushDescriptor has 15 return statements (exceeds 4 allowed).

Open

func (i *ImageService) getPushDescriptor(ctx context.Context, img containerdimages.Image, platform *ocispec.Platform) (ocispec.Descriptor, error) {
    pm := i.matchRequestedOrDefault(platforms.OnlyStrict, platform)

    anyMissing := false

Function initClusterSpec has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring.

Open

func initClusterSpec(node *swarmnode.Node, spec types.Spec) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    for conn := range node.ListenControlSocket(ctx) {
        if ctx.Err() != nil {

• Read up
  Read up