UA-.NETStandard/tests/Opc.Ua.Redundancy.Samples.Tests/TestPorts.cs

/* ========================================================================
 * Copyright (c) 2005-2026 The OPC Foundation, Inc. All rights reserved.
 *
 * OPC Foundation MIT License 1.00
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * The complete license agreement can be found here:
 * http://opcfoundation.org/License/MIT/1.00/
 * ======================================================================*/

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using NUnit.Framework;

namespace Opc.Ua.Redundancy.Samples.Tests
{
    /// <summary>
    /// Allocates free loopback TCP and UDP ports for the sample processes. Using
    /// OS-assigned ephemeral ports avoids collisions with other processes and with
    /// host-reserved or excluded port ranges (for example the Hyper-V / WSL
    /// exclusions on Windows).
    /// </summary>
    internal static class TestPorts
    {
        /// <summary>
        /// Finds and returns a currently-free loopback UDP port that has not
        /// been previously returned by this method in the current process. The
        /// allocation is tracked process-wide so that sequential OS port-0
        /// requests, which may return the same number, never produce a duplicate.
        /// The port is released before this method returns.
        /// </summary>
        /// <returns>A free UDP port number.</returns>
        public static int GetFreeUdpPort()
        {
            while (true)
            {
                using var udpClient = new UdpClient(new IPEndPoint(IPAddress.Loopback, 0));
                int port = ((IPEndPoint)udpClient.Client.LocalEndPoint!).Port;
                if (s_allocatedUdpPorts.TryAdd(port, 0))
                {
                    return port;
                }
            }
        }

        /// <summary>
        /// Finds and returns a currently-free loopback TCP port.
        /// </summary>
        /// <returns>A free TCP port number.</returns>
        public static int GetFreePort()
        {
            var listener = new TcpListener(IPAddress.Loopback, 0);
            listener.Start();
            try
            {
                return ((IPEndPoint)listener.LocalEndpoint).Port;
            }
            finally
            {
                listener.Stop();
            }
        }

        /// <summary>
        /// Finds and returns the requested number of distinct free loopback TCP ports.
        /// </summary>
        /// <param name="count">The number of ports to allocate.</param>
        /// <returns>The allocated distinct ports.</returns>
        public static int[] GetFreePorts(int count)
        {
            var ports = new HashSet<int>();
            while (ports.Count < count)
            {
                ports.Add(GetFreePort());
            }

            int[] result = new int[count];
            ports.CopyTo(result);
            return result;
        }

        /// <summary>
        /// Finds a free adjacent loopback pair for address-space gossip and its session-gossip port.
        /// </summary>
        /// <exception cref="System.InvalidOperationException">
        /// No adjacent gossip port pair could be reserved within the retry limit.
        /// </exception>
        public static int GetFreeGossipPortPair()
        {
            for (int attempt = 0; attempt < 100; attempt++)
            {
                var first = new TcpListener(IPAddress.Loopback, 0);
                TcpListener? second = null;
                first.Start();
                try
                {
                    int port = ((IPEndPoint)first.LocalEndpoint).Port;
                    if (port == IPEndPoint.MaxPort)
                    {
                        continue;
                    }
                    second = new TcpListener(IPAddress.Loopback, port + 1);
                    second.Start();
                    return port;
                }
                catch (SocketException exception) when (
                    exception.SocketErrorCode is SocketError.AddressAlreadyInUse or SocketError.AccessDenied)
                {
                    TestContext.Progress.WriteLine("Retrying unavailable adjacent gossip port: {0}", exception.Message);
                }
                finally
                {
                    second?.Stop();
                    first.Stop();
                }
            }
            throw new System.InvalidOperationException("Could not reserve an adjacent gossip port pair.");
        }

        private static readonly ConcurrentDictionary<int, byte> s_allocatedUdpPorts = new();
    }
}