Make distributed session loading asynchronous to improve scalability … (#1209)

* Make distributed session loading asynchronous to improve scalability (#1195)

* Introduce CustomRedisSessionStore to reduce excessive EXPIRE operations in Redis and improve session handling performance.
Converted ProcessRestRequest method in GXRouting.cs to fully async implementation.

* Ensures sessions load asynchronously

* Apply suggestions from FAzzatto
-Simplified exception handling by replacing await Task.FromException(ex) with throw
-Refactored to throw PageNotFoundException directly when the route cannot be handled, removed unnecessary result task, and moved CommitSessionAsync() to a finally block for clearer async flow

Removed CustomRedisSessionStore which was previously used as an experiment to reduce synchronous Redis Refresh calls. Now that LoadAsync is executed at the start of each request, those synchronous Refresh calls no longer appear to be necessary, because they were caused by the previous synchronous load.

* Refactored method to remove the result variable and await tasks directly, preserving the original behavior.

---------

Co-authored-by: claudiamurialdo <c.murialdo@globant.com>
(cherry picked from commit bb22cbb)

# Conflicts:
#	dotnet/src/dotnetcore/GxClasses.Web/Middleware/GXRouting.cs
#	dotnet/src/dotnetcore/GxNetCoreStartup/SessionHelper.cs
#	dotnet/src/dotnetcore/GxNetCoreStartup/Startup.cs
#	dotnet/src/dotnetframework/GxClasses/Helpers/HttpHelper.cs

* Update SessionHelper.cs

* Update SessionHelper.cs

* Update SessionHelper.cs

Author: claudiamurialdo

dotnet/src/dotnetcore/GxClasses.Web/Middleware/GXRouting.cs

@@ -62,10 +62,10 @@ public GXRouting(string baseURL)
 		}
 
 		static public List<ControllerInfo> GetRouteController(Dictionary<string, string> apiPaths,
-											Dictionary<string, List<string>> sValid,
-											Dictionary<string, Dictionary<string, SingleMap>> sMap,
-											Dictionary<string, Dictionary<Tuple<string, string>, string>> sMapData,
-											string basePath, string verb, string path)
+																				Dictionary<string, List<string>> sValid,
+																				Dictionary<string, Dictionary<string, SingleMap>> sMap,
+																				Dictionary<string, Dictionary<Tuple<string, string>, string>> sMapData,
+																				string basePath, string verb, string path)
 		{
 			List<ControllerInfo> result = new List<ControllerInfo>();
 			string parms = string.Empty;
@@ -78,10 +78,10 @@ static public List<ControllerInfo> GetRouteController(Dictionary<string, string>
 					int questionMarkIdx = path.IndexOf(QUESTIONMARK);
 					string controller;
 					if (apiPaths.ContainsKey(basePath)
-						&& sValid.ContainsKey(basePath)
-						&& sMap.ContainsKey(basePath)
-						&& sMapData.ContainsKey(basePath)
-						)
+							&& sValid.ContainsKey(basePath)
+							&& sMap.ContainsKey(basePath)
+							&& sMapData.ContainsKey(basePath)
+							)
 					{
 						if (sValid[basePath].Contains(path.ToLower()))
 						{
@@ -174,12 +174,12 @@ internal async Task RouteHttpService(HttpContext context)
 				HandlerFactory handlerFactory = new HandlerFactory();
 				await handlerFactory.Invoke(context);
 			}
-			catch (Exception ex)
+			catch
 			{
-				await Task.FromException(ex);
+				throw;
 			}
 		}
-		public Task ProcessRestRequest(HttpContext context)
+		public async Task ProcessRestRequest(HttpContext context)
 		{
 			try
 			{
@@ -188,7 +188,6 @@ public Task ProcessRestRequest(HttpContext context)
 					IHttpContextAccessor contextAccessor = context.RequestServices.GetService<IHttpContextAccessor>();
 					context = new GxHttpContextAccesor(contextAccessor);
 				}
-				Task result = Task.CompletedTask;
 				string path = context.Request.Path.ToString();
 				string actualPath = string.Empty;
 				bool isServiceInPath = ServiceInPath(path, out actualPath);
@@ -220,37 +219,40 @@ public Task ProcessRestRequest(HttpContext context)
 					else
 					{
 						if ((path.Contains(oauthRoute) && (AzureDeploy.GAM == "true")) || path.Contains("gxmulticall")) 
-							return (RouteHttpService(context));
+						{
+							await (RouteHttpService(context));
+							return;
+						}
 						controllerWithParms = GetGxRouteValue(path);
 						GXLogging.Debug(log, $"Running Azure functions. ControllerWithParms :{controllerWithParms} path:{path}");
 					}
-				
+
 					List<ControllerInfo> controllers = GetRouteController(servicesPathUrl, servicesValidPath, servicesMap, servicesMapData, actualPath, context.Request.Method, controllerWithParms);
 					GxRestWrapper controller = null;
 					ControllerInfo controllerInfo = controllers.FirstOrDefault(c => (controller = GetController(context, c)) != null);
-					
+
 
 					if (controller != null)
 					{
 						if (HttpMethods.IsGet(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsGet(controllerInfo.Verb)))
 						{
-							result = controller.Get(controllerInfo.Parameters);
+							await controller.Get(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsPost(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsPost(controllerInfo.Verb)))
 						{
-							result = controller.Post();
+							await controller.Post();
 						}
 						else if (HttpMethods.IsDelete(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsDelete(controllerInfo.Verb)))
 						{
-							result = controller.Delete(controllerInfo.Parameters);
+							await controller.Delete(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsPut(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsPut(controllerInfo.Verb)))
 						{
-							result = controller.Put(controllerInfo.Parameters);
+							await controller.Put(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsPatch(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsPatch(controllerInfo.Verb)))
 						{
-							result = controller.Patch(controllerInfo.Parameters);
+							await controller.Patch(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsOptions(context.Request.Method))
 						{
@@ -284,18 +286,20 @@ public Task ProcessRestRequest(HttpContext context)
 					{
 						GXLogging.Error(log, $"ProcessRestRequest controller not found path:{path} controllerWithParms:{controllerWithParms}");
 						context.Response.Headers.Clear();
-						result = Task.FromException(new PageNotFoundException(path));
+						throw new PageNotFoundException(path);
 					}
 				}
-				context.CommitSession();
-
-				return result;
+				
 			}
 			catch (Exception ex)
 			{
 				GXLogging.Error(log, "ProcessRestRequest", ex);
 				HttpHelper.SetUnexpectedError(context, HttpStatusCode.InternalServerError, ex);
-				return Task.FromException(ex);
+				throw;
+			}
+			finally
+			{
+				await context.CommitSessionAsync();
 			}
 		}
 
@@ -374,20 +378,21 @@ public bool ServiceInPath(String path, out String actualPath)
 					return true;
 				}
 			}
-			else {
+			else
+			{
 				return true;
-			}						
+			}
 		}
 
-		private String FindPath(string innerPath, Dictionary<string,string > servicesPathUrl, bool startTxt)
+		private String FindPath(string innerPath, Dictionary<string, string> servicesPathUrl, bool startTxt)
 		{
 			string actualPath = String.Empty;
-			foreach (string subPath in from String subPath in servicesPathUrl.Keys									
-									select subPath)
+			foreach (string subPath in from String subPath in servicesPathUrl.Keys
+									   select subPath)
 			{
 				bool match = false;
 				innerPath = innerPath.ToLower();
-				match = (startTxt)? innerPath.StartsWith($"/{subPath.ToLower()}"): innerPath.Contains($"/{subPath.ToLower()}");
+				match = (startTxt) ? innerPath.StartsWith($"/{subPath.ToLower()}") : innerPath.Contains($"/{subPath.ToLower()}");
 				if (match)
 				{
 					actualPath = subPath.ToLower();
@@ -431,7 +436,7 @@ public GxRestWrapper GetController(HttpContext context, ControllerInfo controlle
 			bool privateDirExists = Directory.Exists(privateDir);
 
 			GXLogging.Debug(log, $"PrivateDir:{privateDir} asssemblycontroller:{asssemblycontroller}");
-			string svcFile=null;
+			string svcFile = null;
 			if (privateDirExists && File.Exists(Path.Combine(privateDir, $"{asssemblycontroller.ToLower()}.grp.json")))
 			{
 				controller = tmpController;
@@ -498,7 +503,7 @@ string SvcFile(string controller)
 				GXLogging.Warn(log, "Service file not found:" + controllerFullName);
 				return null;
 			}
-			
+
 		}
 		public void ServicesGroupSetting()
 		{
@@ -524,7 +529,7 @@ public void ServicesGroupSetting()
 								string mapPath = (m.BasePath.EndsWith("/")) ? m.BasePath : m.BasePath + "/";
 								string mapPathLower = mapPath.ToLower();
 								string mNameLower = m.Name.ToLower();
-								servicesPathUrl[mapPathLower]= mNameLower;
+								servicesPathUrl[mapPathLower] = mNameLower;
 								if (!RestAPIHelpers.ServiceAsController())
 								{
 									GXLogging.Debug(log, $"addServicesPathUrl key:{mapPathLower} value:{mNameLower}");
@@ -575,7 +580,8 @@ public void ServicesGroupSetting()
 						}
 					}
 				}
-			}catch (Exception ex)
+			}
+			catch (Exception ex)
 			{
 				GXLogging.Error(log, $"Error Loading Services Group Settings", ex);
 				throw;
@@ -676,7 +682,7 @@ public class Binding
 
 	[DataContract()]
 	public class MapGroup
-	{	
+	{
 		String _objectType;
 		String _name;
 		String _basePath;

dotnet/src/dotnetcore/GxClasses.Web/Middleware/HandlerFactory.cs

@@ -89,13 +89,13 @@ public async Task Invoke(HttpContext context)
 				}
 				else
 				{
-					await Task.FromException(new PageNotFoundException(url));
+					throw new PageNotFoundException(url);
 				}
 			}
 			catch (Exception ex)
 			{
 				GXLogging.Error(log, $"Handler Factory failed creating {url}", ex);
-				await Task.FromException(ex);
+				throw;
 			}
 		}
 		private static string ObjectUrl(string requestPath, string basePath) 

dotnet/src/dotnetcore/GxClasses/Domain/HttpSessionState.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using System.Reflection;
+using System.Threading;
 using Microsoft.AspNetCore.Http;
 
 namespace GeneXus.Http
@@ -32,34 +34,13 @@ public static CookieCollection GetCookies(this CookieContainer container)
 			return allCookies;
 		}
 	}
-	internal class LockTracker : IDisposable
+	public static class LockTracker
 	{
-		private static Dictionary<string, LockTracker> _locks = new Dictionary<string, LockTracker>();
-		private int _activeUses = 0;
-		private readonly string _id;
+		private static readonly ConcurrentDictionary<string, SemaphoreSlim> _locks = new();
 
-		private LockTracker(string id) => _id = id;
-
-		internal static LockTracker Get(string id)
-		{
-			lock (_locks)
-			{
-				if (!_locks.ContainsKey(id))
-					_locks.Add(id, new LockTracker(id));
-				var res = _locks[id];
-				res._activeUses += 1;
-				return res;
-			}
-		}
-
-		void IDisposable.Dispose()
+		public static SemaphoreSlim Get(string sessionId)
 		{
-			lock (_locks)
-			{
-				_activeUses--;
-				if (_activeUses == 0)
-					_locks.Remove(_id);
-			}
+			return _locks.GetOrAdd(sessionId, _ => new SemaphoreSlim(1, 1));
 		}
 	}
 	internal class HttpSyncSessionState : HttpSessionState

dotnet/src/dotnetcore/GxNetCoreStartup/SessionHelper.cs

@@ -69,7 +69,6 @@ public async Task Invoke(HttpContext context)
 				if (!string.IsNullOrEmpty(subdomain))
 					context.Items[AppContext.TENANT_ID] = subdomain;
 			}
-
 			await _next(context);
 		}
 	}