feature: all in one (single) (#202)

* CHG use keyed options to allow multiple definitions in one app

* CHG make packet provider and related services keyed so they can be registered multiple times and injected by key

* ADD Single executable to host both auth and game in one executable

* feat(single): implement single exe

* refactor(build): renamed Game + Auth to Game.Server + Auth.Server

Executables are now just a tiny wrapper around the library to make QuantumCore.Single not depend on executables (causes many issues with build output)

* feat(ci): single exe

* feat(single): Add commandline parser to allow --version and --help

* chore: Set author to MeikelLP to make auto generated copyright more useful

* refactor(single): Moved Game.Server + Auth.Server to Libraries/ dir

* fix: launchSettings.json

* fix: project references

* feat: Use IFileProvider

Additionally removed the proto loaders and merged them with their respective manager

* refactor(game): Use IFileProvider

* refactor(game): Remove additional config files from data dir

* fix: tests

* refactor(game): Use IFileProvider

* refactor(game): Use IFileProvider

* refactor(game): Use ILoadable

* fix(game): Duplicate service registration

* fix: tests

* fix: startup crash if no data/ dir existed

* docs: renamed API to configuration

* docs: Improve configuration docs

* chore(docs): Add recommended truncate for blog posts

* fix(tests)

Bumped FluentAssertions to 7.0.0-alpha.5 for fluentassertions/fluentassertions#2565

* fix: InMemory cache wrong expiry

* fix(game): service registration

* fix: default IP is loopback

* fix(auth): startup

* fix(tests)

* fix(game): remove unnecessary file IO

* refactor: use constants for "auth" and "game" named options

* chore: cleanup csproj

* fix(single): bump GitVersion.MsBuild to latest to possibly fix CI issue

* fix(ci): unshallow fetch

* fix(ci): unshallow fetch

* fix(single): app launch

* fix(ci): self-contained publish for single

* chore(ci): rename publish artifacts job

* fix(game): ping handler casting wrongly

* chore(docs): clarify the client directory

* fix(ci): run single builds only on master/tag

Author: MeikelLP

.github/workflows/dotnet-pipeline.yml

@@ -18,6 +18,8 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: '0'
 
       # setup .NET
       - name: Setup .NET Core SDK 8
@@ -30,6 +32,30 @@ jobs:
 
       - name: Test
         run: dotnet test --no-build src/QuantumCore.sln
+  publish_single:
+    needs:
+      - test
+    runs-on: ubuntu-latest
+    # only deploy if on master or tag
+    if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/master'
+    strategy:
+      matrix:
+        os: [ win-x64, osx-x64, linux-x64, linux-musl-x64 ]
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: '0'
+      - name: Setup .NET Core SDK 8
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.x
+      - name: Build
+        run: dotnet publish -r ${{ matrix.os }} --verbosity minimal -p DebugType=None -p DebugSymbols=false -p PublishSingleFile=true --self-contained  src/Executables/Single/
+      - name: Archive build artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: QuantumCore Single ${{ matrix.os }}
+          path: src/Executables/Single/bin/Release/net8.0/${{ matrix.os }}/publish
   deploy:
     needs:
       - test

docs/docs/Getting Started/developer.md

@@ -18,7 +18,7 @@ git clone https://github.com/MeikelLP/quantum-core-x.git
 
 ### 2. Generate a `mob_proto` and `item_proto`
 
-In the client directory there should be a folder called `Eternexus` with an folder `--dump_proto--`. Just execute the `dump_proto.exe`. It should generate you 2 files:
+In the (TMP4) client directory there should be a folder called `Eternexus` with an folder `--dump_proto--`. Just execute the `dump_proto.exe`. It should generate you 2 files:
 
 * `item_proto`
 * `mob_proto`

src/Core.Networking/PacketReader.cs

@@ -2,6 +2,7 @@
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
@@ -14,11 +15,11 @@ public class PacketReader : IPacketReader
     private readonly IHostEnvironment _env;
     private readonly int _bufferSize;
 
-    public PacketReader(ILogger<PacketReader> logger, IPacketManager packetManager, IConfiguration configuration,
-        IHostEnvironment env)
+    public PacketReader([ServiceKey] string serviceKey, ILogger<PacketReader> logger, IConfiguration configuration,
+        IServiceProvider serviceProvider, IHostEnvironment env)
     {
         _logger = logger;
-        _packetManager = packetManager;
+        _packetManager = serviceProvider.GetRequiredKeyedService<IPacketManager>(serviceKey);
         _env = env;
         _bufferSize = configuration.GetValue<int?>("BufferSize") ?? 4096;
         _logger.LogDebug("Using buffer size {BufferSize}", _bufferSize);
@@ -42,7 +43,7 @@ public async IAsyncEnumerable<object> EnumerateAsync(Stream stream,
             }
             catch (IOException)
             {
-                _logger.LogDebug("Connection was most likely closed while reading a packet. This may be fine");
+                _logger.LogDebug("Connection was closed while reading a packet header. This may be fine");
                 break;
             }
 
@@ -66,7 +67,7 @@ public async IAsyncEnumerable<object> EnumerateAsync(Stream stream,
             }
             catch (IOException)
             {
-                _logger.LogDebug("Connection was most likely closed while reading a packet. This may be fine");
+                _logger.LogDebug("Connection was closed while reading a packet sub header. This may be fine");
                 break;
             }
 
@@ -111,7 +112,7 @@ public async IAsyncEnumerable<object> EnumerateAsync(Stream stream,
             }
             catch (IOException)
             {
-                _logger.LogDebug("Connection was most likely closed while reading a packet. This may be fine");
+                _logger.LogDebug("Connection was closed while reading a packet body. This may be fine");
                 break;
             }
 
@@ -132,7 +133,7 @@ public async IAsyncEnumerable<object> EnumerateAsync(Stream stream,
             }
             catch (IOException)
             {
-                _logger.LogDebug("Connection was most likely closed while reading a packet. This may be fine");
+                _logger.LogDebug("Connection was closed while reading a packet sequence. This may be fine");
                 break;
             }
         }
@@ -159,4 +160,4 @@ private async Task<byte[]> GetAsMuchDataAsPossibleAsync(Stream stream)
         Array.Resize(ref bytes, totalRead);
         return bytes;
     }
-}
+}

src/Core/Core/Networking/ServerBase.cs

@@ -8,7 +8,6 @@
 using Microsoft.Extensions.Options;
 using QuantumCore.API;
 using QuantumCore.API.PluginTypes;
-using QuantumCore.Core.Utils;
 using QuantumCore.Networking;
 
 namespace QuantumCore.Core.Networking
@@ -27,28 +26,30 @@ public abstract class ServerBase<T> : BackgroundService, IServerBase
         private readonly PluginExecutor _pluginExecutor;
         private readonly IServiceProvider _serviceProvider;
         private readonly string _serverMode;
+        protected IServiceScope Scope { get; }
 
-        public int Port { get; }
+        public ushort Port { get; }
+        public IPAddress IpAddress { get; }
 
         public ServerBase(IPacketManager packetManager, ILogger logger, PluginExecutor pluginExecutor,
-            IServiceProvider serviceProvider, string mode,
-            IOptions<HostingOptions> hostingOptions)
+            IServiceProvider serviceProvider, string mode)
         {
             _logger = logger;
             _pluginExecutor = pluginExecutor;
             _serviceProvider = serviceProvider;
             _serverMode = mode;
             PacketManager = packetManager;
-            Port = hostingOptions.Value.Port;
+            Scope = serviceProvider.CreateScope();
+            var hostingOptions = Scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<HostingOptions>>().Get(mode);
+            Port = hostingOptions.Port;
 
             // Start server timer
             _serverTimer.Start();
-
-            var localAddr = IPAddress.Parse(hostingOptions.Value.IpAddress ?? "0.0.0.0");
-            IpUtils.PublicIP = localAddr;
-            Listener = new TcpListener(localAddr, Port);
-
-            _logger.LogInformation("Initialize tcp server listening on {IP}:{Port}", localAddr, Port);
+            var desiredIpAddress = IPAddress.TryParse(hostingOptions.IpAddress, out var ipAddress)
+                ? ipAddress
+                : IPAddress.Loopback;
+            IpAddress = desiredIpAddress;
+            Listener = new TcpListener(IpAddress, Port);
         }
 
         public long ServerTime => _serverTimer.ElapsedMilliseconds;
@@ -64,11 +65,13 @@ await _pluginExecutor.ExecutePlugins<IConnectionLifetimeListener>(_logger,
         public override Task StartAsync(CancellationToken token)
         {
             base.StartAsync(token);
-            _logger.LogInformation("Start listening for connections...");
 
             Listener.Start();
             Listener.BeginAcceptTcpClient(OnClientAccepted, Listener);
 
+            _logger.LogInformation("Start listening for connections on {IP}:{Port} ({Mode})", IpAddress, Port,
+                _serverMode);
+
             return Task.CompletedTask;
         }
 
@@ -116,11 +119,11 @@ public async Task CallListener(IConnection connection, IPacketSerializable packe
             }
 
             object context;
-            if (_serverMode == "game")
+            if (_serverMode == HostingOptions.ModeGame)
             {
                 context = GetGameContextPacket(connection, packet, details.PacketType);
             }
-            else if (_serverMode == "auth")
+            else if (_serverMode == HostingOptions.ModeAuth)
             {
                 context = GetAuthContextPacket(connection, packet, details.PacketType);
             }
@@ -188,6 +191,7 @@ public async override Task StopAsync(CancellationToken cancellationToken)
             await _stoppingToken.CancelAsync();
             await base.StopAsync(cancellationToken);
             _stoppingToken.Dispose();
+            Scope.Dispose();
         }
     }
-}
+}

src/Core/Core/Utils/IpUtils.cs

@@ -16,19 +16,51 @@ public static class ServiceExtensions
     private const string MessageTemplate = "[{Timestamp:HH:mm:ss.fff}][{Level:u3}]{Message:lj} " +
                                            "{NewLine:1}{Exception:1}";
 
+    /// <summary>
+    /// Used to register a packet provider per application type.
+    /// The application types might have duplicate packet definitions (by header) but they still might be handled
+    /// differently. Thus multiple packet providers may be registered if necessary with each registered as a keyed
+    /// service.
+    /// </summary>
+    /// <param name="services"></param>
+    /// <param name="mode"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static IServiceCollection AddPacketProvider<T>(this IServiceCollection services, string mode)
+        where T : class, IPacketLocationProvider
+    {
+        services.AddKeyedSingleton<IPacketLocationProvider, T>(mode);
+        services.AddKeyedSingleton<IPacketReader, PacketReader>(mode);
+        services.AddKeyedSingleton<IPacketManager>(mode, (provider, key) =>
+        {
+            var packetLocationProvider = provider.GetRequiredKeyedService<IPacketLocationProvider>(key);
+            var assemblies = packetLocationProvider.GetPacketAssemblies();
+            var packetTypes = assemblies.SelectMany(x => x.ExportedTypes)
+                .Where(x => x.IsAssignableTo(typeof(IPacketSerializable)) &&
+                            x.GetCustomAttribute<PacketAttribute>()?.Direction.HasFlag(EDirection.Incoming) == true)
+                .OrderBy(x => x.FullName)
+                .ToArray();
+            var handlerTypes = assemblies.SelectMany(x => x.ExportedTypes)
+                .Where(x =>
+                    x.IsAssignableTo(typeof(IPacketHandler)) &&
+                    x is {IsClass: true, IsAbstract: false, IsInterface: false})
+                .OrderBy(x => x.FullName)
+                .ToArray();
+            return ActivatorUtilities.CreateInstance<PacketManager>(provider,
+                new object[] {(IEnumerable<Type>) packetTypes, handlerTypes});
+        });
+        return services;
+    }
+
     /// <summary>
     /// Services required by Auth & Game
     /// </summary>
     /// <param name="services"></param>
     /// <param name="pluginCatalog"></param>
-    /// <param name="configuration"></param>
     /// <returns></returns>
     public static IServiceCollection AddCoreServices(this IServiceCollection services, IPluginCatalog pluginCatalog,
         IConfiguration configuration)
     {
-        services.AddOptions<HostingOptions>()
-            .BindConfiguration("Hosting")
-            .ValidateDataAnnotations();
         services.AddCustomLogging(configuration);
         services.AddSingleton<IPacketManager>(provider =>
         {
@@ -50,7 +82,6 @@ public static IServiceCollection AddCoreServices(this IServiceCollection service
                 .ToArray();
             return ActivatorUtilities.CreateInstance<PacketManager>(provider, [packetTypes, handlerTypes]);
         });
-        services.AddSingleton<IPacketReader, PacketReader>();
         services.AddSingleton<PluginExecutor>();
         services.AddPluginFramework()
             .AddPluginCatalog(pluginCatalog)
@@ -112,4 +143,4 @@ private static IServiceCollection AddCustomLogging(this IServiceCollection servi
         });
         return services;
     }
-}
+}

src/Core/Extensions/ServiceExtensions.cs

@@ -4,7 +4,8 @@ namespace QuantumCore;
 
 public class HostingOptions
 {
-    [Required]
-    public int Port { get; set; }
+    public const string ModeAuth = "auth";
+    public const string ModeGame = "game";
+    [Required] public ushort Port { get; set; }
     public string? IpAddress { get; set; }
-}
+}

src/Core/HostingOptions.cs

@@ -0,0 +1,12 @@
+using System.Reflection;
+
+namespace QuantumCore;
+
+/// <summary>
+/// This will be registered as a keyed service.
+/// Used to define where to load packet types and handlers from
+/// </summary>
+public interface IPacketLocationProvider
+{
+    IReadOnlyCollection<Assembly> GetPacketAssemblies();
+}

src/Core/IPacketLocationProvider.cs

@@ -2,9 +2,9 @@
 
 namespace QuantumCore.API.Game.World
 {
-    public interface IWorld
+    public interface IWorld : ILoadable
     {
-        Task Load();
+        Task InitAsync();
         void Update(double elapsedTime);
 #nullable enable
         IMap? GetMapAt(uint x, uint y);