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

Open

func getSystemCPUUsage() (cpuUsage uint64, cpuNum uint32, err error) {
    f, err := os.Open("/proc/stat")
    if err != nil {
        return 0, 0, err
    }

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

Open

func getSecret(ctx context.Context, c swarmapi.ControlClient, input string) (*swarmapi.Secret, error) {
    // attempt to lookup secret by full ID
    if rg, err := c.GetSecret(ctx, &swarmapi.GetSecretRequest{SecretID: input}); err == nil {
        return rg.Secret, nil
    }

Method reader.drainJournal has 5 return statements (exceeds 4 allowed).

Open

func (r *reader) drainJournal() (bool, error) {
    for i := 0; ; i++ {
        // Read the entry's timestamp.
        timestamp, err := r.j.Realtime()
        if err != nil {

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

Open

func copyRegular(srcPath, dstPath string, fileinfo os.FileInfo, copyWithFileRange, copyWithFileClone *bool) error {
    srcFile, err := os.Open(srcPath)
    if err != nil {
        return err
    }

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

Open

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

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

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

Open

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

    defer func() {
        if err != nil {

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?

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

Open

func (daemon *Daemon) createSpecWindowsFields(c *container.Container, s *specs.Spec, isHyperV bool) error {
    s.Hostname = c.FullHostname()

    if len(s.Process.Cwd) == 0 {
        // We default to C:\ to workaround the oddity of the case that the

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

Open

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

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

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

Open

func (daemon *Daemon) populateInitCommit(ctx context.Context, v *system.Info, cfg *configStore) error {
    v.InitBinary = cfg.GetInitPath()
    initBinary, err := cfg.LookupInitPath()
    if err != nil {
        log.G(ctx).WithError(err).Warnf("Failed to find docker-init")

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 Reload has 5 return statements (exceeds 4 allowed).

Open

func Reload(configFile string, flags *pflag.FlagSet, reload func(*Config)) error {
    log.G(context.TODO()).Infof("Got signal to reload configuration, reloading from: %s", configFile)
    newConfig, err := getConflictFreeConfiguration(configFile, flags)
    if err != nil {
        if flags.Changed("config-file") || !os.IsNotExist(err) {

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

Open

func Init(proto, addr, socketGroup string, tlsConfig *tls.Config) ([]net.Listener, error) {
    ls := []net.Listener{}

    switch proto {
    case "fd":

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

Open

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

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

Open

func updateJoinInfo(networkSettings *network.Settings, n *libnetwork.Network, ep *libnetwork.Endpoint) error {
    if ep == nil {
        return errors.New("invalid enppoint whhile building portmap info")
    }

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

Open

func (daemon *Daemon) releaseNetwork(ctx context.Context, ctr *container.Container) {
    ctx = context.WithoutCancel(ctx)

    start := time.Now()
    // If live-restore is enabled, the daemon cleans up dead containers when it starts up. In that case, the

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
    }

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 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
    }