/// <summary>
/// Initializes a new instance of the <see cref="ManagementProtocol"/> class.
/// </summary>
/// <param name="logger">A reference to the logger to use.</param>
/// <param name="handlerSelector">A reference to the handler selector to use in this protocol.</param>
public ManagementProtocol(ILogger logger, IHandlerSelector handlerSelector)
: base(handlerSelector)
{
logger.ThrowIfNull(nameof(logger));
this.Logger = logger.ForContext <GameProtocol>();
}
public void AddHandlerSelector(IHandlerSelector selector)
{
lock (_selectorLock)
{
_handlerSelectors.Add(selector);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TcpServer"/> class.
/// </summary>
/// <param name="options">The options to intialize the instance with.</param>
/// <param name="loggerFactory">A reference to the factory of loggers to use.</param>
/// <param name="handlerSelector">A refrence to the selector of handlers for TCP messages.</param>
/// <param name="clientsManager">A reference to a manager for clients.</param>
/// <param name="listeners">A reference to the listeners to bind to the server.</param>
/// <param name="gameworldAdapter">A reference to an adapter that will act as a client to the game world.</param>
public TcpServer(
IOptions <TcpServerOptions> options,
ILoggerFactory loggerFactory,
IHandlerSelector handlerSelector,
IClientsManager clientsManager,
IEnumerable <IListener> listeners,
ITcpServerToGameworldAdapter gameworldAdapter)
{
options.ThrowIfNull(nameof(options));
loggerFactory.ThrowIfNull(nameof(loggerFactory));
handlerSelector.ThrowIfNull(nameof(handlerSelector));
listeners.ThrowIfNull(nameof(listeners));
gameworldAdapter.ThrowIfNull(nameof(gameworldAdapter));
if (!listeners.Any())
{
throw new ArgumentException("No listeners found after composition.", nameof(listeners));
}
DataAnnotationsValidator.ValidateObjectRecursive(options.Value);
this.id = Guid.NewGuid().ToString();
this.logger = loggerFactory.CreateLogger <TcpServer>();
this.gameworldClientAdapter = gameworldAdapter;
this.connectionToClientMap = new Dictionary <IConnection, IClient>();
this.clientsManager = clientsManager;
this.Options = options.Value;
this.BindListeners(loggerFactory, handlerSelector, listeners);
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseProtocol"/> class.
/// </summary>
/// <param name="handlerSelector">A reference to the handler selector to use.</param>
/// <param name="keepConnectionOpen">Optional. A value indicating whether to maintain the connection open after processing a message in the connection.</param>
protected BaseProtocol(IHandlerSelector handlerSelector, bool keepConnectionOpen = true)
{
handlerSelector.ThrowIfNull(nameof(handlerSelector));
this.HandlerSelector = handlerSelector;
this.keepConnectionOpen = keepConnectionOpen;
}
public void AddHandlerSelector(IHandlerSelector selector)
{
if (selectors == null)
{
selectors = new List <IHandlerSelector>();
}
selectors.Add(selector);
}
public void AddHandlerSelector(IHandlerSelector selector)
{
if (selectors == null)
{
selectors = new List<IHandlerSelector>();
}
selectors.Add(selector);
}
/// <summary>
/// Initializes a new instance of the <see cref="GameProtocol"/> class.
/// </summary>
/// <param name="logger">A reference to the logger to use.</param>
/// <param name="handlerSelector">A reference to the handler selector to use in this protocol.</param>
/// <param name="protocolConfigOptions">A reference to the protocol configuration options.</param>
public GameProtocol(
ILogger logger,
IHandlerSelector handlerSelector,
ProtocolConfigurationOptions protocolConfigOptions)
: base(handlerSelector)
{
logger.ThrowIfNull(nameof(logger));
protocolConfigOptions.ThrowIfNull(nameof(protocolConfigOptions));
this.Logger = logger.ForContext <GameProtocol>();
this.ProtocolConfiguration = protocolConfigOptions;
}
/// <summary>
/// Binds the TCP listener events with handler picking.
/// </summary>
/// <param name="loggerFactory">The loggers factory to create loggers with.</param>
/// <param name="handlerSelector">The selector of handlers to bind listeners' events to.</param>
/// <param name="listeners">The listeners to bind.</param>
private void BindListeners(ILoggerFactory loggerFactory, IHandlerSelector handlerSelector, IEnumerable <IListener> listeners)
{
IEnumerable <IOutboundPacket> OnPacketReady(IConnection connection, IInboundPacket packet)
{
var handler = handlerSelector.SelectForPacket(packet);
if (handler != null && this.connectionToClientMap.TryGetValue(connection, out IClient client))
{
return(handler.HandleRequestPacket(this, packet, client));
}
return(null);
}
void OnConnectionClosed(IConnection connection)
{
// Clean up the event listeners we set up here.
connection.PacketReady -= OnPacketReady;
connection.Closed -= OnConnectionClosed;
if (!this.connectionToClientMap.ContainsKey(connection))
{
return;
}
var playerId = this.connectionToClientMap[connection].PlayerId;
this.clientsManager.Unregister(playerId);
this.connectionToClientMap.Remove(connection);
}
void OnNewConnection(IConnection connection)
{
if (this.connectionToClientMap.ContainsKey(connection))
{
return;
}
this.connectionToClientMap.Add(connection, new ConnectedClient(loggerFactory.CreateLogger <ConnectedClient>(), connection));
connection.PacketReady += OnPacketReady;
connection.Closed += OnConnectionClosed;
}
foreach (var tcpListener in listeners)
{
tcpListener.NewConnection += OnNewConnection;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LoginProtocol"/> class.
/// </summary>
/// <param name="logger">A reference to the logger to use.</param>
/// <param name="handlerSelector">A reference to the handler selector to use in this protocol.</param>
/// <param name="protocolConfigOptions">A reference to the protocol configuration options.</param>
/// <param name="gameConfigOptions">A reference to the game configuration options.</param>
public LoginProtocol(
ILogger logger,
IHandlerSelector handlerSelector,
ProtocolConfigurationOptions protocolConfigOptions,
GameConfigurationOptions gameConfigOptions)
: base(handlerSelector, keepConnectionOpen: false)
{
logger.ThrowIfNull(nameof(logger));
protocolConfigOptions.ThrowIfNull(nameof(protocolConfigOptions));
gameConfigOptions.ThrowIfNull(nameof(gameConfigOptions));
this.Logger = logger.ForContext <LoginProtocol>();
this.ProtocolConfiguration = protocolConfigOptions;
this.GameConfiguration = gameConfigOptions;
}
/// <summary>
/// The main entry point for the program.
/// </summary>
/// <param name="args">The arguments for this program.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public static async Task Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("logsettings.json")
.Build();
var host = new HostBuilder()
.ConfigureHostConfiguration(configHost =>
{
configHost.SetBasePath(Directory.GetCurrentDirectory());
configHost.AddJsonFile("hostsettings.json", optional: true, reloadOnChange: true);
configHost.AddEnvironmentVariables(prefix: "OTS_");
configHost.AddCommandLine(args);
})
.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.SetBasePath(Directory.GetCurrentDirectory());
configApp.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);
configApp.AddEnvironmentVariables(prefix: "OTS_");
configApp.AddCommandLine(args);
})
.ConfigureServices(ConfigureServices)
.UseSerilog((context, services, loggerConfig) =>
{
var telemetryConfigOptions = services.GetRequiredService <IOptions <TelemetryConfiguration> >();
loggerConfig.ReadFrom.Configuration(configuration)
.WriteTo.ApplicationInsights(telemetryConfigOptions.Value, TelemetryConverter.Traces, Serilog.Events.LogEventLevel.Information)
.Enrich.FromLogContext();
})
.Build();
// Bind the TCP listener events with handler picking.
// This is needed for now because we don't have a separate listening pipeline for generic (non TCP client requests).
handlerSelector = host.Services.GetRequiredService <IHandlerSelector>();
clientMap = new Dictionary <IConnection, IClient>();
public void AddHandlerSelector(IHandlerSelector selector)
{
NamingSubSystem.AddHandlerSelector(selector);
}
public void AddHandlerSelector(IHandlerSelector selector)
{
throw new NotImplementedException();
}
public void AddHandlerSelector(IHandlerSelector selector)
{
selectors.Add(selector);
}
