Function newRepository has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    ctx context.Context, repoInfo *registry.RepositoryInfo, endpoint registry.APIEndpoint,
    metaHeaders http.Header, authConfig *registrytypes.AuthConfig, actions ...string,

Method manifestStore.getLocal has 7 return statements (exceeds 4 allowed).

Open

func (m *manifestStore) getLocal(ctx context.Context, desc ocispec.Descriptor, ref reference.Named) (distribution.Manifest, error) {
    ra, err := m.local.ReaderAt(ctx, desc)
    if err != nil {
        return nil, errors.Wrap(err, "error getting content store reader")
    }

Function EnsureRemoveAll has 7 return statements (exceeds 4 allowed).

Open

func EnsureRemoveAll(dir string) error {
    notExistErr := make(map[string]bool)

    // track retries
    exitOnErr := make(map[string]int)

Method store.restore has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.

Open

func (is *store) restore() error {
    // As the code below is run when restoring all images (which can be "many"),
    // constructing the "log.G(ctx).WithFields" is deliberately not "DRY", as the
    // logger is only used for error-cases, and we don't want to do allocations
    // if we don't need it. The "f" type alias is here is just for convenience,

• Read up
  Read up

Method Manager.Pull has 7 return statements (exceeds 4 allowed).

Open

func (pm *Manager) Pull(ctx context.Context, ref reference.Named, name string, metaHeader http.Header, authConfig *registry.AuthConfig, privileges types.PluginPrivileges, outStream io.Writer, opts ...CreateOpt) (err error) {
    pm.muGC.RLock()
    defer pm.muGC.RUnlock()

    // revalidate because Pull is public

Method Store.resolvePluginID has 7 return statements (exceeds 4 allowed).

Open

func (ps *Store) resolvePluginID(idOrName string) (string, error) {
    if validFullID.MatchString(idOrName) {
        return idOrName, nil
    }

Function kubernetesSafeOpen has 7 return statements (exceeds 4 allowed).

Open

func kubernetesSafeOpen(base, subpath string) (int, error) {
    // syscall.Openat flags used to traverse directories not following symlinks
    const nofollowFlags = unix.O_RDONLY | unix.O_NOFOLLOW
    // flags for getting file descriptor without following the symlink
    const openFDFlags = unix.O_NOFOLLOW | unix.O_PATH

Function evaluatePath has 7 return statements (exceeds 4 allowed).

Open

func evaluatePath(path, subpath string) (resolvedBasePath string, resolvedSubpath string, err error) {
    baseResolved, err := filepath.EvalSymlinks(path)
    if err != nil {
        if errors.Is(err, os.ErrNotExist) {
            return "", "", &ErrNotAccessible{Path: path, Cause: err}

Method KernelVersion.UnmarshalJSON has 7 return statements (exceeds 4 allowed).

Open

func (k *KernelVersion) UnmarshalJSON(version []byte) error {
    var (
        ver string
        err error
    )

Method pushDescriptor.layerAlreadyExists has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    ctx context.Context,
    progressOutput progress.Output,
    diffID layer.DiffID,
    checkOtherRepositories bool,
    maxExistenceCheckAttempts int,

Method Manager.fetch has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (pm *Manager) fetch(ctx context.Context, ref reference.Named, auth *registry.AuthConfig, out progress.Output, metaHeader http.Header, handlers ...images.Handler) (err error) {

Function splitConfigRootFSFromTar has 7 return statements (exceeds 4 allowed).

Open

func splitConfigRootFSFromTar(in io.ReadCloser, config *[]byte) io.ReadCloser {
    pr, pw := io.Pipe()
    go func() {
        tarReader := tar.NewReader(in)
        tarWriter := tar.NewWriter(pw)

Method tarexporter.loadLayer has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (l *tarexporter) loadLayer(ctx context.Context, filename string, rootFS image.RootFS, id string, foreignSrc distribution.Descriptor, progressOutput progress.Output) (_ layer.Layer, outErr error) {

Avoid deeply nested control flow statements.

Open

            } else if len(output) != 0 {
                return fmt.Errorf("could not delete linking rule from %s/%s: %s", c.Table, c.Name, output)
            }

Method Controller.deleteEndpointNameResolution has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (c *Controller) deleteEndpointNameResolution(svcName, svcID, nID, eID, containerName string, vip net.IP, serviceAliases, taskAliases []string, ip net.IP, rmService, multipleEntries bool, method string) error {

Method Controller.addServiceBinding has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (c *Controller) addServiceBinding(svcName, svcID, nID, eID, containerName string, vip net.IP, ingressPorts []*PortConfig, serviceAliases, taskAliases []string, ip net.IP, method string) error {

Method NetworkDB.handleNetworkEvent has 7 return statements (exceeds 4 allowed).

Open

func (nDB *NetworkDB) handleNetworkEvent(nEvent *NetworkEvent) bool {
    // Update our local clock if the received messages has newer
    // time.
    nDB.networkClock.Witness(nEvent.LTime)

Avoid deeply nested control flow statements.

Open

            } else if len(output) != 0 {
                return fmt.Errorf("could not delete establish rule from %s: %s", c.Table, output)
            }

Function NewAllocator has 7 return statements (exceeds 4 allowed).

Open

func NewAllocator(lcAs, glAs []*ipamutils.NetworkToSplit) (*Allocator, error) {
    var (
        a                          Allocator
        err                        error
        lcAs4, lcAs6, glAs4, glAs6 []*ipamutils.NetworkToSplit

Method Controller.handleEpTableEvent has 7 return statements (exceeds 4 allowed).

Open

func (c *Controller) handleEpTableEvent(ev events.Event) {
    var (
        nid   string
        eid   string
        value []byte