refactor(workstation): Use port allocator

pkg/workstation/network/network.go

@@ -89,14 +89,17 @@ func (n *BaseNetworkManager) Initialize() error {
 
 	n.services = serviceList
 
+	// Create PortAllocator for this initialization run
+	portAllocator := services.NewPortAllocator()
+
 	networkCIDR := n.configHandler.GetString("network.cidr_block")
 	if networkCIDR == "" {
 		networkCIDR = constants.DefaultNetworkCIDR
 		if err := n.configHandler.Set("network.cidr_block", networkCIDR); err != nil {
 			return fmt.Errorf("error setting default network CIDR: %w", err)
 		}
 	}
-	if err := assignIPAddresses(n.services, &networkCIDR); err != nil {
+	if err := assignIPAddresses(n.services, &networkCIDR, portAllocator); err != nil {
 		return fmt.Errorf("error assigning IP addresses: %w", err)
 	}
 
@@ -123,7 +126,7 @@ func (n *BaseNetworkManager) isLocalhostMode() bool {
 // =============================================================================
 
 // assignIPAddresses assigns IP addresses to services based on the network CIDR.
-var assignIPAddresses = func(services []services.Service, networkCIDR *string) error {
+var assignIPAddresses = func(serviceList []services.Service, networkCIDR *string, portAllocator *services.PortAllocator) error {
 	if networkCIDR == nil || *networkCIDR == "" {
 		return fmt.Errorf("network CIDR is not defined")
 	}
@@ -139,8 +142,9 @@ var assignIPAddresses = func(services []services.Service, networkCIDR *string) e
 	// Skip the first IP address
 	ip = incrementIP(ip)
 
-	for i := range services {
-		if err := services[i].SetAddress(ip.String()); err != nil {
+	for i := range serviceList {
+		serviceAddress := ip.String()
+		if err := serviceList[i].SetAddress(serviceAddress, portAllocator); err != nil {
 			return fmt.Errorf("error setting address for service: %w", err)
 		}
 		ip = incrementIP(ip)

pkg/workstation/network/network_test.go

@@ -8,9 +8,9 @@ import (
 	"testing"
 
 	"github.com/windsorcli/cli/pkg/context/config"
-	"github.com/windsorcli/cli/pkg/di"
 	"github.com/windsorcli/cli/pkg/context/shell"
 	"github.com/windsorcli/cli/pkg/context/shell/ssh"
+	"github.com/windsorcli/cli/pkg/di"
 	"github.com/windsorcli/cli/pkg/workstation/services"
 )
 
@@ -251,11 +251,11 @@ func TestNetworkManager_Initialize(t *testing.T) {
 		var setAddressCalls []string
 		mockService1 := mocks.Services[0]
 		mockService2 := mocks.Services[1]
-		mockService1.SetAddressFunc = func(address string) error {
+		mockService1.SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			setAddressCalls = append(setAddressCalls, address)
 			return nil
 		}
-		mockService2.SetAddressFunc = func(address string) error {
+		mockService2.SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			setAddressCalls = append(setAddressCalls, address)
 			return nil
 		}
@@ -286,7 +286,7 @@ func TestNetworkManager_Initialize(t *testing.T) {
 	t.Run("SetAddressFailure", func(t *testing.T) {
 		// Given a network manager with service address failure
 		manager, mocks := setup(t)
-		mocks.Services[0].SetAddressFunc = func(address string) error {
+		mocks.Services[0].SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			return fmt.Errorf("mock error setting address for service")
 		}
 
@@ -370,7 +370,7 @@ func TestNetworkManager_Initialize(t *testing.T) {
 	t.Run("ErrorSettingNetworkCidr", func(t *testing.T) {
 		// Given a network manager with CIDR setting error
 		manager, mocks := setup(t)
-		mocks.Services[0].SetAddressFunc = func(address string) error {
+		mocks.Services[0].SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			return fmt.Errorf("error setting default network CIDR")
 		}
 
@@ -392,7 +392,7 @@ func TestNetworkManager_Initialize(t *testing.T) {
 	t.Run("ErrorAssigningIPAddresses", func(t *testing.T) {
 		// Given a network manager with IP assignment error
 		manager, mocks := setup(t)
-		mocks.Services[0].SetAddressFunc = func(address string) error {
+		mocks.Services[0].SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			return fmt.Errorf("mock assign IP addresses error")
 		}
 
@@ -477,18 +477,18 @@ func TestNetworkManager_assignIPAddresses(t *testing.T) {
 		// Given a list of services and a network CIDR
 		_, mocks := setup(t)
 		var setAddressCalls []string
-		mocks.Services[0].SetAddressFunc = func(address string) error {
+		mocks.Services[0].SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			setAddressCalls = append(setAddressCalls, address)
 			return nil
 		}
-		mocks.Services[1].SetAddressFunc = func(address string) error {
+		mocks.Services[1].SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			setAddressCalls = append(setAddressCalls, address)
 			return nil
 		}
 		networkCIDR := "10.5.0.0/16"
 
 		// When assigning IP addresses
-		err := assignIPAddresses(toServices(mocks.Services), &networkCIDR)
+		err := assignIPAddresses(toServices(mocks.Services), &networkCIDR, services.NewPortAllocator())
 
 		// Then no error should occur
 		if err != nil {
@@ -510,7 +510,7 @@ func TestNetworkManager_assignIPAddresses(t *testing.T) {
 		networkCIDR := "invalid-cidr"
 
 		// When assigning IP addresses
-		err := assignIPAddresses(toServices(mocks.Services), &networkCIDR)
+		err := assignIPAddresses(toServices(mocks.Services), &networkCIDR, services.NewPortAllocator())
 
 		// Then an error should occur
 		if err == nil {
@@ -526,13 +526,13 @@ func TestNetworkManager_assignIPAddresses(t *testing.T) {
 	t.Run("ErrorSettingAddress", func(t *testing.T) {
 		// Given a service that fails to set address
 		_, mocks := setup(t)
-		mocks.Services[0].SetAddressFunc = func(address string) error {
+		mocks.Services[0].SetAddressFunc = func(address string, portAllocator *services.PortAllocator) error {
 			return fmt.Errorf("error setting address")
 		}
 		networkCIDR := "10.5.0.0/16"
 
 		// When assigning IP addresses
-		err := assignIPAddresses(toServices(mocks.Services[:1]), &networkCIDR)
+		err := assignIPAddresses(toServices(mocks.Services[:1]), &networkCIDR, services.NewPortAllocator())
 
 		// Then an error should occur
 		if err == nil {
@@ -551,7 +551,7 @@ func TestNetworkManager_assignIPAddresses(t *testing.T) {
 		networkCIDR := "10.5.0.0/30"
 
 		// When assigning IP addresses
-		err := assignIPAddresses(toServices(mocks.Services), &networkCIDR)
+		err := assignIPAddresses(toServices(mocks.Services), &networkCIDR, services.NewPortAllocator())
 
 		// Then an error should occur
 		if err == nil {
@@ -570,7 +570,7 @@ func TestNetworkManager_assignIPAddresses(t *testing.T) {
 		var networkCIDR *string
 
 		// When assigning IP addresses
-		err := assignIPAddresses(toServices(mocks.Services[:1]), networkCIDR)
+		err := assignIPAddresses(toServices(mocks.Services[:1]), networkCIDR, services.NewPortAllocator())
 
 		// Then an error should occur
 		if err == nil {

pkg/workstation/services/dns_service.go

@@ -57,12 +57,12 @@ func (s *DNSService) Initialize() error {
 }
 
 // SetAddress updates DNS address in config and calls BaseService's SetAddress.
-func (s *DNSService) SetAddress(address string) error {
+func (s *DNSService) SetAddress(address string, portAllocator *PortAllocator) error {
 	err := s.configHandler.Set("dns.address", address)
 	if err != nil {
 		return fmt.Errorf("error setting DNS address: %w", err)
 	}
-	return s.BaseService.SetAddress(address)
+	return s.BaseService.SetAddress(address, portAllocator)
 }
 
 // GetComposeConfig sets up CoreDNS with context and domain, configures ports if localhost.

pkg/workstation/services/dns_service_test.go

@@ -152,7 +152,7 @@ func TestDNSService_SetAddress(t *testing.T) {
 
 		// When SetAddress is called
 		address := "127.0.0.1"
-		err := service.SetAddress(address)
+		err := service.SetAddress(address, nil)
 
 		setAddress := mocks.ConfigHandler.GetString("dns.address")
 
@@ -180,7 +180,7 @@ func TestDNSService_SetAddress(t *testing.T) {
 
 		// When SetAddress is called
 		address := "127.0.0.1"
-		err := service.SetAddress(address)
+		err := service.SetAddress(address, nil)
 
 		// Then an error should be returned
 		if err == nil {
@@ -329,7 +329,7 @@ func TestDNSService_WriteConfig(t *testing.T) {
 		service, mocks := setup(t)
 
 		// Set the address to localhost to mock IsLocalhost behavior
-		service.SetAddress("127.0.0.1")
+		service.SetAddress("127.0.0.1", nil)
 
 		// Set the DNS domain
 		mocks.ConfigHandler.Set("dns.domain", "test")
@@ -384,7 +384,7 @@ func TestDNSService_WriteConfig(t *testing.T) {
 		}
 
 		service.SetName("test")
-		service.SetAddress("192.168.1.1")
+		service.SetAddress("192.168.1.1", nil)
 
 		// Execute
 		err := service.WriteConfig()
@@ -643,7 +643,7 @@ func TestDNSService_WriteConfig(t *testing.T) {
 		}
 
 		service.SetName("test")
-		service.SetAddress("192.168.1.1")
+		service.SetAddress("192.168.1.1", nil)
 
 		// Execute
 		err := service.WriteConfig()
@@ -840,7 +840,7 @@ func TestDNSService_GetHostname(t *testing.T) {
 	t.Run("ErrorGettingHostname", func(t *testing.T) {
 		// Given a DNSService with no name set
 		service, mocks := setup(t)
-		service.SetName("")                                   // Clear the name
+		service.SetName("")                       // Clear the name
 		mocks.ConfigHandler.Set("dns.domain", "") // Clear the domain
 
 		// When GetHostname is called

pkg/workstation/services/mock_service.go

@@ -18,7 +18,7 @@ type MockService struct {
 	BaseService
 	GetComposeConfigFunc func() (*types.Config, error)
 	WriteConfigFunc      func() error
-	SetAddressFunc       func(address string) error
+	SetAddressFunc       func(address string, portAllocator *PortAllocator) error
 	GetAddressFunc       func() string
 	InitializeFunc       func() error
 	SetNameFunc          func(name string)
@@ -65,9 +65,9 @@ func (m *MockService) WriteConfig() error {
 }
 
 // SetAddress calls the mock SetAddressFunc if it is set, otherwise returns nil
-func (m *MockService) SetAddress(address string) error {
+func (m *MockService) SetAddress(address string, portAllocator *PortAllocator) error {
 	if m.SetAddressFunc != nil {
-		return m.SetAddressFunc(address)
+		return m.SetAddressFunc(address, portAllocator)
 	}
 	return nil
 }

pkg/workstation/services/mock_service_test.go

@@ -118,12 +118,12 @@ func TestMockService_SetAddress(t *testing.T) {
 	t.Run("Success", func(t *testing.T) {
 		// Given a new MockService with SetAddressFunc set
 		mock := NewMockService()
-		mock.SetAddressFunc = func(address string) error {
+		mock.SetAddressFunc = func(address string, portAllocator *PortAllocator) error {
 			return nil
 		}
 
 		// When SetAddress is called
-		err := mock.SetAddress("test-address")
+		err := mock.SetAddress("test-address", nil)
 
 		// Then no error should be returned
 		if err != nil {
@@ -136,7 +136,7 @@ func TestMockService_SetAddress(t *testing.T) {
 		mock := NewMockService()
 
 		// When SetAddress is called
-		err := mock.SetAddress("test-address")
+		err := mock.SetAddress("test-address", nil)
 
 		// Then no error should be returned
 		if err != nil {

pkg/workstation/services/port_allocator.go

@@ -0,0 +1,25 @@
+package services
+
+// PortAllocator manages port allocation for services during network initialization.
+// It tracks allocated ports to prevent conflicts.
+type PortAllocator struct {
+	allocatedPorts map[int]bool
+}
+
+// NewPortAllocator creates a new PortAllocator with initial state.
+func NewPortAllocator() *PortAllocator {
+	return &PortAllocator{
+		allocatedPorts: make(map[int]bool),
+	}
+}
+
+// NextAvailablePort finds the next available port starting from basePort. If basePort is already allocated,
+// it increments until finding an available port. Returns the allocated port.
+func (p *PortAllocator) NextAvailablePort(basePort int) int {
+	port := basePort
+	for p.allocatedPorts[port] {
+		port++
+	}
+	p.allocatedPorts[port] = true
+	return port
+}

pkg/workstation/services/registry_service.go

@@ -69,8 +69,8 @@ func (s *RegistryService) GetComposeConfig() (*types.Config, error) {
 
 // SetAddress configures the registry's address, forms a hostname, and updates the registry config.
 // It assigns the "registry_url" and the default host port for the first non-remote registry, storing it as "localRegistry".
-func (s *RegistryService) SetAddress(address string) error {
-	if err := s.BaseService.SetAddress(address); err != nil {
+func (s *RegistryService) SetAddress(address string, portAllocator *PortAllocator) error {
+	if err := s.BaseService.SetAddress(address, portAllocator); err != nil {
 		return fmt.Errorf("failed to set address for base service: %w", err)
 	}
 

pkg/workstation/services/registry_service_test.go

@@ -259,7 +259,7 @@ contexts:
 		}
 
 		// When SetAddress is called with localhost
-		err := service.SetAddress("localhost")
+		err := service.SetAddress("localhost", nil)
 
 		// Then there should be no error
 		if err != nil {
@@ -303,7 +303,7 @@ contexts:
 		}
 
 		// When SetAddress is called
-		err := service.SetAddress("192.168.1.1")
+		err := service.SetAddress("192.168.1.1", nil)
 
 		// Then there should be no error
 		if err != nil {
@@ -340,7 +340,7 @@ contexts:
 		}
 
 		// When SetAddress is called
-		err := service.SetAddress("192.168.1.1")
+		err := service.SetAddress("192.168.1.1", nil)
 
 		// Then there should be no error
 		if err != nil {
@@ -366,7 +366,7 @@ contexts:
 		service1.SetName("registry1")
 
 		// When SetAddress is called for first registry
-		err := service1.SetAddress("localhost")
+		err := service1.SetAddress("localhost", nil)
 		if err != nil {
 			t.Fatalf("Failed to set address for first registry: %v", err)
 		}
@@ -378,7 +378,7 @@ contexts:
 		service2.SetName("registry2")
 
 		// When SetAddress is called for second registry
-		err = service2.SetAddress("localhost")
+		err = service2.SetAddress("localhost", nil)
 		if err != nil {
 			t.Fatalf("Failed to set address for second registry: %v", err)
 		}
@@ -411,7 +411,7 @@ contexts:
 		service.SetName("registry")
 
 		// When SetAddress is called with invalid address
-		err := service.SetAddress("invalid-address")
+		err := service.SetAddress("invalid-address", nil)
 
 		// Then there should be an error
 		if err == nil {
@@ -440,7 +440,7 @@ contexts:
 		}
 
 		// When SetAddress is called
-		err := service.SetAddress("localhost")
+		err := service.SetAddress("localhost", nil)
 
 		// Then there should be an error
 		if err == nil {
@@ -492,7 +492,7 @@ contexts:
 		}
 
 		// When SetAddress is called
-		err := service.SetAddress("localhost")
+		err := service.SetAddress("localhost", nil)
 
 		// Then there should be an error
 		if err == nil {
@@ -548,7 +548,7 @@ contexts:
 		}
 
 		// When SetAddress is called
-		err := service.SetAddress("localhost")
+		err := service.SetAddress("localhost", nil)
 
 		// Then there should be an error
 		if err == nil {