feat: availableport enhancements

ignite/pkg/availableport/availableport.go

@@ -7,17 +7,74 @@ import (
 	"time"
 )
 
+type OptionalParameters struct {
+	WithRandomizer *rand.Rand
+	WithMinPort    int
+	WithMaxPort    int
+}
+
 // Find finds n number of unused ports.
 // it is not guaranteed that these ports will not be allocated to
 // another program in the time of calling Find().
-func Find(n int) (ports []int, err error) {
-	min := 44000
-	max := 55000
+func Find(n int, moreParameters ...OptionalParameters) (ports []int, err error) {
+	// Defining them before so we can set a value depending on the OptionalParameters
+	var min int
+	var max int
+	var r *rand.Rand
 
+	if len(moreParameters) != 0 {
+		extra := moreParameters[0]
+		if extra.WithMinPort != 0 {
+			if extra.WithMinPort > -1 {
+				min = extra.WithMinPort
+			} else {
+				// This is not required since the port would become 0
+				// but the user could not notice that sent a negative port
+				return nil, fmt.Errorf("ports can't be negative (negative min port given)")
+			}
+		} else {
+			min = 44000
+		}
+		if extra.WithMaxPort != 0 {
+			if extra.WithMaxPort > -1 {
+				max = extra.WithMaxPort
+			} else {
+				// This is not required since the port would become 0
+				// but the user could not notice that sent a negative port
+				return nil, fmt.Errorf("ports can't be negative (negative max port given)")
+			}
+		} else {
+			max = 55000
+		}
+		if extra.WithRandomizer != nil {
+			r = extra.WithRandomizer
+		} else {
+			r = rand.New(rand.NewSource(time.Now().UnixNano()))
+		}
+	} else {
+		// If we don't require special conditions, we can
+		// return to the original parameters
+		min = 44000
+		max = 55000
+		r = rand.New(rand.NewSource(time.Now().UnixNano()))
+	}
+
+	// If the number of ports required is bigger than the range, this stops it
+	if max < min {
+		return nil, fmt.Errorf("invalid ports range: max < min (%d < %d)", max, min)
+	}
+
+	// If the number of ports required is bigger than the range, this stops it
+	if n > (max - min) {
+		return nil, fmt.Errorf("invalid amount of ports requested: limit is %d", max-min)
+	}
+
+	// Marker to point if a port is already added in the list
+	registered := make(map[int]bool)
 	for i := 0; i < n; i++ {
 		for {
-			rand.Seed(time.Now().UnixNano())
-			port := rand.Intn(max-min+1) + min
+			// Greater or equal to min and lower than max
+			port := r.Intn(max-min+1) + min
 
 			conn, err := net.Dial("tcp", fmt.Sprintf(":%d", port))
 			// if there is an error, this might mean that no one is listening from this port
@@ -26,7 +83,13 @@ func Find(n int) (ports []int, err error) {
 				conn.Close()
 				continue
 			}
+			// if the port is already registered we skip it to the next one
+			// otherwise it's added to the ports list and pointed in our map
+			if registered[port] {
+				continue
+			}
 			ports = append(ports, port)
+			registered[port] = true
 			break
 		}
 	}

ignite/pkg/availableport/availableport_test.go

@@ -0,0 +1,83 @@
+package availableport_test
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+
+	"github.com/ignite/cli/ignite/pkg/availableport"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAvailablePort(t *testing.T) {
+
+	ports, err := availableport.Find(10)
+	require.Equal(t, nil, err)
+	require.Equal(t, 10, len(ports))
+
+	for idx := 0; idx < 9; idx++ {
+		for jdx := idx + 1; jdx < 10; jdx++ {
+			require.NotEqual(t, ports[idx], ports[jdx])
+		}
+	}
+
+	// Case no ports generated
+	options := availableport.OptionalParameters{
+		WithMinPort: 1,
+		WithMaxPort: 1,
+	}
+	ports, err = availableport.Find(10, options)
+	require.Equal(t, fmt.Errorf("invalid amount of ports requested: limit is 0"), err)
+	require.Equal(t, 0, len(ports))
+
+	// Case max < min
+	options = availableport.OptionalParameters{
+		WithMinPort: 5,
+		WithMaxPort: 1,
+	}
+	ports, err = availableport.Find(10, options)
+	require.Equal(t, fmt.Errorf("invalid ports range: max < min (1 < 5)"), err)
+	require.Equal(t, 0, len(ports))
+
+	// Case max < min min restriction given
+	options = availableport.OptionalParameters{
+		WithMinPort: 55001,
+	}
+	ports, err = availableport.Find(10, options)
+	require.Equal(t, fmt.Errorf("invalid ports range: max < min (55000 < 55001)"), err)
+	require.Equal(t, 0, len(ports))
+
+	// Case max < min max restriction given
+	options = availableport.OptionalParameters{
+		WithMaxPort: 43999,
+	}
+	ports, err = availableport.Find(10, options)
+	require.Equal(t, fmt.Errorf("invalid ports range: max < min (43999 < 44000)"), err)
+	require.Equal(t, 0, len(ports))
+
+	// Case negative min
+	options = availableport.OptionalParameters{
+		WithMinPort: -10,
+	}
+	ports, err = availableport.Find(10, options)
+	require.Equal(t, fmt.Errorf("ports can't be negative (negative min port given)"), err)
+	require.Equal(t, 0, len(ports))
+
+	// Case negative max
+	options = availableport.OptionalParameters{
+		WithMaxPort: -10,
+	}
+	ports, err = availableport.Find(10, options)
+	require.Equal(t, fmt.Errorf("ports can't be negative (negative max port given)"), err)
+	require.Equal(t, 0, len(ports))
+
+	// Case randomizer given
+	options = availableport.OptionalParameters{
+		WithRandomizer: rand.New(rand.NewSource(2023)),
+		WithMinPort:    100,
+		WithMaxPort:    200,
+	}
+	ports, err = availableport.Find(10, options)
+	require.Equal(t, 10, len(ports))
+	require.Equal(t, []int{195, 129, 150, 108, 120, 169, 166, 121, 131, 160}, ports)
+}