bumping to pre.10

Fixing connection approval with new API
updating comments to better reflect current state

Author: SamuelBellomo

Assets/Scripts/Gameplay/ConnectionManagement/ServerGameNetPortal.cs

@@ -161,26 +161,27 @@ public bool AreAllClientsInServerScene()
         }
 
         /// <summary>
-        /// This logic plugs into the "ConnectionApprovalCallback" exposed by Netcode.NetworkManager, and is run every time a client connects to us.
-        /// See ClientGameNetPortal.StartClient for the complementary logic that runs when the client starts its connection.
+        /// This logic plugs into the "ConnectionApprovalResponse" exposed by Netcode.NetworkManager. It is run every time a client connects to us.
+        /// The complementary logic that runs when the client starts its connection can be found in ClientGameNetPortal.StartClient.
         /// </summary>
         /// <remarks>
-        /// Since our game doesn't have to interact with some third party authentication service to validate the identity of the new connection, our ApprovalCheck
-        /// method is simple, and runs synchronously, invoking "callback" to signal approval at the end of the method. Netcode currently doesn't support the ability
-        /// to send back more than a "true/false", which means we have to work a little harder to provide a useful error return to the client. To do that, we invoke a
-        /// custom message in the same channel that Netcode uses for its connection callback. Since the delivery is NetworkDelivery.ReliableSequenced, we can be
-        /// confident that our login result message will execute before any disconnect message.
+        /// Multiple things can be done here, some asynchronously. For example, it could authenticate your user against an auth service like UGS' auth service. It can
+        /// also send custom messages to connecting users before they receive their connection result (this is useful to set status messages client side
+        /// when connection is refused, for example).
         /// </remarks>
-        /// <param name="connectionData">binary data passed into StartClient. In our case this is the client's GUID, which is a unique identifier for their install of the game that persists across app restarts. </param>
-        /// <param name="clientId">This is the clientId that Netcode assigned us on login. It does not persist across multiple logins from the same client. </param>
-        /// <param name="connectionApprovedCallback">The delegate we must invoke to signal that the connection was approved or not. </param>
-        void ApprovalCheck(byte[] connectionData, ulong clientId, NetworkManager.ConnectionApprovedDelegate connectionApprovedCallback)
+        ///
+        /// <param name="request"> The initial request contains, among other things, binary data passed into StartClient. In our case, this is the client's GUID,
+        /// which is a unique identifier for their install of the game that persists across app restarts.
+        ///  <param name="response"> Our response to the approval process. In case of connection refusal with custom return message, we delay using the Pending field.
+        void ApprovalCheck(NetworkManager.ConnectionApprovalRequest request, NetworkManager.ConnectionApprovalResponse response)
         {
+            var connectionData = request.Payload;
+            var clientId = request.ClientNetworkId;
             if (connectionData.Length > k_MaxConnectPayload)
             {
                 // If connectionData too high, deny immediately to avoid wasting time on the server. This is intended as
                 // a bit of light protection against DOS attacks that rely on sending silly big buffers of garbage.
-                connectionApprovedCallback(false, 0, false, null, null);
+                response.Approved = false;
                 return;
             }
 
@@ -190,13 +191,14 @@ void ApprovalCheck(byte[] connectionData, ulong clientId, NetworkManager.Connect
                 SessionManager<SessionPlayerData>.Instance.SetupConnectingPlayerSessionData(clientId, m_Portal.GetPlayerId(),
                     new SessionPlayerData(clientId, m_Portal.PlayerName, m_Portal.AvatarRegistry.GetRandomAvatar().Guid.ToNetworkGuid(), 0, true));
 
-                connectionApprovedCallback(true, null, true, null, null);
+                response.Approved = true;
+                response.CreatePlayerObject = true;
                 return;
             }
 
             var payload = System.Text.Encoding.UTF8.GetString(connectionData);
             var connectionPayload = JsonUtility.FromJson<ConnectionPayload>(payload); // https://docs.unity3d.com/2020.2/Documentation/Manual/JSONSerialization.html
-            var gameReturnStatus = GetConnectStatus(connectionPayload);
+            var gameReturnStatus = CanClientConnect(connectionPayload);
 
             if (gameReturnStatus == ConnectStatus.Success)
             {
@@ -207,28 +209,36 @@ void ApprovalCheck(byte[] connectionData, ulong clientId, NetworkManager.Connect
                 //Populate our client scene map
                 m_ClientSceneMap[clientId] = connectionPayload.clientScene;
 
-                // connection approval will create a player object for you
-                connectionApprovedCallback(true, null, true, Vector3.zero, Quaternion.identity);
-
                 m_ConnectionEventPublisher.Publish(new ConnectionEventMessage() { ConnectStatus = ConnectStatus.Success, PlayerName = SessionManager<SessionPlayerData>.Instance.GetPlayerData(clientId)?.PlayerName });
+                response.Approved = true;
+                response.CreatePlayerObject = true;
+                response.Position = Vector3.zero;
+                response.Rotation = Quaternion.identity;
+                return;
             }
-            else
+
+            // In order for clients to not just get disconnected with no feedback, the server needs to tell the client why it disconnected it.
+            // This could happen after an auth check on a service or because of gameplay reasons (server full, wrong build version, etc)
+            // Since network objects haven't synced yet (still in the approval process), we need to send a custom message to clients, wait for
+            // UTP to update a frame and flush that message, then give our response to NetworkManager's connection approval process, with a denied approval.
+            IEnumerator WaitToDenyApproval(NetworkManager.ConnectionApprovalResponse response)
             {
-                //TODO-FIXME:Netcode Issue #796. We should be able to send a reason and disconnect without a coroutine delay.
-                //TODO:Netcode: In the future we expect Netcode to allow us to return more information as part of the
-                //approval callback, so that we can provide more context on a reject. In the meantime we must provide
-                //the extra information ourselves, and then wait a short time before manually close down the connection.
+                response.Pending = true; // give some time for server to send connection status message to clients
+                response.Approved = false;
                 SendServerToClientConnectResult(clientId, gameReturnStatus);
                 SendServerToClientSetDisconnectReason(clientId, gameReturnStatus);
-                StartCoroutine(WaitToDenyApproval(connectionApprovedCallback));
-                if (m_LobbyServiceFacade.CurrentUnityLobby != null)
-                {
-                    m_LobbyServiceFacade.RemovePlayerFromLobbyAsync(connectionPayload.playerId, m_LobbyServiceFacade.CurrentUnityLobby.Id);
-                }
+                yield return null; // wait a frame so UTP can flush it's messages on next update
+                response.Pending = false; // connection approval process can be finished.
+            }
+
+            StartCoroutine(WaitToDenyApproval(response));
+            if (m_LobbyServiceFacade.CurrentUnityLobby != null)
+            {
+                m_LobbyServiceFacade.RemovePlayerFromLobbyAsync(connectionPayload.playerId, m_LobbyServiceFacade.CurrentUnityLobby.Id);
             }
         }
 
-        ConnectStatus GetConnectStatus(ConnectionPayload connectionPayload)
+        ConnectStatus CanClientConnect(ConnectionPayload connectionPayload)
         {
             if (m_Portal.NetManager.ConnectedClientsIds.Count >= CharSelectData.k_MaxLobbyPlayers)
             {
@@ -240,14 +250,7 @@ ConnectStatus GetConnectStatus(ConnectionPayload connectionPayload)
                 return ConnectStatus.IncompatibleBuildType;
             }
 
-            return SessionManager<SessionPlayerData>.Instance.IsDuplicateConnection(connectionPayload.playerId) ?
-                ConnectStatus.LoggedInAgain : ConnectStatus.Success;
-        }
-
-        static IEnumerator WaitToDenyApproval(NetworkManager.ConnectionApprovedDelegate connectionApprovedCallback)
-        {
-            yield return new WaitForSeconds(0.5f);
-            connectionApprovedCallback(false, 0, false, null, null);
+            return SessionManager<SessionPlayerData>.Instance.IsDuplicateConnection(connectionPayload.playerId) ? ConnectStatus.LoggedInAgain : ConnectStatus.Success;
         }
 
         IEnumerator WaitToShutdown()
@@ -310,4 +313,4 @@ void ServerStartedHandler()
         }
 
     }
-}
+}

Packages/manifest.json

@@ -9,7 +9,7 @@
     "com.unity.ide.vscode": "1.2.5",
     "com.unity.learn.iet-framework": "2.2.1",
     "com.unity.memoryprofiler": "0.5.0-preview.1",
-    "com.unity.netcode.gameobjects": "1.0.0-pre.9",
+    "com.unity.netcode.gameobjects": "1.0.0-pre.10",
     "com.unity.multiplayer.tools": "1.0.0-pre.7",
     "com.unity.postprocessing": "3.2.1",
     "com.unity.render-pipelines.universal": "12.1.6",