Method TLSRenewer.Start has 5 return statements (exceeds 4 allowed).

Open

func (t *TLSRenewer) Start(ctx context.Context) <-chan CertificateUpdate {
    updates := make(chan CertificateUpdate)

    go func() {
        var (

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

Open

func DownloadRootCA(ctx context.Context, paths CertPaths, token string, connBroker *connectionbroker.Broker) (RootCA, error) {
    var rootCA RootCA
    // Get a digest for the optional CA hash string that we've been provided
    // If we were provided a non-empty string, and it is an invalid hash, return
    // otherwise, allow the invalid digest through.

Method TasksByTimestamp.Less has 5 return statements (exceeds 4 allowed).

Open

func (t TasksByTimestamp) Less(i, j int) bool {
    iTimestamp := taskTimestamp(t[i])
    jTimestamp := taskTimestamp(t[j])

    if iTimestamp == nil {

Method Deallocator.processNetwork has 5 return statements (exceeds 4 allowed).

Open

func (deallocator *Deallocator) processNetwork(ctx context.Context, tx store.Tx, network *api.Network, ignoreServiceID *string) (updated bool, err error) {
    if !network.PendingDelete {
        return
    }

Method RaftDEKManager.GetKeys has 5 return statements (exceeds 4 allowed).

Open

func (r *RaftDEKManager) GetKeys() raft.EncryptionKeys {
    var newKeys, originalKeys raft.EncryptionKeys
    err := r.kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
        data, ok := h.(RaftDEKData)
        if !ok {

Method Dispatcher.moveTasksToOrphaned has 5 return statements (exceeds 4 allowed).

Open

func (d *Dispatcher) moveTasksToOrphaned(nodeID string) error {
    err := d.store.Batch(func(batch *store.Batch) error {
        var (
            tasks []*api.Task
            err   error

Method Updater.useExistingTask has 5 return statements (exceeds 4 allowed).

Open

func (u *Updater) useExistingTask(ctx context.Context, slot orchestrator.Slot, existing *api.Task) error {
    var removeTasks []*api.Task
    for _, t := range slot {
        if t != existing {
            removeTasks = append(removeTasks, t)

Method Dispatcher.Run has 5 return statements (exceeds 4 allowed).

Open

func (d *Dispatcher) Run(ctx context.Context) error {
    ctx = log.WithModule(ctx, "dispatcher")
    log.G(ctx).Info("dispatcher starting")

    d.taskUpdatesLock.Lock()

Method Scheduler.scheduleNTasksOnNodes has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Scheduler) scheduleNTasksOnNodes(ctx context.Context, n int, taskGroup map[string]*api.Task, nodes []NodeInfo, schedulingDecisions map[string]schedulingDecision, nodeLess func(a *NodeInfo, b *NodeInfo) bool) int {
    tasksScheduled := 0
    failedConstraints := make(map[int]bool) // key is index in nodes slice
    nodeIter := 0
    nodeCount := len(nodes)

• Read up
  Read up

Method Manager.getPlugin has 5 return statements (exceeds 4 allowed).

Open

func (vm *Manager) getPlugin(name string) (Plugin, error) {
    // if the plugin already exists, we can just return it.
    if p, ok := vm.plugins[name]; ok {
        return p, nil
    }

Method Scheduler.scheduleTaskGroup has 5 return statements (exceeds 4 allowed).

Open

func (s *Scheduler) scheduleTaskGroup(ctx context.Context, taskGroup map[string]*api.Task, schedulingDecisions map[string]schedulingDecision) {
    // Pick at task at random from taskGroup to use for constraint
    // evaluation. It doesn't matter which one we pick because all the
    // tasks in the group are equal in terms of the fields the constraint
    // filters consider.

Method volumeSet.freeVolumes has 5 return statements (exceeds 4 allowed).

Open

func (vs *volumeSet) freeVolumes(batch *store.Batch) error {
    for volumeID, info := range vs.volumes {
        if err := batch.Update(func(tx store.Tx) error {
            v := store.GetVolume(tx, volumeID)
            if v == nil {

Method Manager.createVolume has 5 return statements (exceeds 4 allowed).

Open

func (vm *Manager) createVolume(ctx context.Context, v *api.Volume) error {
    l := log.G(ctx).WithField("volume.id", v.ID).WithField("driver", v.Spec.Driver.Name)
    l.Info("creating volume")

    p, err := vm.getPlugin(v.Spec.Driver.Name)

Method Server.RemoveTask has 5 return statements (exceeds 4 allowed).

Open

func (s *Server) RemoveTask(ctx context.Context, request *api.RemoveTaskRequest) (*api.RemoveTaskResponse, error) {
    if request.TaskID == "" {
        return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
    }

Method PluginFilter.Check has 5 return statements (exceeds 4 allowed).

Open

func (f *PluginFilter) Check(n *NodeInfo) bool {
    if n.Description == nil || n.Description.Engine == nil {
        // If the node is not running Engine, plugins are not
        // supported.
        return true

Method Dispatcher.register has 5 return statements (exceeds 4 allowed).

Open

func (d *Dispatcher) register(ctx context.Context, nodeID string, description *api.NodeDescription) (string, error) {
    logLocal := log.G(ctx).WithField("method", "(*Dispatcher).register")
    // prevent register until we're ready to accept it
    dctx, err := d.isRunningLocked()
    if err != nil {

Method volumeSet.isVolumeAvailableOnNode has 5 return statements (exceeds 4 allowed).

Open

func (vs *volumeSet) isVolumeAvailableOnNode(mount *api.Mount, node *NodeInfo) string {
    source := mount.Source
    // first, discern whether we're looking for a group or a volume
    // try trimming off the "group:" prefix. if the resulting string is
    // different from the input string (meaning something has been trimmed),

Method plugin.PublishVolume has 5 return statements (exceeds 4 allowed).

Open

func (p *plugin) PublishVolume(ctx context.Context, v *api.Volume, nodeID string) (map[string]string, error) {
    if !p.publisher {
        return nil, nil
    }
    csiNodeID := p.swarmToCSI[nodeID]

Method Updater.removeOldTasks has 5 return statements (exceeds 4 allowed).

Open

func (u *Updater) removeOldTasks(ctx context.Context, batch *store.Batch, removeTasks []*api.Task) (*api.Task, error) {
    var (
        lastErr     error
        removedTask *api.Task
    )

Method Updater.rollbackUpdate has 5 return statements (exceeds 4 allowed).

Open

func (u *Updater) rollbackUpdate(ctx context.Context, serviceID, message string) {
    log.G(ctx).Debugf("starting rollback of service %s", serviceID)

    err := u.store.Update(func(tx store.Tx) error {
        service := store.GetService(tx, serviceID)