Method Scheduler.applySchedulingDecisions has a Cognitive Complexity of 95 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Scheduler) applySchedulingDecisions(ctx context.Context, schedulingDecisions map[string]schedulingDecision) (successful, failed []schedulingDecision) {
    // applySchedulingDecisions is the only place where we make store
    // transactions in the scheduler. the scheduler is responsible for freeing
    // volumes that are no longer in use. this means that volumes should be
    // freed in this function. sometimes, there are no scheduling decisions to

• Read up
  Read up

File scheduler.go has 684 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package scheduler

import (
    "context"
    "sync"

Method Scheduler.Run has a Cognitive Complexity of 39 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Scheduler) Run(pctx context.Context) error {
    ctx := log.WithModule(pctx, "scheduler")
    defer close(s.doneChan)

    s.pipeline.AddFilter(&VolumesFilter{vs: s.volumes})

• Read up
  Read up

Method Scheduler.applySchedulingDecisions has 103 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (s *Scheduler) applySchedulingDecisions(ctx context.Context, schedulingDecisions map[string]schedulingDecision) (successful, failed []schedulingDecision) {
    // applySchedulingDecisions is the only place where we make store
    // transactions in the scheduler. the scheduler is responsible for freeing
    // volumes that are no longer in use. this means that volumes should be
    // freed in this function. sometimes, there are no scheduling decisions to

Method Scheduler.scheduleNTasksOnSubtree has a Cognitive Complexity of 33 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Scheduler) scheduleNTasksOnSubtree(ctx context.Context, n int, taskGroup map[string]*api.Task, tree *decisionTree, schedulingDecisions map[string]schedulingDecision, nodeLess func(a *NodeInfo, b *NodeInfo) bool) int {
    if tree.next == nil {
        nodes := tree.orderedNodes(s.pipeline.Process, nodeLess)
        if len(nodes) == 0 {
            return 0

• Read up
  Read up

Method Scheduler.Run has 84 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (s *Scheduler) Run(pctx context.Context) error {
    ctx := log.WithModule(pctx, "scheduler")
    defer close(s.doneChan)

    s.pipeline.AddFilter(&VolumesFilter{vs: s.volumes})

Method Scheduler.scheduleNTasksOnNodes has 53 lines of code (exceeds 50 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)

Method Scheduler.updateTask has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.

Open

func (s *Scheduler) updateTask(ctx context.Context, t *api.Task) bool {
    // Ignore all tasks that have not reached PENDING
    // state.
    if t.Status.State < api.TaskStatePending {
        return false

• Read up
  Read up

Method Scheduler.scheduleNTasksOnSubtree has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (s *Scheduler) scheduleNTasksOnSubtree(ctx context.Context, n int, taskGroup map[string]*api.Task, tree *decisionTree, schedulingDecisions map[string]schedulingDecision, nodeLess func(a *NodeInfo, b *NodeInfo) bool) int {

Method Scheduler.scheduleNTasksOnNodes has 6 arguments (exceeds 4 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 {

Avoid deeply nested control flow statements.

Open

                    if time.Since(debouncingStarted) > maxLatency {
                        commitDebounceTimer.Stop()
                        commitDebounceTimer = nil
                        commitDebounceTimeout = nil
                        schedule()

Method Scheduler.updateTask has 6 return statements (exceeds 4 allowed).

Open

func (s *Scheduler) updateTask(ctx context.Context, t *api.Task) bool {
    // Ignore all tasks that have not reached PENDING
    // state.
    if t.Status.State < api.TaskStatePending {
        return false

Method Scheduler.applySchedulingDecisions has 6 return statements (exceeds 4 allowed).

Open

func (s *Scheduler) applySchedulingDecisions(ctx context.Context, schedulingDecisions map[string]schedulingDecision) (successful, failed []schedulingDecision) {
    // applySchedulingDecisions is the only place where we make store
    // transactions in the scheduler. the scheduler is responsible for freeing
    // volumes that are no longer in use. this means that volumes should be
    // freed in this function. sometimes, there are no scheduling decisions to

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.