Improve networking entity ip handling

Author: FabianTerhorst

api/AltV.Net.Networking.Example/NonePlayerAuthenticationProviderFactory.cs

@@ -6,7 +6,7 @@ namespace AltV.Net.Networking.Example
 {
     public class NonePlayerAuthenticationProviderFactory : IAuthenticationProviderFactory
     {
-        public IAuthenticationProvider Create(int port, WebSocket webSocket)
+        public IAuthenticationProvider Create(string ip, int port, WebSocket webSocket)
         {
             return new NonePlayerAuthenticationProvider(webSocket);
         }

api/AltV.Net.Networking.Example/Program.cs

@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using System.Threading;
 using AltV.Net.NetworkingEntity;
-using AltV.Net.NetworkingEntity.Elements.Factories;
-using AltV.Net.NetworkingEntity.Elements.Providers;
 using Entity;
 
 namespace AltV.Net.Networking.Example
@@ -13,9 +11,12 @@ internal static class Program
         private static void Main(string[] args)
         {
             //AltNetworking.Init() is enough for most projects
-            AltNetworking.Init(new NetworkingModule(46429, new IdProvider(), new NetworkingEntityFactory(),
-                new ClientTokenProvider(), new NetworkingClientFactory(),
-                new NonePlayerAuthenticationProviderFactory(), new ClientEntityStreamingHandlerFactory()));
+            AltNetworking.Init(new NetworkingModuleBuilder()
+                .SetPort(46429)
+                .SetAuthenticationProviderFactory(new NonePlayerAuthenticationProviderFactory())
+                .Build()
+            );
+
             var data = new Dictionary<string, object>();
             var data2 = new Dictionary<string, object>();
             data["bla"] = "123";

api/AltV.Net.NetworkingEntity/Client/index.html

@@ -4,10 +4,11 @@
     <script>
         window.callbacks = new Map();
         window.alt = {
-            emit: function(eventname, ...args) {
-                window.callbacks.get(eventname)( ...args);
+            emit: (eventname, ...args) => {
+                const func = window.callbacks.get(eventname);
+                func( ...args);
             },
-            on: function(eventname, callback) {
+            on: (eventname, callback) => {
                 window.callbacks.set(eventname, callback);
             }
         }

api/AltV.Net.NetworkingEntity/Elements/Factories/AuthenticationProviderFactory.cs

@@ -5,9 +5,9 @@ namespace AltV.Net.NetworkingEntity.Elements.Factories
 {
     public class AuthenticationProviderFactory : IAuthenticationProviderFactory
     {
-        public IAuthenticationProvider Create(int port, WebSocket webSocket)
+        public IAuthenticationProvider Create(string ip, int port, WebSocket webSocket)
         {
-            return new AuthenticationProvider(port, webSocket);
+            return new AuthenticationProvider(ip, port, webSocket);
         }
     }
 }

api/AltV.Net.NetworkingEntity/Elements/Factories/IAuthenticationProviderFactory.cs

@@ -5,6 +5,6 @@ namespace AltV.Net.NetworkingEntity.Elements.Factories
 {
     public interface IAuthenticationProviderFactory
     {
-        IAuthenticationProvider Create(int port, WebSocket webSocket);
+        IAuthenticationProvider Create(string ip, int port, WebSocket webSocket);
     }
 }

api/AltV.Net.NetworkingEntity/Elements/Providers/AuthenticationProvider.cs

@@ -21,7 +21,7 @@ public class AuthenticationProvider : IAuthenticationProvider
 
         private readonly Dictionary<IPlayer, string> playerTokenAccess = new Dictionary<IPlayer, string>();
 
-        public AuthenticationProvider(int port, WebSocket webSocket) : this("ws://" + GetIpAddress() + $":{port}/",
+        public AuthenticationProvider(string ip, int port, WebSocket webSocket) : this("ws://" + (ip ?? GetIpAddress()) + $":{port}/",
             webSocket)
         {
         }
@@ -76,15 +76,6 @@ await webSocket.CloseWebSocketAsync(clientWebSocket, WebSocketCloseStatus.Normal
             };
         }
 
-        private static string GetIpAddress()
-        {
-            var ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); // `Dns.Resolve()` method is deprecated.
-            if (ipHostInfo.AddressList.Length == 0) return null;
-            var ipAddress = ipHostInfo.AddressList[0];
-
-            return ipAddress.ToString();
-        }
-
         public bool Verify(ManagedWebSocket webSocket, string token, out INetworkingClient client)
         {
             if (!AltNetworking.Module.ClientPool.TryGet(token, out client)) return false;
@@ -120,5 +111,14 @@ public bool VerifyPosition(INetworkingClient client, INetworkingEntity entity, b
             // Can be extended when more trustful position checking is needed 
             return true;
         }
+        
+        private static string GetIpAddress()
+        {
+            var ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); // `Dns.Resolve()` method is deprecated.
+            if (ipHostInfo.AddressList.Length == 0) return null;
+            var ipAddress = ipHostInfo.AddressList[0];
+
+            return ipAddress.ToString();
+        }
     }
 }

api/AltV.Net.NetworkingEntity/NetworkingModule.cs

@@ -14,21 +14,23 @@ public class NetworkingModule
 
         public readonly IEntityStreamer Streamer;
 
-        public NetworkingModule(int port = 46429) : this(port, new IdProvider(), new NetworkingEntityFactory(),
+        public NetworkingModule(string ip = null, int port = 46429) : this(ip, port, new IdProvider(),
+            new NetworkingEntityFactory(),
             new ClientTokenProvider(), new NetworkingClientFactory(), new AuthenticationProviderFactory(),
             new ClientEntityStreamingHandlerFactory())
         {
         }
 
-        public NetworkingModule(int port, IIdProvider<ulong> idProvider, INetworkingEntityFactory entityFactory,
+        public NetworkingModule(string ip, int port, IIdProvider<ulong> idProvider,
+            INetworkingEntityFactory entityFactory,
             IIdProvider<string> tokenProvider, INetworkingClientFactory clientFactory,
             IAuthenticationProviderFactory authenticationProviderFactory,
             IStreamingHandlerFactory streamingHandlerFactory)
         {
             EntityPool = new NetworkingEntityPool(idProvider, entityFactory);
             ClientPool = new NetworkingClientPool(tokenProvider, clientFactory);
             Streamer = new EntityStreamer();
-            Server = new Server(port, authenticationProviderFactory, Streamer, streamingHandlerFactory);
+            Server = new Server(ip, port, authenticationProviderFactory, Streamer, streamingHandlerFactory);
         }
     }
 }

api/AltV.Net.NetworkingEntity/NetworkingModuleBuilder.cs

@@ -0,0 +1,113 @@
+using AltV.Net.NetworkingEntity.Elements.Factories;
+using AltV.Net.NetworkingEntity.Elements.Providers;
+
+namespace AltV.Net.NetworkingEntity
+{
+    public class NetworkingModuleBuilder
+    {
+        private string ip;
+
+        private int port;
+
+        private IIdProvider<ulong> idProvider;
+
+        private INetworkingEntityFactory networkingEntityFactory;
+
+        private IIdProvider<string> tokenProvider;
+
+        private INetworkingClientFactory networkingClientFactory;
+
+        private IAuthenticationProviderFactory authenticationProviderFactory;
+
+        private IStreamingHandlerFactory streamingHandlerFactory;
+
+        public NetworkingModuleBuilder()
+        {
+            this.port = 46429;
+        }
+
+        public NetworkingModuleBuilder SetIp(string value)
+        {
+            this.ip = value;
+            return this;
+        }
+
+        public NetworkingModuleBuilder SetPort(int value)
+        {
+            this.port = value;
+            return this;
+        }
+
+        public NetworkingModuleBuilder SetEntityIdProvider(IIdProvider<ulong> value)
+        {
+            this.idProvider = value;
+            return this;
+        }
+
+        public NetworkingModuleBuilder SetNetworkingEntityFactory(INetworkingEntityFactory value)
+        {
+            this.networkingEntityFactory = value;
+            return this;
+        }
+
+        public NetworkingModuleBuilder SetTokenProvider(IIdProvider<string> value)
+        {
+            this.tokenProvider = value;
+            return this;
+        }
+
+        public NetworkingModuleBuilder SetNetworkingClientFactory(INetworkingClientFactory value)
+        {
+            this.networkingClientFactory = value;
+            return this;
+        }
+
+        public NetworkingModuleBuilder SetAuthenticationProviderFactory(IAuthenticationProviderFactory value)
+        {
+            this.authenticationProviderFactory = value;
+            return this;
+        }
+
+        public NetworkingModuleBuilder SetStreamingHandlerFactory(IStreamingHandlerFactory value)
+        {
+            this.streamingHandlerFactory = value;
+            return this;
+        }
+
+        public NetworkingModule Build()
+        {
+            if (idProvider == null)
+            {
+                idProvider = new IdProvider();
+            }
+
+            if (networkingEntityFactory == null)
+            {
+                networkingEntityFactory = new NetworkingEntityFactory();
+            }
+
+            if (tokenProvider == null)
+            {
+                tokenProvider = new ClientTokenProvider();
+            }
+
+            if (networkingClientFactory == null)
+            {
+                networkingClientFactory = new NetworkingClientFactory();
+            }
+
+            if (authenticationProviderFactory == null)
+            {
+                authenticationProviderFactory = new AuthenticationProviderFactory();
+            }
+
+            if (streamingHandlerFactory == null)
+            {
+                streamingHandlerFactory = new ClientEntityStreamingHandlerFactory();
+            }
+
+            return new NetworkingModule(ip, port, idProvider, networkingEntityFactory, tokenProvider,
+                networkingClientFactory, authenticationProviderFactory, streamingHandlerFactory);
+        }
+    }
+}

api/AltV.Net.NetworkingEntity/Server.cs

@@ -13,11 +13,11 @@ public class Server
     {
         public readonly IStreamingHandler StreamingHandler;
 
-        public Server(int port, IAuthenticationProviderFactory authenticationProviderFactory, IEntityStreamer streamer,
+        public Server(string ip, int port, IAuthenticationProviderFactory authenticationProviderFactory, IEntityStreamer streamer,
             IStreamingHandlerFactory factory)
         {
             var webSocket = new WebSocket();
-            var authenticationProvider = authenticationProviderFactory.Create(port, webSocket);
+            var authenticationProvider = authenticationProviderFactory.Create(ip, port, webSocket);
             var streamingHandler = factory.Create(authenticationProvider);
             StreamingHandler = streamingHandler;
             webSocket.OnMessageReceived = streamingHandler.OnMessage;