Relay

ChaseNet2.FileTransfer/FileClient.cs

@@ -15,18 +15,18 @@ public class FileClient : ConnectionHandler
     NetworkMessage? SentRequest;
     private DateTime LastReceivedPart;
 
-    public override Task OnAttached(ConnectionManager manager)
+    public override Task OnHandlerAttached(ConnectionManager manager)
     {
         return Task.CompletedTask;
     }
 
-    public override Task OnManagerConnect(Connection connection)
+    public override Task OnConnectionAttached(Connection connection)
     {
         AddConnection(connection.ConnectionId);
         return Task.CompletedTask;
     }
 
-    public override void ConnectionUpdate(Connection connection)
+    public override void OnConnectionUpdated(Connection connection)
     {
         while (connection.IncomingMessages.TryDequeue(out var message))
         {
@@ -111,7 +111,7 @@ public void StartTransfer(FileSpec fileSpec, string destinationPath)
         }
     }
 
-    public override void Update()
+    public override void OnManagerUpdated()
     {
         if (CurrentTransfer == null) return;
 

ChaseNet2.FileTransfer/FileHost.cs

@@ -17,26 +17,26 @@ public FileHost(string filePath)
         LastBroadcastTime = DateTime.UtcNow;
     }
 
-    public override async Task OnAttached(ConnectionManager manager)
+    public override async Task OnHandlerAttached(ConnectionManager manager)
     {
         Log.Information("Starting file host");
         Spec = await FileSpec.Create(FilePath);
         Stream = new FileStream(FilePath, FileMode.Open);
     }
 
-    public override Task OnManagerConnect(Connection connection)
+    public override Task OnConnectionAttached(Connection connection)
     {
         connection.RegisterMessageHandler(997, this);
         Connections.Add(connection);
 
         return Task.CompletedTask;
     }
 
-    public override void ConnectionUpdate(Connection connection)
+    public override void OnConnectionUpdated(Connection connection)
     {
     }
 
-    public override void Update()
+    public override void OnManagerUpdated()
     {
         if (Spec is null)
         {

ChaseNet2.SimpleTracker/Program.cs

@@ -1,30 +1,56 @@
-using ChaseNet2.Session;
+using System.Text.Json;
+using ChaseNet2.Relay;
+using ChaseNet2.Session;
+using ChaseNet2.SimpleTracker;
 using ChaseNet2.Transport;
 using Serilog;
 using Serilog.Core;
 
-Logger logger = new LoggerConfiguration()
-    .MinimumLevel.Debug()
-    .WriteTo.Console()
-    .CreateLogger();
+var settings = new TrackerSettings();
+if (File.Exists("tracker.json"))
+{
+    settings = JsonSerializer.Deserialize<TrackerSettings>(File.ReadAllText("tracker.json")) ?? new TrackerSettings();
+}
 
-Log.Logger = logger;
+if (settings.DebugLogging)
+{
+    var logger = new LoggerConfiguration()
+        .MinimumLevel.Debug()
+        .WriteTo.Console()
+        .CreateLogger();
+    Log.Logger = logger;
+}
+else
+{
+    var logger = new LoggerConfiguration()
+        .MinimumLevel.Warning()
+        .WriteTo.Console()
+        .CreateLogger();
+    Log.Logger = logger;
+}
 
-ConnectionManager cm = new ConnectionManager(2137);
-SessionTracker st = new SessionTracker();
-cm.AttachHandler(st);
+var cm = new ConnectionManager(settings.Port);
+cm.Settings.TargetUpdateRate = settings.UpdateRate;
+cm.StartBackgroundThread();
 
+var st = new SessionTracker();
 st.SessionName = "TrackerSession";
+cm.AttachHandler(st);
+
+if (settings.EnableRelay)
+{
+    var relayHost = new RelayHost();
+    cm.AttachHandler(relayHost);
+}
 
 int counter = 0;
 while (true)
 {
-    if (counter % 30 == 0)
+    if (counter % 10 == 0)
     {
         Console.WriteLine($"Host statistics: {cm.Statistics}");
     }
 
-    await Task.Delay(100);
-    await cm.Update();
+    await Task.Delay(1000);
     counter++;
 }

ChaseNet2.SimpleTracker/TrackerSettings.cs

@@ -0,0 +1,9 @@
+namespace ChaseNet2.SimpleTracker;
+
+public class TrackerSettings
+{
+    public bool EnableRelay = true;
+    public bool DebugLogging = false;
+    public ushort Port = 2137;
+    public uint UpdateRate = 20;
+}

ChaseNet2.Tests/ConnectionManagerTests.cs

@@ -47,7 +47,7 @@ public async Task ConnectionManagerShouldConnect()
         var (first, second, connection) = await GetConnectedManagers();
 
         // Assert
-        Assert.True(connection.State == ConnectionState.Connected);
+        Assert.True(connection.Status == ConnectionStatus.Connected);
     }
 
     [Theory]

ChaseNet2.Tests/FileTransfer.cs

@@ -87,8 +87,8 @@ public async Task ShouldConnect()
         Assert.True(hostCM.Connections.Count == 2);
         Assert.True(clientCM.Connections.Count == 2);
 
-        Assert.True(hostCM.Connections.TrueForAll(x=>x.State==ConnectionState.Connected));
-        Assert.True(clientCM.Connections.TrueForAll(x=>x.State==ConnectionState.Connected));
+        Assert.True(hostCM.Connections.TrueForAll(x=>x.Status==ConnectionStatus.Connected));
+        Assert.True(clientCM.Connections.TrueForAll(x=>x.Status==ConnectionStatus.Connected));
     }
 
     [Fact]

ChaseNet2/Contract/NetworkContract.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ChaseNet2.Transport;
+
+namespace ChaseNet2.Contract
+{
+    public class NetworkContract<SenderStateT, ReceiverStateT>
+    {
+        private List<(SenderStateT from, Type triggerType, Action<object> onTrigger)> SenderTransitions =
+            new List<(SenderStateT from, Type triggerType, Action<object> onTrigger)>();
+
+        private List<(ReceiverStateT from, Type triggerType, Action<object> onTrigger)> ReceiverTransitions =
+            new List<(ReceiverStateT from, Type triggerType, Action<object> onTrigger)>();
+
+        public SenderStateT SenderState;
+        public ReceiverStateT ReceiverState;
+
+        public bool IsSender;
+
+        public bool Equals = true;
+
+        public ulong Channel { get; private set; }
+        public Connection Connection { get; private set; }
+
+        public void AddSenderTransition(SenderStateT from, Type triggerType, Action<object> onReceived)
+        {
+            SenderTransitions.Add((from,triggerType,onReceived));
+        }
+        public void AddReceiverTransition(ReceiverStateT from, Type triggerType, Action<object> onReceived)
+        {
+            ReceiverTransitions.Add((from,triggerType,onReceived));
+        }
+
+        private bool StatesEqual(SenderStateT a, SenderStateT b)
+        {
+            if (Equals)
+            {
+                return a.Equals(b);
+            }
+
+            return a.GetType() == b.GetType();
+        }
+
+        private bool StatesEqual(ReceiverStateT a, ReceiverStateT b)
+        {
+            if (Equals)
+            {
+                return a.Equals(b);
+            }
+
+            return a.GetType() == b.GetType();
+        }
+
+        public void Fire(NetworkMessage message)
+        {
+            if (IsSender)
+            {
+                FireSender(message);
+            }
+            else
+            {
+                FireReceiver(message);
+            }
+        }
+
+        void FireSender(NetworkMessage msg)
+        {
+            var availableTransitions = SenderTransitions.Where(x => StatesEqual(x.from,SenderState));
+
+            var transition = availableTransitions.First(x => x.triggerType == msg.ContentType); // will throw if the desired transition doensn't exist
+
+            transition.onTrigger.Invoke(msg.Content);
+        }
+
+        void FireReceiver(NetworkMessage msg)
+        {
+            var availableTransitions = ReceiverTransitions.Where(x => StatesEqual(x.from,ReceiverState));
+
+            var transition = availableTransitions.First(x => x.triggerType == msg.ContentType); // will throw if the desired transition doensn't exist
+
+            transition.onTrigger.Invoke(msg.Content);
+        }
+    }
+}

ChaseNet2/InternalChannelType.cs

@@ -7,5 +7,7 @@ public enum InternalChannelType : ulong
 
         SessionJoin = 201,
         TrackerInternal = 202,
+
+        Relay = 301,
     }
 }

ChaseNet2/Relay/Contracts/RelaySetupContract.cs

@@ -0,0 +1,44 @@
+using ChaseNet2.Contract;
+using ChaseNet2.Relay;
+
+namespace ChaseNet2.Relay
+{
+    public class RelaySetupContract : NetworkContract<RelaySetupContract.SenderState,RelaySetupContract.ReceiverState>
+    {
+        public enum SenderState
+        {
+            Start,
+            RequestSent,
+            Success,
+            Failure
+        }
+        public enum ReceiverState
+        {
+            Start,
+            ResponseSent
+        }
+
+        public RelaySetupContract()
+        {
+            AddReceiverTransition(
+                ReceiverState.Start,
+                typeof(RelayRequest),
+                (content) => { base.ReceiverState = ReceiverState.ResponseSent; });
+
+            AddSenderTransition(
+                SenderState.RequestSent,
+                typeof(RelayRequestResponse),
+                o =>
+                {
+                    if (o is RelayRequestResponse { Accepted: true })
+                    {
+                        base.SenderState = SenderState.Success;
+                    }
+                    else
+                    {
+                        base.SenderState = SenderState.Failure;
+                    }
+                });
+        }
+    }
+}

ChaseNet2/Relay/Messages/RelayAdvertisement.cs

@@ -0,0 +1,10 @@
+using ProtoBuf;
+
+namespace ChaseNet2.Relay
+{
+    [ProtoContract]
+    public class RelayAdvertisement
+    {
+        public ushort PreferredMTU;
+    }
+}

ChaseNet2/Relay/Messages/RelayRequest.cs

@@ -0,0 +1,14 @@
+using System.Net;
+using ProtoBuf;
+
+namespace ChaseNet2.Relay
+{
+    [ProtoContract]
+    public class RelayRequest
+    {
+        [ProtoMember(1)]
+        public IPEndPoint TargetEndPoint;
+        [ProtoMember(2)]
+        public ulong TargetConnectionID;
+    }
+}

ChaseNet2/Relay/Messages/RelayRequestResponse.cs

@@ -0,0 +1,11 @@
+using ProtoBuf;
+
+namespace ChaseNet2.Relay
+{
+    [ProtoContract]
+    public class RelayRequestResponse
+    {
+        [ProtoMember(1)]
+        public bool Accepted;
+    }
+}