scheduler: detect and log unexpected scheduling collisions

nomad/fsm.go

@@ -1801,7 +1801,7 @@ func (n *nomadFSM) reconcileQueuedAllocations(index uint64) error {
 		// Ignore eval event creation during snapshot restore
 		snap.UpsertEvals(structs.IgnoreUnknownTypeFlag, 100, []*structs.Evaluation{eval})
 		// Create the scheduler and run it
-		sched, err := scheduler.NewScheduler(eval.Type, n.logger, snap, planner)
+		sched, err := scheduler.NewScheduler(eval.Type, n.logger, nil, snap, planner)
 		if err != nil {
 			return err
 		}

nomad/job_endpoint.go

@@ -1785,7 +1785,7 @@ func (j *Job) Plan(args *structs.JobPlanRequest, reply *structs.JobPlanResponse)
 	}
 
 	// Create the scheduler and run it
-	sched, err := scheduler.NewScheduler(eval.Type, j.logger, snap, planner)
+	sched, err := scheduler.NewScheduler(eval.Type, j.logger, j.srv.workersEventCh, snap, planner)
 	if err != nil {
 		return err
 	}

nomad/mock/mock.go

@@ -2,6 +2,7 @@ package mock
 
 import (
 	"fmt"
+	"math/rand"
 	"time"
 
 	"github.com/hashicorp/nomad/helper"
@@ -1349,6 +1350,58 @@ func Alloc() *structs.Allocation {
 	return alloc
 }
 
+func AllocWithoutReservedPort() *structs.Allocation {
+	alloc := Alloc()
+	alloc.Resources.Networks[0].ReservedPorts = nil
+	alloc.TaskResources["web"].Networks[0].ReservedPorts = nil
+	alloc.AllocatedResources.Tasks["web"].Networks[0].ReservedPorts = nil
+
+	return alloc
+}
+
+func AllocForNode(n *structs.Node) *structs.Allocation {
+	nodeIP := n.NodeResources.NodeNetworks[0].Addresses[0].Address
+
+	dynamicPortRange := structs.DefaultMaxDynamicPort - structs.DefaultMinDynamicPort
+	randomDynamicPort := rand.Intn(dynamicPortRange) + structs.DefaultMinDynamicPort
+
+	alloc := Alloc()
+	alloc.NodeID = n.ID
+
+	// Set node IP address.
+	alloc.Resources.Networks[0].IP = nodeIP
+	alloc.TaskResources["web"].Networks[0].IP = nodeIP
+	alloc.AllocatedResources.Tasks["web"].Networks[0].IP = nodeIP
+
+	// Set dynamic port to a random value.
+	alloc.TaskResources["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
+	alloc.AllocatedResources.Tasks["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
+
+	return alloc
+
+}
+
+func AllocForNodeWithoutReservedPort(n *structs.Node) *structs.Allocation {
+	nodeIP := n.NodeResources.NodeNetworks[0].Addresses[0].Address
+
+	dynamicPortRange := structs.DefaultMaxDynamicPort - structs.DefaultMinDynamicPort
+	randomDynamicPort := rand.Intn(dynamicPortRange) + structs.DefaultMinDynamicPort
+
+	alloc := AllocWithoutReservedPort()
+	alloc.NodeID = n.ID
+
+	// Set node IP address.
+	alloc.Resources.Networks[0].IP = nodeIP
+	alloc.TaskResources["web"].Networks[0].IP = nodeIP
+	alloc.AllocatedResources.Tasks["web"].Networks[0].IP = nodeIP
+
+	// Set dynamic port to a random value.
+	alloc.TaskResources["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
+	alloc.AllocatedResources.Tasks["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
+
+	return alloc
+}
+
 // ConnectAlloc adds a Connect proxy sidecar group service to mock.Alloc.
 func ConnectAlloc() *structs.Allocation {
 	alloc := Alloc()

nomad/plan_apply.go

@@ -475,6 +475,8 @@ func evaluatePlanPlacements(pool *EvaluatePool, snap *state.StateSnapshot, plan
 			return true
 		}
 		if !fit {
+			metrics.IncrCounterWithLabels([]string{"nomad", "plan", "node_rejected"}, 1, []metrics.Label{{Name: "node_id", Value: nodeID}})
+
 			// Log the reason why the node's allocations could not be made
 			if reason != "" {
 				//TODO This was debug level and should return

nomad/server.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/tls"
 	"crypto/x509"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io/ioutil"
@@ -229,6 +230,7 @@ type Server struct {
 	workers          []*Worker
 	workerLock       sync.RWMutex
 	workerConfigLock sync.RWMutex
+	workersEventCh   chan interface{}
 
 	// aclCache is used to maintain the parsed ACL objects
 	aclCache *lru.TwoQueueCache
@@ -344,6 +346,7 @@ func NewServer(config *Config, consulCatalog consul.CatalogAPI, consulConfigEntr
 		blockedEvals:     NewBlockedEvals(evalBroker, logger),
 		rpcTLS:           incomingTLS,
 		aclCache:         aclCache,
+		workersEventCh:   make(chan interface{}, 1),
 	}
 
 	s.shutdownCtx, s.shutdownCancel = context.WithCancel(context.Background())
@@ -1581,6 +1584,8 @@ func reloadSchedulers(s *Server, newArgs *SchedulerWorkerPoolArgs) {
 func (s *Server) setupWorkers(ctx context.Context) error {
 	poolArgs := s.GetSchedulerWorkerConfig()
 
+	go s.listenWorkerEvents()
+
 	// we will be writing to the worker slice
 	s.workerLock.Lock()
 	defer s.workerLock.Unlock()
@@ -1665,6 +1670,49 @@ func (s *Server) stopOldWorkers(oldWorkers []*Worker) {
 	}
 }
 
+// listenWorkerEvents listens for events emitted by scheduler workers and log
+// them if necessary. Some events may be skipped to avoid polluting logs with
+// duplicates.
+func (s *Server) listenWorkerEvents() {
+	loggedAt := make(map[string]time.Time)
+
+	gcDeadline := 4 * time.Hour
+	gcTicker := time.NewTicker(10 * time.Second)
+	defer gcTicker.Stop()
+
+	for {
+		select {
+		case <-gcTicker.C:
+			for k, v := range loggedAt {
+				if time.Since(v) >= gcDeadline {
+					delete(loggedAt, k)
+				}
+			}
+		case e := <-s.workersEventCh:
+			switch event := e.(type) {
+			case *scheduler.PortCollisionEvent:
+				if event == nil || event.Node == nil {
+					continue
+				}
+
+				if _, ok := loggedAt[event.Node.ID]; ok {
+					continue
+				}
+
+				eventJson, err := json.Marshal(event.Sanitize())
+				if err != nil {
+					s.logger.Debug("failed to encode event to JSON", "error", err)
+				}
+				s.logger.Warn("unexpected node port collision, refer to https://www.nomadproject.io/s/port-plan-failure for more information",
+					"node_id", event.Node.ID, "reason", event.Reason, "event", string(eventJson))
+				loggedAt[event.Node.ID] = time.Now()
+			}
+		case <-s.shutdownCh:
+			return
+		}
+	}
+}
+
 // numPeers is used to check on the number of known peers, including the local
 // node.
 func (s *Server) numPeers() (int, error) {

nomad/structs/funcs.go

@@ -187,8 +187,12 @@ func AllocsFit(node *Node, allocs []*Allocation, netIdx *NetworkIndex, checkDevi
 	if netIdx == nil {
 		netIdx = NewNetworkIndex()
 		defer netIdx.Release()
-		if netIdx.SetNode(node) || netIdx.AddAllocs(allocs) {
-			return false, "reserved port collision", used, nil
+
+		if collision, reason := netIdx.SetNode(node); collision {
+			return false, fmt.Sprintf("reserved node port collision: %v", reason), used, nil
+		}
+		if collision, reason := netIdx.AddAllocs(allocs); collision {
+			return false, fmt.Sprintf("reserved alloc port collision: %v", reason), used, nil
 		}
 	}