Method Supervisor.UpdatableTasksInSlot has 5 return statements (exceeds 4 allowed).

Open

func (r *Supervisor) UpdatableTasksInSlot(ctx context.Context, slot orchestrator.Slot, service *api.Service) orchestrator.Slot {
    if len(slot) < 1 {
        return nil
    }

Method VolumeEnforcer.rejectNoncompliantTasks has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (ve *VolumeEnforcer) rejectNoncompliantTasks(v *api.Volume) {
    if v.Spec.Availability != api.VolumeAvailabilityDrain {
        return
    }

• Read up
  Read up

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

Open

func (d *Dispatcher) UpdateTaskStatus(ctx context.Context, r *api.UpdateTaskStatusRequest) (*api.UpdateTaskStatusResponse, error) {
    d.rpcRW.RLock()
    defer d.rpcRW.RUnlock()

    dctx, err := d.isRunningLocked()

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

Open

func (s *Server) RemoveService(ctx context.Context, request *api.RemoveServiceRequest) (*api.RemoveServiceResponse, error) {
    if request.ServiceID == "" {
        return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.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 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)

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