From 711b12fa249cba9effecd4e722dd8d460d083659 Mon Sep 17 00:00:00 2001
From: vnugent <public@vaughnnugent.com>
Date: Tue, 17 Sep 2024 14:29:49 -0400
Subject: feat: some mvc static routing extensions

---
 .../src/Routing/RoutingExtensions.cs               | 92 +++++++---------------
 1 file changed, 29 insertions(+), 63 deletions(-)

(limited to 'lib/VNLib.Plugins.Extensions.Loading/src/Routing/RoutingExtensions.cs')

diff --git a/lib/VNLib.Plugins.Extensions.Loading/src/Routing/RoutingExtensions.cs b/lib/VNLib.Plugins.Extensions.Loading/src/Routing/RoutingExtensions.cs
index 6665a75..39a2d83 100644
--- a/lib/VNLib.Plugins.Extensions.Loading/src/Routing/RoutingExtensions.cs
+++ b/lib/VNLib.Plugins.Extensions.Loading/src/Routing/RoutingExtensions.cs
@@ -24,19 +24,14 @@
 
 using System;
 using System.Reflection;
-using System.Threading.Tasks;
-using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using System.Runtime.CompilerServices;
 
-using VNLib.Net.Http;
 using VNLib.Utils.Logging;
 using VNLib.Utils.Resources;
 using VNLib.Plugins.Essentials.Runtime;
-using VNLib.Plugins.Essentials;
-using VNLib.Plugins.Essentials.Endpoints;
-using VNLib.Plugins.Extensions.Loading.Routing.Mvc;
+
 
 namespace VNLib.Plugins.Extensions.Loading.Routing
 {
@@ -110,6 +105,7 @@ namespace VNLib.Plugins.Extensions.Loading.Routing
             return pBase ?? throw new InvalidOperationException("Endpoint was not dynamically routed");
         }
 
+
         private static readonly Regex ConfigSyntaxParser = ParserRegex();
         private delegate void InitFunc(string path, ILogProvider log);
 
@@ -119,9 +115,7 @@ namespace VNLib.Plugins.Extensions.Loading.Routing
         private static void InitEndpointSettings<T>(PluginBase plugin, T endpoint) where T : IEndpoint
         {
             //Load optional config
-            IConfigScope config = plugin.GetConfigForType<T>();
-
-            ILogProvider logger = plugin.Log;
+            IConfigScope? config = plugin.TryGetConfigForType<T>();
 
             EndpointPathAttribute? pathAttr = typeof(T).GetCustomAttribute<EndpointPathAttribute>();
 
@@ -136,18 +130,13 @@ namespace VNLib.Plugins.Extensions.Loading.Routing
                 return;
             }
 
-            string? logName = typeof(T).GetCustomAttribute<EndpointLogNameAttribute>()?.LogName;
+            ILogProvider logger = ConfigureLogger<T>(plugin, config);
 
-            if (!string.IsNullOrWhiteSpace(logName))
-            {
-                logger = plugin.Log.CreateScope(SubsituteValue(logName, config));
-            }
             try
             {
-
                 //Invoke init function and pass in variable names
                 initPathAndLog(
-                    path: SubsituteValue(pathAttr.Path, config),
+                    path: SubsituteConfigStringValue(pathAttr.Path, config),
                     logger
                 );
             }
@@ -159,68 +148,45 @@ namespace VNLib.Plugins.Extensions.Loading.Routing
             {
                 throw new ConfigurationException($"Failed to initalize endpoint {endpoint.GetType().Name}", e);
             }
-
-            static string SubsituteValue(string pathVar, IConfigScope? config)
-            {
-                if (config is null)
-                {
-                    return pathVar;
-                }
-
-                // Replace the matched pattern with the corresponding value from the dictionary
-                return ConfigSyntaxParser.Replace(pathVar, match =>
-                {
-                    string varName = match.Groups[1].Value;
-
-                    //Get the value from the config scope or return the original variable unmodified
-                    return config.GetValueOrDefault(varName, varName);
-                });
-            }
-        }
-
-        private sealed class EndpointCollection : IVirtualEndpointDefinition
-        {
-            public List<IEndpoint> Endpoints { get; } = new();
-
-            ///<inheritdoc/>
-            IEnumerable<IEndpoint> IVirtualEndpointDefinition.GetEndpoints() => Endpoints;
         }
 
-
-        private delegate ValueTask<VfReturnType> EndpointWorkFunc(HttpEntity entity);
-
-        sealed record class HttpControllerEndpoint(MethodInfo MethodInfo, HttpEndpointAttribute Attr)
+        internal static string SubsituteConfigStringValue(string pathVar, IConfigScope? config)
         {
-            public string Path => Attr.Path;
+            if (config is null)
+            {
+                return pathVar;
+            }
 
-            public HttpMethod Method => Attr.Method;
+            // Replace the matched pattern with the corresponding value from the dictionary
+            return ConfigSyntaxParser.Replace(pathVar, match =>
+            {
+                string varName = match.Groups[1].Value;
 
-            public EndpointWorkFunc Func { get; } = MethodInfo.CreateDelegate<EndpointWorkFunc>();
+                //Get the value from the config scope or return the original variable unmodified
+                return config.GetValueOrDefault(varName, varName);
+            });
         }
 
-        private sealed class EndpointWrapper 
-            : ResourceEndpointBase
+        internal static ILogProvider ConfigureLogger<T>(PluginBase plugin, IConfigScope? config)
         {
+            ILogProvider logger = plugin.Log;
 
-            private readonly FrozenDictionary<HttpMethod, EndpointWorkFunc> _wrappers;
+            string? logName = typeof(T).GetCustomAttribute<EndpointLogNameAttribute>()?.LogName;
 
-            public EndpointWrapper(FrozenDictionary<HttpMethod, EndpointWorkFunc> table, string path, ILogProvider log)
+            if (!string.IsNullOrWhiteSpace(logName))
             {
-                _wrappers = table;
-                InitPathAndLog(path, log);
+                logger = plugin.Log.CreateScope(SubsituteConfigStringValue(logName, config));
             }
 
-            protected override ValueTask<VfReturnType> OnProcessAsync(HttpEntity entity)
-            {
-                ref readonly EndpointWorkFunc func = ref _wrappers.GetValueRefOrNullRef(entity.Server.Method);
+            return logger;
+        }
 
-                if (Unsafe.IsNullRef(in func))
-                {
-                    return ValueTask.FromResult(VfReturnType.ProcessAsFile);
-                }
+        private sealed class EndpointCollection : IVirtualEndpointDefinition
+        {
+            public List<IEndpoint> Endpoints { get; } = [];
 
-                return func(entity);
-            }
+            ///<inheritdoc/>
+            IEnumerable<IEndpoint> IVirtualEndpointDefinition.GetEndpoints() => Endpoints;
         }
     }
 }
-- 
cgit