Improve stability of tasks a bit

valkyrienyanko · valkyrienyanko · commit 3825d2628d30 · 2022-05-05T14:09:45.000-05:00
diff --git a/Scripts/Msc/UIPopupCreateLobby.cs b/Scripts/Msc/UIPopupCreateLobby.cs
@@ -104,8 +104,7 @@ private async void _on_Create_pressed()
             NetworkManager.StartServer(port, ValidatedMaxPlayerCount);
             NetworkManager.StartClient(localIp, port);
 
-            await NetworkManager.WaitForClientToConnect(3000, async () =>
-            {
+            await SceneGameServersScript.ClientConnect(async () => {
                 await NetworkManager.WaitForHostToConnectToServer();
                 await NetworkManager.GameClient.Send(ClientPacketOpcode.Lobby, new CPacketLobby
                 {
diff --git a/Scripts/Scenes/Game Servers/SceneGameServers.cs b/Scripts/Scenes/Game Servers/SceneGameServers.cs
@@ -9,23 +9,26 @@ namespace GodotModules
 {
     public class SceneGameServers : AScene
     {
-        public Dictionary<string, LobbyListing> LobbyListings { get; set; }
+        public UIPopupCreateLobby ServerCreationPopup { get; set; }
         public UILobbyListing SelectedLobbyInstance { get; set; }
         public bool GettingServers { get; set; }
 
         [Export] public readonly NodePath NodePathServerList;
         [Export] public readonly NodePath NodePathServerCreationPopup;
 
+        private Dictionary<string, LobbyListing> LobbyListings { get; set; }
         private VBoxContainer ServerList { get; set; }
-        public UIPopupCreateLobby ServerCreationPopup { get; set; }
+        private CancellationTokenSource CTSClientConnecting { get; set; }
+        private CancellationTokenSource CTSPingServers { get; set; }
 
         public override async void _Ready()
         {
+            CTSClientConnecting = new CancellationTokenSource();
             GettingServers = true; // because we await GetServers() at bottom
             UIGameServersNavBtns.BtnRefresh.Disabled = true;
-
             ServerList = GetNode<VBoxContainer>(NodePathServerList);
             ServerCreationPopup = GetNode<UIPopupCreateLobby>(NodePathServerCreationPopup);
+
             LobbyListings = new();
 
             if (GameClient.Disconnected)
@@ -67,7 +70,7 @@ public override async void _Input(InputEvent @event)
             await SceneManager.EscapeToScene("Menu", () =>
             {
                 WebClient.Client.CancelPendingRequests();
-                NetworkManager.CancelClientConnectingTokenSource();
+                NetworkManager.GameClient.CancelTask();
             });
         }
 
@@ -82,8 +85,7 @@ public async Task JoinServer(LobbyListing info, bool directConnect)
             GD.Print("Connecting to lobby...");
             NetworkManager.StartClient(info.Ip, info.Port);
 
-            await NetworkManager.WaitForClientToConnect(3000, async () =>
-            {
+            await ClientConnect(async () => {
                 await NetworkManager.GameClient.Send(ClientPacketOpcode.Lobby, new CPacketLobby
                 {
                     LobbyOpcode = LobbyOpcode.LobbyJoin,
@@ -93,6 +95,8 @@ await NetworkManager.WaitForClientToConnect(3000, async () =>
             });
         }
 
+        public async Task ClientConnect(Action action) => await NetworkManager.WaitForClientToConnect(3000, CTSClientConnecting, action);
+
         public void AddServer(LobbyListing info)
         {
             var lobby = Prefabs.LobbyListing.Instance<UILobbyListing>();
@@ -106,8 +110,6 @@ public void ClearServers()
                 child.QueueFree();
         }
 
-        public CancellationTokenSource PingServersCTS;
-
         public async Task ListServers()
         {
             GettingServers = true;
@@ -132,8 +134,8 @@ public async Task ListServers()
 
             res.Content.ForEach(async server =>
             {
-                PingServersCTS = new CancellationTokenSource();
-                PingServersCTS.CancelAfter(1000);
+                CTSPingServers = new CancellationTokenSource();
+                CTSPingServers.CancelAfter(1000);
 
                 var dummyClient = new ENetClient();
                 dummyClient.Start("127.0.0.1", 7777);
@@ -143,23 +145,23 @@ public async Task ListServers()
                     try
                     {
                         while (!dummyClient.IsConnected)
-                            await Task.Delay(100, PingServersCTS.Token);
+                            await Task.Delay(100, CTSPingServers.Token);
 
                         await dummyClient.Send(Netcode.ClientPacketOpcode.Ping);
 
                         while (!dummyClient.WasPingReceived)
-                            await Task.Delay(1, PingServersCTS.Token);
+                            await Task.Delay(1, CTSPingServers.Token);
 
                         dummyClient.WasPingReceived = false;
                     }
                     catch (TaskCanceledException) { }
-                }, PingServersCTS.Token);
+                }, CTSPingServers.Token);
 
                 tasks.Add(task);
 
                 await task;
 
-                if (!PingServersCTS.IsCancellationRequested)
+                if (!CTSPingServers.IsCancellationRequested)
                 {
                     LobbyListings[server.Ip] = server;
                     server.Ping = dummyClient.PingMs;
@@ -197,11 +199,14 @@ private void _on_Control_resized()
 
         public override void Cleanup()
         {
-            if (PingServersCTS != null)
+            if (CTSPingServers != null)
             {
-                PingServersCTS.Cancel();
-                PingServersCTS.Dispose();
+                CTSPingServers.Cancel();
+                CTSPingServers.Dispose();
             }
+
+            CTSClientConnecting.Cancel();
+            CTSClientConnecting.Dispose();
         }
     }
 }
diff --git a/Scripts/Scenes/Main/GameManager.cs b/Scripts/Scenes/Main/GameManager.cs
@@ -61,11 +61,6 @@ private static async Task ExitCleanup()
 
                 UtilOptions.SaveOptions();
                 NetworkManager.WebClient.Dispose();
-
-                //if (SceneGameServers.PingServersCTS != null)
-                //SceneGameServers.PingServersCTS.Dispose();
-                if (NetworkManager.ClientConnectingTokenSource != null)
-                    NetworkManager.ClientConnectingTokenSource.Dispose();
             }
             catch (Exception e)
             {
diff --git a/Scripts/Scenes/Main/NetworkManager.cs b/Scripts/Scenes/Main/NetworkManager.cs
@@ -16,7 +16,6 @@ public class NetworkManager : Node
         public static GameClient GameClient { get; set; }
         public static WebClient WebClient { get; set; }
         public static NetworkManager Instance { get; set; }
-        public static CancellationTokenSource ClientConnectingTokenSource { get; set; }
 
         public static DisconnectOpcode DisconnectOpcode { get; set; }
         public static uint PeerId { get; set; } // this clients peer id (grabbed from server at some point)
@@ -86,7 +85,7 @@ public override async void _Process(float delta)
                         Console.ForegroundColor = ConsoleColor.Red;
                         GD.PrintErr(exception);
                         Console.ResetColor();
-                        
+
                         ErrorNotifier.IncrementErrorCount();
                         UIDebugger.AddMessage(errorText);
                         break;
@@ -129,33 +128,22 @@ public static async Task WaitForHostToConnectToServer()
                 await Task.Delay(200);
         }
 
-        public static async Task WaitForClientToConnect(int timeoutMs, Action onClientConnected)
+        public static async Task WaitForClientToConnect(int timeoutMs, CancellationTokenSource cts, Action onClientConnected)
         {
-            ClientConnectingTokenSource = new CancellationTokenSource();
-            ClientConnectingTokenSource.CancelAfter(timeoutMs);
+            cts.CancelAfter(timeoutMs);
             await Task.Run(async () =>
             {
                 while (!NetworkManager.GameClient.IsConnected)
                 {
-                    if (ClientConnectingTokenSource.IsCancellationRequested)
+                    if (cts.IsCancellationRequested)
                         break;
 
                     await Task.Delay(100);
                 }
-            }, ClientConnectingTokenSource.Token).ContinueWith((task) =>
-            {
-                if (!ClientConnectingTokenSource.IsCancellationRequested)
-                    onClientConnected();
-            });
-        }
-
-        public static void CancelClientConnectingTokenSource()
-        {
-            if (ClientConnectingTokenSource == null)
-                return;
+            }, cts.Token);
 
-            ClientConnectingTokenSource.Cancel();
-            GameClient.CancelTask();
+            if (!cts.IsCancellationRequested)
+                onClientConnected();
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -104,8 +104,7 @@ private async void _on_Create_pressed()`
`104`	`104`	`NetworkManager.StartServer(port, ValidatedMaxPlayerCount);`
`105`	`105`	`NetworkManager.StartClient(localIp, port);`
`106`	`106`
`107`		`- await NetworkManager.WaitForClientToConnect(3000, async () =>`
`108`		`- {`
	`107`	`+ await SceneGameServersScript.ClientConnect(async () => {`
`109`	`108`	`await NetworkManager.WaitForHostToConnectToServer();`
`110`	`109`	`await NetworkManager.GameClient.Send(ClientPacketOpcode.Lobby, new CPacketLobby`
`111`	`110`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,23 +9,26 @@ namespace GodotModules`
`9`	`9`	`{`
`10`	`10`	`public class SceneGameServers : AScene`
`11`	`11`	`{`
`12`		`- public Dictionary<string, LobbyListing> LobbyListings { get; set; }`
	`12`	`+ public UIPopupCreateLobby ServerCreationPopup { get; set; }`
`13`	`13`	`public UILobbyListing SelectedLobbyInstance { get; set; }`
`14`	`14`	`public bool GettingServers { get; set; }`
`15`	`15`
`16`	`16`	`[Export] public readonly NodePath NodePathServerList;`
`17`	`17`	`[Export] public readonly NodePath NodePathServerCreationPopup;`
`18`	`18`
	`19`	`+ private Dictionary<string, LobbyListing> LobbyListings { get; set; }`
`19`	`20`	`private VBoxContainer ServerList { get; set; }`
`20`		`- public UIPopupCreateLobby ServerCreationPopup { get; set; }`
	`21`	`+ private CancellationTokenSource CTSClientConnecting { get; set; }`
	`22`	`+ private CancellationTokenSource CTSPingServers { get; set; }`
`21`	`23`
`22`	`24`	`public override async void _Ready()`
`23`	`25`	`{`
	`26`	`+ CTSClientConnecting = new CancellationTokenSource();`
`24`	`27`	`GettingServers = true; // because we await GetServers() at bottom`
`25`	`28`	`UIGameServersNavBtns.BtnRefresh.Disabled = true;`
`26`		`-`
`27`	`29`	`ServerList = GetNode<VBoxContainer>(NodePathServerList);`
`28`	`30`	`ServerCreationPopup = GetNode<UIPopupCreateLobby>(NodePathServerCreationPopup);`
	`31`	`+`
`29`	`32`	`LobbyListings = new();`
`30`	`33`
`31`	`34`	`if (GameClient.Disconnected)`
`@@ -67,7 +70,7 @@ public override async void _Input(InputEvent @event)`
`67`	`70`	`await SceneManager.EscapeToScene("Menu", () =>`
`68`	`71`	`{`
`69`	`72`	`WebClient.Client.CancelPendingRequests();`
`70`		`- NetworkManager.CancelClientConnectingTokenSource();`
	`73`	`+ NetworkManager.GameClient.CancelTask();`
`71`	`74`	`});`
`72`	`75`	`}`
`73`	`76`
`@@ -82,8 +85,7 @@ public async Task JoinServer(LobbyListing info, bool directConnect)`
`82`	`85`	`GD.Print("Connecting to lobby...");`
`83`	`86`	`NetworkManager.StartClient(info.Ip, info.Port);`
`84`	`87`
`85`		`- await NetworkManager.WaitForClientToConnect(3000, async () =>`
`86`		`- {`
	`88`	`+ await ClientConnect(async () => {`
`87`	`89`	`await NetworkManager.GameClient.Send(ClientPacketOpcode.Lobby, new CPacketLobby`
`88`	`90`	`{`
`89`	`91`	`LobbyOpcode = LobbyOpcode.LobbyJoin,`
`@@ -93,6 +95,8 @@ await NetworkManager.WaitForClientToConnect(3000, async () =>`
`93`	`95`	`});`
`94`	`96`	`}`
`95`	`97`
	`98`	`+ public async Task ClientConnect(Action action) => await NetworkManager.WaitForClientToConnect(3000, CTSClientConnecting, action);`
	`99`	`+`
`96`	`100`	`public void AddServer(LobbyListing info)`
`97`	`101`	`{`
`98`	`102`	`var lobby = Prefabs.LobbyListing.Instance<UILobbyListing>();`
`@@ -106,8 +110,6 @@ public void ClearServers()`
`106`	`110`	`child.QueueFree();`
`107`	`111`	`}`
`108`	`112`
`109`		`- public CancellationTokenSource PingServersCTS;`
`110`		`-`
`111`	`113`	`public async Task ListServers()`
`112`	`114`	`{`
`113`	`115`	`GettingServers = true;`
`@@ -132,8 +134,8 @@ public async Task ListServers()`
`132`	`134`
`133`	`135`	`res.Content.ForEach(async server =>`
`134`	`136`	`{`
`135`		`- PingServersCTS = new CancellationTokenSource();`
`136`		`- PingServersCTS.CancelAfter(1000);`
	`137`	`+ CTSPingServers = new CancellationTokenSource();`
	`138`	`+ CTSPingServers.CancelAfter(1000);`
`137`	`139`
`138`	`140`	`var dummyClient = new ENetClient();`
`139`	`141`	`dummyClient.Start("127.0.0.1", 7777);`
`@@ -143,23 +145,23 @@ public async Task ListServers()`
`143`	`145`	`try`
`144`	`146`	`{`
`145`	`147`	`while (!dummyClient.IsConnected)`
`146`		`- await Task.Delay(100, PingServersCTS.Token);`
	`148`	`+ await Task.Delay(100, CTSPingServers.Token);`
`147`	`149`
`148`	`150`	`await dummyClient.Send(Netcode.ClientPacketOpcode.Ping);`
`149`	`151`
`150`	`152`	`while (!dummyClient.WasPingReceived)`
`151`		`- await Task.Delay(1, PingServersCTS.Token);`
	`153`	`+ await Task.Delay(1, CTSPingServers.Token);`
`152`	`154`
`153`	`155`	`dummyClient.WasPingReceived = false;`
`154`	`156`	`}`
`155`	`157`	`catch (TaskCanceledException) { }`
`156`		`- }, PingServersCTS.Token);`
	`158`	`+ }, CTSPingServers.Token);`
`157`	`159`
`158`	`160`	`tasks.Add(task);`
`159`	`161`
`160`	`162`	`await task;`
`161`	`163`
`162`		`- if (!PingServersCTS.IsCancellationRequested)`
	`164`	`+ if (!CTSPingServers.IsCancellationRequested)`
`163`	`165`	`{`
`164`	`166`	`LobbyListings[server.Ip] = server;`
`165`	`167`	`server.Ping = dummyClient.PingMs;`
`@@ -197,11 +199,14 @@ private void _on_Control_resized()`
`197`	`199`
`198`	`200`	`public override void Cleanup()`
`199`	`201`	`{`
`200`		`- if (PingServersCTS != null)`
	`202`	`+ if (CTSPingServers != null)`
`201`	`203`	`{`
`202`		`- PingServersCTS.Cancel();`
`203`		`- PingServersCTS.Dispose();`
	`204`	`+ CTSPingServers.Cancel();`
	`205`	`+ CTSPingServers.Dispose();`
`204`	`206`	`}`
	`207`	`+`
	`208`	`+ CTSClientConnecting.Cancel();`
	`209`	`+ CTSClientConnecting.Dispose();`
`205`	`210`	`}`
`206`	`211`	`}`
`207`	`212`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,11 +61,6 @@ private static async Task ExitCleanup()`
`61`	`61`
`62`	`62`	`UtilOptions.SaveOptions();`
`63`	`63`	`NetworkManager.WebClient.Dispose();`
`64`		`-`
`65`		`- //if (SceneGameServers.PingServersCTS != null)`
`66`		`- //SceneGameServers.PingServersCTS.Dispose();`
`67`		`- if (NetworkManager.ClientConnectingTokenSource != null)`
`68`		`- NetworkManager.ClientConnectingTokenSource.Dispose();`
`69`	`64`	`}`
`70`	`65`	`catch (Exception e)`
`71`	`66`	`{`