Reuse released versiond child ports

Replace the monotonic child port counter with a bounded pool that scans from BasePort and reuses ports after child exit.

Reserve versiond's own listen port so long-lived supervisors cannot eventually assign :8080 to a child, and normalize invalid BasePort values back to the default.

Update manager tests for port reuse, reserved-port skipping, and out-of-range BasePort handling. Document the bounded child-port pool in the rolling update design.

Author: snevolin

devshard/docs/rolling-update.md

@@ -281,6 +281,9 @@ func (m *Manager) assignPort(name string) int {
 ```
 → add a swap-aware allocation (e.g. `assignSwapPort(name)`) that returns a new
 port even when `name` already has one, and a `releasePort` on drain completion.
+The implementation uses a bounded child-port pool starting at `BasePort`,
+reuses ports after child exit, and reserves versiond's own listen port so a
+long-lived supervisor does not eventually allocate it to a child.
 
 #### c) Readiness gate instead of TCP-accept
 

versioned/internal/process/manager.go

@@ -14,6 +14,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -35,6 +36,8 @@ const (
 	statusStopped  = "stopped"
 
 	childLoopbackHost            = "127.0.0.1"
+	invalidChildPort             = -1
+	maxChildPort                 = 65535
 	devshardMetaDBFile           = "_meta.db"
 	defaultDevshardShutdownGrace = 10 * time.Minute
 	installedVersionRetain       = 3
@@ -64,7 +67,7 @@ type Manager struct {
 	draining       map[string][]*child
 	downloading    map[string]struct{}
 	allocatedPorts map[int]struct{}
-	nextPort       int
+	reservedPorts  map[int]struct{}
 	mu             sync.Mutex
 	routes         atomic.Value // map[string]string
 }
@@ -77,14 +80,14 @@ func NewManager(cfg config.Config) *Manager {
 		draining:       make(map[string][]*child),
 		downloading:    make(map[string]struct{}),
 		allocatedPorts: make(map[int]struct{}),
-		nextPort:       cfg.BasePort,
+		reservedPorts:  reservedChildPorts(),
 	}
 	m.routes.Store(map[string]string{})
 	return m
 }
 
 func normalizeConfig(cfg config.Config) config.Config {
-	if cfg.BasePort == 0 {
+	if cfg.BasePort <= 0 || cfg.BasePort > maxChildPort {
 		cfg.BasePort = 5000
 	}
 	if cfg.ReadyPath == "" {
@@ -114,21 +117,49 @@ func normalizeConfig(cfg config.Config) config.Config {
 // assignPort returns a currently-free child port.
 // Must be called with m.mu held.
 func (m *Manager) assignPort() int {
-	for {
-		port := m.nextPort
-		m.nextPort++
+	for port := m.cfg.BasePort; port <= maxChildPort; port++ {
 		if _, used := m.allocatedPorts[port]; used {
 			continue
 		}
+		if _, reserved := m.reservedPorts[port]; reserved {
+			continue
+		}
 		m.allocatedPorts[port] = struct{}{}
 		return port
 	}
+	slog.Error("no child ports available", "base_port", m.cfg.BasePort, "max_port", maxChildPort)
+	return invalidChildPort
+}
+
+func reservedChildPorts() map[int]struct{} {
+	ports := make(map[int]struct{})
+	if port, ok := parseListenPort(config.ListenAddr()); ok {
+		ports[port] = struct{}{}
+	}
+	return ports
+}
+
+func parseListenPort(addr string) (int, bool) {
+	_, portStr, err := net.SplitHostPort(addr)
+	if err != nil {
+		if !strings.HasPrefix(addr, ":") {
+			slog.Warn("cannot parse versiond listen address for child port reservation", "addr", addr, "error", err)
+			return 0, false
+		}
+		portStr = strings.TrimPrefix(addr, ":")
+	}
+	port, err := strconv.Atoi(portStr)
+	if err != nil || port <= 0 || port > maxChildPort {
+		slog.Warn("cannot parse versiond listen port for child port reservation", "addr", addr, "port", portStr, "error", err)
+		return 0, false
+	}
+	return port, true
 }
 
 // releasePort releases a child port after the child process exits.
 // Must be called with m.mu held.
 func (m *Manager) releasePort(port int) {
-	if port != 0 {
+	if port > 0 {
 		delete(m.allocatedPorts, port)
 	}
 }

versioned/internal/process/manager_test.go

@@ -470,7 +470,7 @@ func TestHashFile_Missing(t *testing.T) {
 	}
 }
 
-func TestAssignPort_AllocatesOverlapPortsAndReleases(t *testing.T) {
+func TestAssignPort_ReusesReleasedPorts(t *testing.T) {
 	cfg := config.Config{BasePort: 5000}
 	m := NewManager(cfg)
 
@@ -487,8 +487,36 @@ func TestAssignPort_AllocatesOverlapPortsAndReleases(t *testing.T) {
 	if p2 != 5001 {
 		t.Errorf("second port = %d, want 5001", p2)
 	}
-	if p3 != 5002 {
-		t.Errorf("released port should not be immediately reused; got %d, want 5002", p3)
+	if p3 != 5000 {
+		t.Errorf("released port should be reused; got %d, want 5000", p3)
+	}
+}
+
+func TestAssignPort_SkipsVersiondListenPort(t *testing.T) {
+	m := NewManager(config.Config{BasePort: 8079})
+
+	m.mu.Lock()
+	p1 := m.assignPort()
+	p2 := m.assignPort()
+	m.mu.Unlock()
+
+	if p1 != 8079 {
+		t.Errorf("first port = %d, want 8079", p1)
+	}
+	if p2 != 8081 {
+		t.Errorf("second port = %d, want 8081", p2)
+	}
+}
+
+func TestAssignPort_NormalizesOutOfRangeBasePort(t *testing.T) {
+	m := NewManager(config.Config{BasePort: 70000})
+
+	m.mu.Lock()
+	port := m.assignPort()
+	m.mu.Unlock()
+
+	if port != 5000 {
+		t.Errorf("port = %d, want 5000", port)
 	}
 }