Store the available nodes in the alloc metric

nomad/structs/structs.go

@@ -1695,6 +1695,9 @@ type AllocMetric struct {
 	// NodesFiltered is the number of nodes filtered due to a constraint
 	NodesFiltered int
 
+	// NodesAvailable is the number of nodes available for evaluation per DC.
+	NodesAvailable map[string]int
+
 	// ClassFiltered is the number of nodes filtered by class
 	ClassFiltered map[string]int
 

scheduler/generic_sched.go

@@ -245,11 +245,14 @@ func (s *GenericScheduler) computeJobAllocs() error {
 // computePlacements computes placements for allocations
 func (s *GenericScheduler) computePlacements(place []allocTuple) error {
 	// Get the base nodes
-	nodes, err := readyNodesInDCs(s.state, s.job.Datacenters)
+	nodes, byDC, err := readyNodesInDCs(s.state, s.job.Datacenters)
 	if err != nil {
 		return err
 	}
 
+	// Store the available nodes by datacenter
+	s.ctx.Metrics().NodesAvailable = byDC
+
 	// Update the set of placement ndoes
 	s.stack.SetNodes(nodes)
 

scheduler/system_sched.go

@@ -86,10 +86,14 @@ func (s *SystemScheduler) process() (bool, error) {
 
 	// Get the ready nodes in the required datacenters
 	if s.job != nil {
-		s.nodes, err = readyNodesInDCs(s.state, s.job.Datacenters)
+		var byDC map[string]int
+		s.nodes, byDC, err = readyNodesInDCs(s.state, s.job.Datacenters)
 		if err != nil {
 			return false, fmt.Errorf("failed to get ready nodes: %v", err)
 		}
+
+		// Store the available nodes by datacenter
+		s.ctx.Metrics().NodesAvailable = byDC
 	}
 
 	// Create a plan
@@ -219,7 +223,7 @@ func (s *SystemScheduler) computePlacements(place []allocTuple) error {
 			return fmt.Errorf("could not find node %q", missing.Alloc.NodeID)
 		}
 
-		// Update the set of placement ndoes
+		// Update the set of placement nodes
 		nodes[0] = node
 		s.stack.SetNodes(nodes)
 

scheduler/util.go

@@ -172,19 +172,20 @@ func diffSystemAllocs(job *structs.Job, nodes []*structs.Node, taintedNodes map[
 	return result
 }
 
-// readyNodesInDCs returns all the ready nodes in the given datacenters
-func readyNodesInDCs(state State, dcs []string) ([]*structs.Node, error) {
+// readyNodesInDCs returns all the ready nodes in the given datacenters and a
+// mapping of each data center to the count of ready nodes.
+func readyNodesInDCs(state State, dcs []string) ([]*structs.Node, map[string]int, error) {
 	// Index the DCs
-	dcMap := make(map[string]struct{}, len(dcs))
+	dcMap := make(map[string]int, len(dcs))
 	for _, dc := range dcs {
-		dcMap[dc] = struct{}{}
+		dcMap[dc] = 0
 	}
 
 	// Scan the nodes
 	var out []*structs.Node
 	iter, err := state.Nodes()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	for {
 		raw := iter.Next()
@@ -204,8 +205,9 @@ func readyNodesInDCs(state State, dcs []string) ([]*structs.Node, error) {
 			continue
 		}
 		out = append(out, node)
+		dcMap[node.Datacenter] += 1
 	}
-	return out, nil
+	return out, dcMap, nil
 }
 
 // retryMax is used to retry a callback until it returns success or

scheduler/util_test.go

@@ -204,7 +204,7 @@ func TestReadyNodesInDCs(t *testing.T) {
 	noErr(t, state.UpsertNode(1002, node3))
 	noErr(t, state.UpsertNode(1003, node4))
 
-	nodes, err := readyNodesInDCs(state, []string{"dc1", "dc2"})
+	nodes, dc, err := readyNodesInDCs(state, []string{"dc1", "dc2"})
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -215,6 +215,12 @@ func TestReadyNodesInDCs(t *testing.T) {
 	if nodes[0].ID == node3.ID || nodes[1].ID == node3.ID {
 		t.Fatalf("Bad: %#v", nodes)
 	}
+	if count, ok := dc["dc1"]; !ok || count != 0 {
+		t.Fatalf("Bad: dc1 count %v", count)
+	}
+	if count, ok := dc["dc2"]; !ok || count != 2 {
+		t.Fatalf("Bad: dc2 count %v", count)
+	}
 }
 
 func TestRetryMax(t *testing.T) {