Public Member Functions

PortAllocator (IServerPortProvider serverPortProvider, IDatabaseContextFactory databaseContextFactory, IPlatformIdentifier platformIdentifier, IOptions< SwarmConfiguration > swarmConfigurationOptions, ILogger< PortAllocator > logger)

Initializes a new instance of the PortAllocator class.

void Dispose ()

async ValueTask< ushort?> GetAvailablePort (ushort basePort, bool checkOne, CancellationToken cancellationToken)

Gets a port not currently in use by TGS.

Parameters

basePort	The port to check first. Will not allocate a port lower than this.
checkOne	If only basePort should be checked and no others.
cancellationToken	The CancellationToken for the operation.

Returns: A ValueTask<TResult> resulting in the first available port on success, null on failure.

Private Member Functions
async ValueTask< ushort?>	GetAvailablePort (IDatabaseContext databaseContext, ushort basePort, bool checkOne, CancellationToken cancellationToken)
	Gets a port not currently in use by TGS.

Private Attributes
readonly IServerPortProvider	serverPortProvider
	The IServerPortProvider for the PortAllocator.

readonly IDatabaseContextFactory	databaseContextFactory
	The IDatabaseContext for the PortAllocator.

readonly IPlatformIdentifier	platformIdentifier
	The IPlatformIdentifier for the PortAllocator.

readonly IOptions< SwarmConfiguration >	swarmConfigurationOptions
	The IOptions<TOptions> of SwarmConfiguration for the PortAllocator.

readonly ILogger< PortAllocator >	logger
	The ILogger for the PortAllocator.

readonly SemaphoreSlim	allocatorLock
	The SemaphoreSlim used to serialized port requisition requests.

Detailed Description

Definition at line 20 of file PortAllocator.cs.

Constructor & Destructor Documentation

◆ PortAllocator()

Tgstation.Server.Host.Utils.PortAllocator.PortAllocator	(	IServerPortProvider	serverPortProvider,
		IDatabaseContextFactory	databaseContextFactory,
		IPlatformIdentifier	platformIdentifier,
		IOptions< SwarmConfiguration >	swarmConfigurationOptions,
		ILogger< PortAllocator >	logger
	)

Initializes a new instance of the PortAllocator class.

Parameters

serverPortProvider	The value of serverPortProvider.
databaseContextFactory	The value of databaseContextFactory.
platformIdentifier	The value of platformIdentifier.
swarmConfigurationOptions	The value of swarmConfigurationOptions.
logger	The value of logger.

Definition at line 60 of file PortAllocator.cs.

        {
            this.serverPortProvider = serverPortProvider ?? throw new ArgumentNullException(nameof(serverPortProvider));
            this.databaseContextFactory = databaseContextFactory ?? throw new ArgumentNullException(nameof(databaseContextFactory));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            this.swarmConfigurationOptions = swarmConfigurationOptions ?? throw new ArgumentNullException(nameof(swarmConfigurationOptions));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
            allocatorLock = new SemaphoreSlim(1);
        }

References Tgstation.Server.Host.Utils.PortAllocator.allocatorLock, Tgstation.Server.Host.Utils.PortAllocator.databaseContextFactory, Tgstation.Server.Host.Utils.PortAllocator.logger, Tgstation.Server.Host.Utils.PortAllocator.platformIdentifier, Tgstation.Server.Host.Utils.PortAllocator.serverPortProvider, and Tgstation.Server.Host.Utils.PortAllocator.swarmConfigurationOptions.

Member Function Documentation

◆ Dispose()

void Tgstation.Server.Host.Utils.PortAllocator.Dispose ( )

◆ GetAvailablePort() [1/2]

async ValueTask< ushort?> Tgstation.Server.Host.Utils.PortAllocator.GetAvailablePort	(	IDatabaseContext	databaseContext,
		ushort	basePort,
		bool	checkOne,
		CancellationToken	cancellationToken
	)

private

Gets a port not currently in use by TGS.

Parameters

databaseContext	The IDatabaseContext to use.
basePort	The port to check first. Will not allocate a port lower than this.
checkOne	If only basePort should be checked and no others.
cancellationToken	The CancellationToken for the operation.

Returns: A ValueTask<TResult> resulting in the first available port on success, null on failure.

Definition at line 97 of file PortAllocator.cs.

        {
            logger.LogTrace("Port allocation >= {basePort} requested...", basePort);
            var ddPorts = await databaseContext
                .DreamDaemonSettings
                .Where(x => x.Instance!.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier)
                .Select(x => new
                {
                    Port = x.Port!.Value,
                    x.InstanceId,
                })
                .ToListAsync(cancellationToken);
 
            var dmPorts = await databaseContext
                .DreamMakerSettings
                .Where(x => x.Instance!.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier)
                .Select(x => new
                {
                    ApiValidationPort = x.ApiValidationPort!.Value,
                    x.InstanceId,
                })
                .ToListAsync(cancellationToken);
 
            var exceptions = new List<Exception>();
            ushort port = 0;
            try
            {
                for (port = basePort; port < ushort.MaxValue; ++port)
                {
                    if (checkOne && port != basePort)
                        break;
 
                    if (port == serverPortProvider.HttpApiPort)
                    {
                        logger.LogWarning("Cannot allocate port {port} as it is the TGS API port!", port);
                        continue;
                    }
 
                    var reservedGamePortData = ddPorts.Where(data => data.Port == port).ToList();
                    if (reservedGamePortData.Count > 0)
                    {
                        logger.LogWarning(
                            "Cannot allocate port {port} as it in use by the game server of instance(s): {instanceId}!",
                            port,
                            String.Join(
                                ", ",
                                reservedGamePortData.Select(data => data.InstanceId)));
                        continue;
                    }
 
                    var reservedApiValidationPortData = dmPorts.Where(data => data.ApiValidationPort == port).ToList();
                    if (reservedApiValidationPortData.Count > 0)
                    {
                        logger.LogWarning(
                            "Cannot allocate port {port} as it in use by the API validation server of instance(s): {instanceId}!",
                            port,
                            String.Join(
                                ", ",
                                reservedApiValidationPortData.Select(data => data.InstanceId)));
                        continue;
                    }
 
                    try
                    {
                        SocketExtensions.BindTest(platformIdentifier, port, false, true);
                        SocketExtensions.BindTest(platformIdentifier, port, false, false);
                    }
                    catch (Exception ex)
                    {
                        exceptions.Add(ex);
                        continue;
                    }
 
                    logger.LogInformation("Allocated port {port}", port);
                    return port;
                }
 
                logger.LogWarning("Unable to allocate port >= {basePort}!", basePort);
                return null;
            }
            finally
            {
                if (port != basePort)
                {
                    logger.LogDebug(
                        exceptions.Count == 1
                            ? exceptions.First()
                            : new AggregateException(exceptions),
                        "Failed to allocate ports {basePort}-{lastCheckedPort}!",
                        basePort,
                        port - 1);
                }
            }
        }

Here is the call graph for this function:

◆ GetAvailablePort() [2/2]

async ValueTask< ushort?> Tgstation.Server.Host.Utils.PortAllocator.GetAvailablePort	(	ushort	basePort,
		bool	checkOne,
		CancellationToken	cancellationToken
	)

Gets a port not currently in use by TGS.

Parameters

basePort	The port to check first. Will not allocate a port lower than this.
checkOne	If only basePort should be checked and no others.
cancellationToken	The CancellationToken for the operation.

Returns: A ValueTask<TResult> resulting in the first available port on success, null on failure.

Implements Tgstation.Server.Host.Utils.IPortAllocator.

Definition at line 80 of file PortAllocator.cs.

        {
            ushort? result = null;
            using (await SemaphoreSlimContext.Lock(allocatorLock, cancellationToken))
                await databaseContextFactory.UseContext(
                    async databaseContext => result = await GetAvailablePort(databaseContext, basePort, checkOne, cancellationToken));
            return result;
        }