feat: allowing users to subscribe to a networked message channel while offline [MTT-3684] [MTT-3690] (#670)

* allowing users to subscribe to a message channel while offline

* Adding tests for NetworkedMessageChannel

Author: LPLafontaineB

Assets/Scripts/ApplicationLifecycle/ApplicationController.cs

@@ -30,6 +30,7 @@ protected override void Configure(IContainerBuilder builder)
         {
             base.Configure(builder);
             builder.RegisterComponent(m_UpdateRunner);
+            builder.RegisterComponent(m_ConnectionManager.NetworkManager);
             builder.RegisterComponent(m_ConnectionManager);
 
             //the following singletons represent the local representations of the lobby that we're in and the user that we are
@@ -48,10 +49,10 @@ protected override void Configure(IContainerBuilder builder)
 
             //these message channels are essential and persist for the lifetime of the lobby and relay services
             //they are networked so that the clients can subscribe to those messages that are published by the server
-            builder.RegisterInstance(new NetworkedMessageChannel<LifeStateChangedEventMessage>()).AsImplementedInterfaces();
-            builder.RegisterInstance(new NetworkedMessageChannel<ConnectionEventMessage>()).AsImplementedInterfaces();
+            builder.RegisterComponent(new NetworkedMessageChannel<LifeStateChangedEventMessage>()).AsImplementedInterfaces();
+            builder.RegisterComponent(new NetworkedMessageChannel<ConnectionEventMessage>()).AsImplementedInterfaces();
 #if UNITY_EDITOR || DEVELOPMENT_BUILD
-            builder.RegisterInstance(new NetworkedMessageChannel<CheatUsedMessage>()).AsImplementedInterfaces();
+            builder.RegisterComponent(new NetworkedMessageChannel<CheatUsedMessage>()).AsImplementedInterfaces();
 #endif
 
             //this message channel is essential and persists for the lifetime of the lobby and relay services

Assets/Scripts/Infrastructure/PubSub/NetworkedMessageChannel.cs

@@ -2,70 +2,66 @@
 using Unity.Collections;
 using Unity.Netcode;
 using UnityEngine;
+using VContainer;
 
 namespace Unity.Multiplayer.Samples.BossRoom.Shared.Infrastructure
 {
     /// <summary>
     /// This type of message channel allows the server to publish a message that will be sent to clients as well as
-    /// being published locally. Clients and the server both can subscribe to it. However, that subscription needs to be
-    /// done after the NetworkManager has initialized. On objects whose lifetime is bigger than a networked session,
-    /// subscribing will be required each time a new session starts.
+    /// being published locally. Clients and the server both can subscribe to it.
     /// </summary>
     /// <typeparam name="T"></typeparam>
     public class NetworkedMessageChannel<T> : MessageChannel<T> where T : unmanaged, INetworkSerializeByMemcpy
     {
-        string m_Name;
+        NetworkManager m_NetworkManager;
 
-        bool m_HasRegisteredHandler;
+        string m_Name;
 
         public NetworkedMessageChannel()
         {
             m_Name = $"{typeof(T).FullName}NetworkMessageChannel";
         }
 
-        public override void Dispose()
+        [Inject]
+        void InjectDependencies(NetworkManager networkManager)
         {
-            if (!IsDisposed)
+            m_NetworkManager = networkManager;
+            m_NetworkManager.OnClientConnectedCallback += OnClientConnected;
+            if (m_NetworkManager.IsListening)
             {
-                if (NetworkManager.Singleton != null && NetworkManager.Singleton.CustomMessagingManager != null && m_HasRegisteredHandler)
-                {
-                    NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler(m_Name);
-                }
-
-                m_HasRegisteredHandler = false;
+                RegisterHandler();
             }
-            base.Dispose();
         }
 
-        public override IDisposable Subscribe(Action<T> handler)
+        public override void Dispose()
         {
-            if (NetworkManager.Singleton != null && NetworkManager.Singleton.IsListening)
+            if (!IsDisposed)
             {
-                // Only register message handler on clients
-                if (!m_HasRegisteredHandler && !NetworkManager.Singleton.IsServer)
+                if (m_NetworkManager != null && m_NetworkManager.CustomMessagingManager != null)
                 {
-                    NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler(m_Name, ReceiveMessageThroughNetwork);
-                    m_HasRegisteredHandler = true;
-                    NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnect;
+                    m_NetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler(m_Name);
                 }
-
-                return base.Subscribe(handler);
             }
+            base.Dispose();
+        }
 
-            Debug.LogError("Cannot subscribe to NetworkedMessageChannel. NetworkManager is not initialized.");
-            return null;
+        void OnClientConnected(ulong clientId)
+        {
+            RegisterHandler();
         }
 
-        void OnClientDisconnect(ulong clientId)
+        void RegisterHandler()
         {
-            m_HasRegisteredHandler = false;
-            NetworkManager.Singleton.OnClientConnectedCallback -= OnClientDisconnect;
-            NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler(m_Name);
+            // Only register message handler on clients
+            if (!m_NetworkManager.IsServer)
+            {
+                m_NetworkManager.CustomMessagingManager.RegisterNamedMessageHandler(m_Name, ReceiveMessageThroughNetwork);
+            }
         }
 
         public override void Publish(T message)
         {
-            if (NetworkManager.Singleton.IsServer)
+            if (m_NetworkManager.IsServer)
             {
                 // send message to clients, then publish locally
                 SendMessageThroughNetwork(message);
@@ -81,7 +77,7 @@ void SendMessageThroughNetwork(T message)
         {
             var writer = new FastBufferWriter(FastBufferWriter.GetWriteSize<T>(), Allocator.Temp);
             writer.WriteValueSafe(message);
-            NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(m_Name, writer);
+            m_NetworkManager.CustomMessagingManager.SendNamedMessageToAll(m_Name, writer);
         }
 
         void ReceiveMessageThroughNetwork(ulong clientID, FastBufferReader reader)

Assets/Scripts/Infrastructure/Unity.BossRoom.Infrastructure.asmdef

@@ -3,7 +3,8 @@
     "rootNamespace": "",
     "references": [
         "Unity.Netcode.Runtime",
-        "Unity.TextMeshPro"
+        "Unity.TextMeshPro",
+        "VContainer"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

Assets/Tests/Runtime/NetworkedMessageChannelTests.cs

@@ -0,0 +1,261 @@
+using System;
+using System.Collections;
+using NUnit.Framework;
+using Unity.Multiplayer.Samples.BossRoom.Shared.Infrastructure;
+using Unity.Netcode;
+using UnityEngine;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine.TestTools;
+using VContainer;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace Unity.Multiplayer.Samples.BossRoom.Tests.Runtime
+{
+    public class NetworkedMessageChannelTests : NetcodeIntegrationTest
+    {
+        struct EmptyMessage : INetworkSerializeByMemcpy { }
+
+        struct GenericMessage : INetworkSerializeByMemcpy
+        {
+            public bool value;
+        }
+
+        protected override int NumberOfClients => 2;
+
+        DisposableGroup m_Subscriptions;
+
+        IObjectResolver[] m_ClientScopes;
+        IObjectResolver m_ServerScope;
+
+        int m_NbMessagesReceived;
+
+        protected override IEnumerator OnSetup()
+        {
+            m_NbMessagesReceived = 0;
+            return base.OnSetup();
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_ClientScopes = new IObjectResolver[NumberOfClients];
+            for (int i = 0; i < NumberOfClients; i++)
+            {
+                var clientBuilder = new ContainerBuilder();
+                clientBuilder.RegisterInstance(m_ClientNetworkManagers[i]);
+                m_ClientScopes[i] = clientBuilder.Build();
+                m_ClientNetworkManagers[i].NetworkConfig.EnableSceneManagement = false;
+            }
+
+            var serverBuilder = new ContainerBuilder();
+            serverBuilder.RegisterInstance(m_ServerNetworkManager);
+            m_ServerScope = serverBuilder.Build();
+            m_ServerNetworkManager.NetworkConfig.EnableSceneManagement = false;
+
+            base.OnServerAndClientsCreated();
+        }
+
+        protected override IEnumerator OnTearDown()
+        {
+            m_Subscriptions.Dispose();
+            for (int i = 0; i < NumberOfClients; i++)
+            {
+                m_ClientScopes[i].Dispose();
+            }
+            m_ServerScope.Dispose();
+            return base.OnTearDown();
+        }
+
+        void InitializeNetworkedMessageChannels<T>(int nbClients, int nbSubscribers, T expectedValue, out NetworkedMessageChannel<T>[] emptyMessageChannelClients, out NetworkedMessageChannel<T> emptyMessageChannelServer) where T : unmanaged, INetworkSerializeByMemcpy
+        {
+            emptyMessageChannelClients = new NetworkedMessageChannel<T>[nbClients];
+            for (int i = 0; i < nbClients; i++)
+            {
+                emptyMessageChannelClients[i] = new NetworkedMessageChannel<T>();
+                m_ClientScopes[i].Inject(emptyMessageChannelClients[i]);
+            }
+
+            emptyMessageChannelServer = new NetworkedMessageChannel<T>();
+            m_ServerScope.Inject(emptyMessageChannelServer);
+
+            m_Subscriptions = new DisposableGroup();
+            for (int i = 0; i < nbClients; i++)
+            {
+                for (int j = 0; j < nbSubscribers; j++)
+                {
+                    var numClient = i;
+                    var numSub = j;
+                    m_Subscriptions.Add(emptyMessageChannelClients[i].Subscribe(message =>
+                    {
+                        Debug.Log($"Received message on client {numClient} in subscription {numSub}.");
+                        m_NbMessagesReceived++;
+                        Assert.AreEqual(expectedValue, message, "Message received with unexpected value.");
+                    }));
+                }
+            }
+
+            for (int j = 0; j < nbSubscribers; j++)
+            {
+                var numSub = j;
+                m_Subscriptions.Add(emptyMessageChannelServer.Subscribe(message =>
+                {
+                    Debug.Log($"Received message on server in subscription {numSub}.");
+                    m_NbMessagesReceived++;
+                    Assert.AreEqual(expectedValue, message, "Message received with unexpected value.");
+                }));
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator EmptyNetworkedMessageIsReceivedByAllSubscribersOnAllClientsAndServer([Values(0, 1, 2)] int nbClients, [Values(0, 1, 2)] int nbSubscribers)
+        {
+            InitializeNetworkedMessageChannels(nbClients, nbSubscribers, new EmptyMessage(), out var emptyMessageChannelClients, out var emptyMessageChannelServer);
+
+            emptyMessageChannelServer.Publish(new EmptyMessage());
+
+            // wait for the custom named message to be sent on the server and received on the clients
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual((nbClients + 1) * nbSubscribers, m_NbMessagesReceived);
+
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkedMessageContentIsProperlyReceivedOnAllClientsAndServer([Values(0, 1, 2)] int nbClients, [Values(0, 1, 2)] int nbSubscribers)
+        {
+            InitializeNetworkedMessageChannels(nbClients, nbSubscribers, new GenericMessage() { value = true }, out var genericMessageChannelClients, out var genericMessageChannelServer);
+
+            genericMessageChannelServer.Publish(new GenericMessage() { value = true });
+
+            // wait for the custom named message to be sent on the server and received on the client
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual((nbClients + 1) * nbSubscribers, m_NbMessagesReceived);
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkedMessagesAreStillReceivedAfterNetworkManagerShutsDownAndRestarts([Values(0, 1, 2)] int nbClients, [Values(0, 1, 2)] int nbSubscribers)
+        {
+            InitializeNetworkedMessageChannels(nbClients, nbSubscribers, new EmptyMessage(), out var emptyMessageChannelClients, out var emptyMessageChannelServer);
+
+            emptyMessageChannelServer.Publish(new EmptyMessage());
+
+            // wait for the custom named message to be sent on the server and received on the clients
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual((nbClients + 1) * nbSubscribers, m_NbMessagesReceived);
+
+            m_NbMessagesReceived = 0;
+
+            // Shutdown the server and clients
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ServerNetworkManager, false);
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ClientNetworkManagers[0], false);
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ClientNetworkManagers[1], false);
+
+            yield return new WaitWhile(() => m_ServerNetworkManager.ShutdownInProgress);
+            yield return new WaitWhile(() => m_ClientNetworkManagers[0].ShutdownInProgress);
+            yield return new WaitWhile(() => m_ClientNetworkManagers[1].ShutdownInProgress);
+
+            // Restart the server and clients
+            m_ServerNetworkManager.StartHost();
+            NetcodeIntegrationTestHelpers.StartOneClient(m_ClientNetworkManagers[0]);
+            NetcodeIntegrationTestHelpers.StartOneClient(m_ClientNetworkManagers[1]);
+
+            yield return WaitForClientsConnectedOrTimeOut();
+
+            // Test sending a message a second time
+            emptyMessageChannelServer.Publish(new EmptyMessage());
+
+            // wait for the custom named message to be sent on the server and received on the clients
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual((nbClients + 1) * nbSubscribers, m_NbMessagesReceived);
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkedMessagesAreReceivedIfClientsSubscribeBeforeConnecting([Values(0, 1, 2)] int nbClients, [Values(0, 1, 2)] int nbSubscribers)
+        {
+            // Shutdown the clients
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ClientNetworkManagers[0], false);
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ClientNetworkManagers[1], false);
+
+            yield return new WaitWhile(() => m_ClientNetworkManagers[0].ShutdownInProgress);
+            yield return new WaitWhile(() => m_ClientNetworkManagers[1].ShutdownInProgress);
+
+            InitializeNetworkedMessageChannels(nbClients, nbSubscribers, new EmptyMessage(), out var emptyMessageChannelClients, out var emptyMessageChannelServer);
+
+            // Restart the clients
+            NetcodeIntegrationTestHelpers.StartOneClient(m_ClientNetworkManagers[0]);
+            NetcodeIntegrationTestHelpers.StartOneClient(m_ClientNetworkManagers[1]);
+
+            yield return WaitForClientsConnectedOrTimeOut();
+
+            emptyMessageChannelServer.Publish(new EmptyMessage());
+
+            // wait for the custom named message to be sent on the server and received on the clients
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual((nbClients + 1) * nbSubscribers, m_NbMessagesReceived);
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkedMessagesAreNotReceivedWhenClientsAreShutDown([Values(0, 1, 2)] int nbClients, [Values(0, 1, 2)] int nbSubscribers)
+        {
+            InitializeNetworkedMessageChannels(nbClients, nbSubscribers, new EmptyMessage(), out var emptyMessageChannelClients, out var emptyMessageChannelServer);
+
+            // Shutdown the clients
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ClientNetworkManagers[0], false);
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ClientNetworkManagers[1], false);
+
+            yield return new WaitWhile(() => m_ClientNetworkManagers[0].ShutdownInProgress);
+            yield return new WaitWhile(() => m_ClientNetworkManagers[1].ShutdownInProgress);
+
+            emptyMessageChannelServer.Publish(new EmptyMessage());
+
+            // wait for the custom named message to be sent on the server and received on the clients
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual(nbSubscribers, m_NbMessagesReceived);
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkedMessagesAreNotReceivedWhenServerIsShutDown([Values(0, 1, 2)] int nbClients, [Values(0, 1, 2)] int nbSubscribers)
+        {
+            InitializeNetworkedMessageChannels(nbClients, nbSubscribers, new EmptyMessage(), out var emptyMessageChannelClients, out var emptyMessageChannelServer);
+
+            // Shutdown the server
+            NetcodeIntegrationTestHelpers.StopOneClient(m_ServerNetworkManager, false);
+
+            yield return new WaitWhile(() => m_ServerNetworkManager.ShutdownInProgress);
+
+            LogAssert.Expect(LogType.Error, "Only a server can publish in a NetworkedMessageChannel");
+            emptyMessageChannelServer.Publish(new EmptyMessage());
+
+            // wait for the custom named message to be sent on the server and received on the clients
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual(0, m_NbMessagesReceived);
+        }
+
+        [UnityTest]
+        public IEnumerator NetworkedMessagesCannotBePublishedFromClient()
+        {
+            InitializeNetworkedMessageChannels(2, 1, new EmptyMessage(), out var emptyMessageChannelClients, out var emptyMessageChannelServer);
+
+            LogAssert.Expect(LogType.Error, "Only a server can publish in a NetworkedMessageChannel");
+            emptyMessageChannelClients[0].Publish(new EmptyMessage());
+
+            // wait for the custom named message to be sent on the server and received on the clients
+            yield return null;
+            yield return null;
+
+            Assert.AreEqual(0, m_NbMessagesReceived);
+        }
+    }
+}