Method Daemon.getNetworkedContainer has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) getNetworkedContainer(containerID, connectedContainerID string) (*container.Container, error) {
    nc, err := daemon.GetContainer(connectedContainerID)
    if err != nil {
        return nil, err
    }

Method Daemon.killWithSignal has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) killWithSignal(container *containerpkg.Container, stopSignal syscall.Signal) error {
    log.G(context.TODO()).Debugf("Sending kill signal %d to container %s", stopSignal, container.ID)
    container.Lock()
    defer container.Unlock()

Method Daemon.updateNetworkSettings has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) updateNetworkSettings(container *container.Container, n *libnetwork.Network, endpointConfig *networktypes.EndpointSettings) error {
    if container.NetworkSettings == nil {
        container.NetworkSettings = &network.Settings{}
    }
    if container.NetworkSettings.Networks == nil {

Method Daemon.registerName has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) registerName(container *container.Container) error {
    if daemon.Exists(container.ID) {
        return fmt.Errorf("Container is already loaded")
    }
    if err := validateID(container.ID); err != nil {

Method Daemon.updateNetwork has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) updateNetwork(cfg *config.Config, container *container.Container) error {
    var (
        start = time.Now()
        ctrl  = daemon.netController
        sid   = container.NetworkSettings.SandboxID

Function getUserFromContainerd has 5 return statements (exceeds 4 allowed).

Open

func getUserFromContainerd(ctx context.Context, containerdCli *containerd.Client, ec *container.ExecConfig) (specs.User, error) {
    ctr, err := containerdCli.LoadContainer(ctx, ec.Container.ID)
    if err != nil {
        return specs.User{}, err
    }

Method ImageService.GetLayerFolders has 5 return statements (exceeds 4 allowed).

Open

func (i *ImageService) GetLayerFolders(img *image.Image, rwLayer layer.RWLayer, containerID string) ([]string, error) {
    folders := []string{}
    rd := len(img.RootFS.DiffIDs)
    for index := 1; index <= rd; index++ {
        // FIXME: why does this mutate the RootFS?

Function getUntilFromPruneFilters has 5 return statements (exceeds 4 allowed).

Open

func getUntilFromPruneFilters(pruneFilters filters.Args) (time.Time, error) {
    until := time.Time{}
    if !pruneFilters.Contains("until") {
        return until, nil
    }

Method Daemon.containerStatPath has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) containerStatPath(container *container.Container, path string) (stat *types.ContainerPathStat, err error) {
    container.Lock()
    defer container.Unlock()

    // Make sure an online file-system operation is permitted.

Method Daemon.containerArchivePath has 5 return statements (exceeds 4 allowed).

Open

func (daemon *Daemon) containerArchivePath(container *container.Container, path string) (content io.ReadCloser, stat *types.ContainerPathStat, err error) {
    container.Lock()

    defer func() {
        if err != nil {

Function RebaseArchiveEntries has 5 return statements (exceeds 4 allowed).

Open

func RebaseArchiveEntries(srcContent io.Reader, oldBase, newBase string) io.ReadCloser {
    if oldBase == string(os.PathSeparator) {
        // If oldBase specifies the root directory, use an empty string as
        // oldBase instead so that newBase doesn't replace the path separator
        // that all paths will start with.

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

Open

func (i *ImageService) ImageHistory(ctx context.Context, name string) ([]*image.HistoryResponseItem, error) {
    start := time.Now()
    img, err := i.GetImage(ctx, name, backend.GetImageOpts{})
    if err != nil {
        return nil, err

• Read up
  Read up

Method ImageService.manifestMatchesPlatform has 5 return statements (exceeds 4 allowed).

Open

func (i *ImageService) manifestMatchesPlatform(ctx context.Context, img *image.Image, platform ocispec.Platform) (bool, error) {
    ls, err := i.leases.ListResources(ctx, leases.Lease{ID: imageKey(img.ID().String())})
    if err != nil {
        if cerrdefs.IsNotFound(err) {
            return false, nil

Method ImageService.GetImageAndReleasableLayer has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (i *ImageService) GetImageAndReleasableLayer(ctx context.Context, refOrID string, opts backend.GetImageAndLayerOptions) (builder.Image, builder.ROLayer, error) {
    if refOrID == "" { // FROM scratch
        if runtime.GOOS == "windows" {
            return nil, nil, fmt.Errorf(`"FROM scratch" is not supported on Windows`)
        }

• Read up
  Read up

Function populateInitVersion has 5 return statements (exceeds 4 allowed).

Open

func populateInitVersion(ctx context.Context, cfg *configStore, v *types.Version) error {
    initBinary, err := cfg.LookupInitPath()
    if err != nil {
        log.G(ctx).WithError(err).Warn("Failed to find docker-init")
        return nil

Function parseDefaultRuntimeVersion has 5 return statements (exceeds 4 allowed).

Open

func parseDefaultRuntimeVersion(rts *runtimes) (runtime, version, commit string, err error) {
    shim, opts, err := rts.Get(rts.Default)
    if err != nil {
        return "", "", "", err
    }

Method cdiHandler.injectCDIDevices has 5 return statements (exceeds 4 allowed).

Open

func (c *cdiHandler) injectCDIDevices(s *specs.Spec, dev *deviceInstance) error {
    if dev.req.Count != 0 {
        return errdefs.InvalidParameter(errors.New("unexpected count in CDI device request"))
    }
    if len(dev.req.Options) > 0 {

Method Ctx.AuthZRequest has 5 return statements (exceeds 4 allowed).

Open

func (ctx *Ctx) AuthZRequest(w http.ResponseWriter, r *http.Request) error {
    var body []byte
    if sendBody(ctx.requestURI, r.Header) && r.ContentLength > 0 && r.ContentLength < maxBodySize {
        var err error
        body, r.Body, err = drainBody(r.Body)

Function GetTotalUsedFds has 5 return statements (exceeds 4 allowed).

Open

func GetTotalUsedFds(ctx context.Context) int {
    ctx, span := tracing.StartSpan(ctx, "GetTotalUsedFds")
    defer span.End()

    name := fmt.Sprintf("/proc/%d/fd", os.Getpid())

Method ImageService.GetImage has 5 return statements (exceeds 4 allowed).

Open

func (i *ImageService) GetImage(ctx context.Context, refOrID string, options backend.GetImageOpts) (*image.Image, error) {
    img, err := i.getImage(ctx, refOrID, options)
    if err != nil {
        return nil, err
    }