Merge branch 'feature/pathparams'

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 00asdf, GHXX
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

SimpleHttpServer/HttpServer.cs

@@ -24,7 +24,7 @@ public sealed class HttpServer {
         Port = port;
         conf = configuration;
         listener = new HttpListener();
-        listener.Prefixes.Add($"http://127.0.0.1:{port}/");
+        listener.Prefixes.Add($"http://localhost:{port}/");
         mainLogger = new(LogOutputTopic.Main, conf);
         requestLogger = new(LogOutputTopic.Request, conf);
     }
@@ -89,7 +89,6 @@ public sealed class HttpServer {
     private readonly Dictionary<string, PathTree<EndpointInvocationInfo>> pathEndpointMethodInfosTrees = new(); // reqmethod : pathtree
     private static readonly Type[] expectedEndpointParameterTypes = new[] { typeof(RequestContext) };
     internal static readonly int expectedEndpointParameterPrefixCount = expectedEndpointParameterTypes.Length;
-    private readonly Dictionary<string, Func<RequestContext, Task<bool>>> wildcardFallbackHandlers = new(); // reqmethod : handler
 
     public void RegisterEndpointsFromType<T>(Func<T>? instanceFactory = null) where T : class { // T cannot be static, as generic args must be nonstatic
         if (stringToTypeParameterConverters.Count == 0)
@@ -214,7 +213,7 @@ public sealed class HttpServer {
 
     private readonly Dictionary<Type, IParameterConverter> stringToTypeParameterConverters = new();
 
-    private string NormalizeUrlPath(string url) {
+    private static string NormalizeUrlPath(string url) {
         var fwdSlashUrl = url.Replace('\\', '/');
 
         var segments = fwdSlashUrl.Trim('/').Split('/', StringSplitOptions.RemoveEmptyEntries).ToList();
@@ -243,12 +242,7 @@ public sealed class HttpServer {
         }
         rv.AppendJoin('/', simplifiedSegmentsReversed.Reverse<string>());
 
-        var suffix = (rv.ToString().TrimEnd('/') + (fwdSlashUrl.EndsWith('/') ? "/" : "")).TrimStart('/');
+        return '/' + (rv.ToString().TrimEnd('/') + (fwdSlashUrl.EndsWith('/') ? "/" : "")).TrimStart('/');
-        if (conf.TrimTrailingSlash) {
-            suffix = suffix.TrimEnd('/');
-        }
-
-        return '/' + suffix;
     }
 
     private async Task ProcessRequestAsync(HttpListenerContext ctx) {
@@ -268,9 +262,8 @@ public sealed class HttpServer {
             /* Finding the endpoint that should process the request:
              * 1. Try to see if there is a simple endpoint where request method and path match
              * 2. Otherwise, try to see if a path-parameter-endpoint matches (duplicates throw an error on startup)
-             * 3. Otherwise, check if wildcardFallbackHandlers contains a handler for the current requestMethod. If this method returns false 'request was not handled', continue, otherwise skip all future steps.
+             * 3. Otherwise, check if it is inside a static serve path
-             * 4. Otherwise, check if it is inside a static serve path
+             * 4. Otherwise, show 404 page */
-             * 5. Otherwise, show 404 page */
 
             EndpointInvocationInfo? pathEndpointInvocationInfo = null;
             if (simpleEndpointMethodInfos.TryGetValue(requestMethod, reqPath, out var simpleEndpointInvocationInfo) ||
@@ -335,18 +328,10 @@ public sealed class HttpServer {
                     var splittedReqPath = reqPath[1..].Split('/');
                     for (int i = 0; i < pparams.Count; i++) {
                         var pparam = pparams[i];
-                        string paramValue;
                         if (pparam.IsCatchAll)
-                            paramValue = string.Join('/', splittedReqPath[pparam.SegmentStartPos..]);
+                            convertedMParamValues[pparam.ArgPos] = string.Join('/', splittedReqPath[pparam.SegmentStartPos..]);
                         else
-                            paramValue = splittedReqPath[pparam.SegmentStartPos];
+                            convertedMParamValues[pparam.ArgPos] = splittedReqPath[pparam.SegmentStartPos];
-
-                        if (stringToTypeParameterConverters[pparam.Type].TryConvertFromString(paramValue, out var res))
-                            convertedMParamValues[pparam.ArgPos] = res;
-                        else {
-                            await HandleDefaultErrorPageAsync(rc, HttpStatusCode.BadRequest);
-                            return;
-                        }
                     }
                 }
 
@@ -356,17 +341,7 @@ public sealed class HttpServer {
                 // todo read and convert pathparams
 
                 await (Task) (mi.Invoke(endpointInvocationInfo.typeInstanceReference, convertedMParamValues) ?? throw new NullReferenceException("Website func returned null unexpectedly"));
-            } else {
+            } else { // try to find suitable static serve path
-                // ---------------- check for fallback wildcard handler ----------------
-                if (wildcardFallbackHandlers.TryGetValue(requestMethod, out var handler)) {
-                    var handledByWildcard = await handler.Invoke(rc);
-                    if (handledByWildcard) { // if that handler was able to handle the request, end execution
-                        return;
-                    }
-                }
-                // ---------------------------------------------------------------------
-
-                // try to find suitable static serve path
                 if (requestMethod == "GET")
                     foreach (var (k, v) in staticServePaths) {
                         if (reqPath.StartsWith(k)) { // do a static serve
@@ -427,14 +402,4 @@ public sealed class HttpServer {
             }
         } catch (ObjectDisposedException) { }
     }
-
-    /// <summary>
-    /// Adds a wildcard fallback handler that receives any request that was not matched by a more explicit endpoint. 
-    /// The handler is supposed to return 'true' if the request was handled correctly and thus execution shall end. Return 'false' to try to serve the file from a static-serve path.
-    /// </summary>
-    /// <param name="reqMethod"></param>
-    /// <param name="requestHandler">This method must return whether the reuqest was handled; returning false makes handling act as if this handler never ran</param>
-    public void RegisterWildcardFallbackHandler(HttpRequestType reqMethod, Func<RequestContext, Task<bool>> requestHandler) {
-        wildcardFallbackHandlers.Add(Enum.GetName(reqMethod) ?? throw new NotImplementedException(), requestHandler);
-    }
 }

SimpleHttpServer/SimpleHttpServerConfiguration.cs

@@ -13,10 +13,6 @@ public class SimpleHttpServerConfiguration {
     /// See description of <see cref="DisableLogMessagePrinting"/>
     /// </summary>
     public CustomLogMessageHandler? LogMessageHandler { get; init; } = null;
-    /// <summary>
-    /// If set to true, paths ending with / are identical to paths without said trailing slash. E.g. /index is then the same as /index/
-    /// </summary>
-    public bool TrimTrailingSlash { get; init; } = true;
 
     public SimpleHttpServerConfiguration() { }
 

SimpleHttpServer/Types/PathTree.cs

@@ -22,12 +22,12 @@ internal class PathTree<T> where T : class {
                 throw new Exception($"Found illegal catchall-wildcard in path: '{string.Join('/', path)}'");
             }
 
-            var leafdata = unpackedLeafData[i] ?? throw new ArgumentNullException("Leafdata must not be null!");
+            var leafdata = unpackedLeafData[i];
             rootNode.AddSuccessor(path, leafdata);
         }
     }
 
-    internal bool TryGetPath(string reqPath, [MaybeNullWhen(false)] out T endpoint) {
+    internal bool TryGetPath(string reqPath, [MaybeNullWhen(false)] out T? endpoint) {
         if (rootNode == null) {
             endpoint = null;
             return false;
@@ -58,16 +58,16 @@ internal class PathTree<T> where T : class {
 
         // return found path
         endpoint = currNode.leafData;
-        return endpoint != null;
+        return true;
     }
 
     private class Node {
-        public T? leafData = null; // null means that this is a node without a value (e.g. when it is just part of a path)
+        public T? leafData = null;
         public Dictionary<string, Node>? next = null;
         public Node? pathWildcardNext = null; // path wildcard
         public Node? catchAllNext = null; // trailing-catchall wildcard
 
-        public void AddSuccessor(string[] segments, T newLeafData) {
+        public void AddSuccessor(string[] segments, T? newLeafData) {
             if (segments.Length == 0) { // actually add the data to this node
                 Assert(leafData == null);
                 leafData = newLeafData;
@@ -84,14 +84,17 @@ internal class PathTree<T> where T : class {
                     catchAllNext.AddSuccessor(segments[1..], newLeafData);
                     return;
                 } else { // must be single wildcard otherwise
-                    pathWildcardNext ??= new();
+                    Assert(pathWildcardNext == null);
+                    pathWildcardNext = new();
                     pathWildcardNext.AddSuccessor(segments[1..], newLeafData);
                     return;
                 }
             }
 
             // otherwise we want to add a new constant path successor
-            next ??= new();
+            if (next == null) {
+                next = new();
+            }
 
             if (next.TryGetValue(seg, out var existingNode)) {
                 existingNode.AddSuccessor(segments[1..], newLeafData);

SimpleHttpServer/Types/RequestContext.cs

@@ -35,23 +35,22 @@ public class RequestContext : IDisposable {
 
     public void SetStatusCode(HttpStatusCode status) => SetStatusCode((int) status);
 
-    public async Task SetStatusCodeWriteLineDisposeAsync(HttpStatusCode status, string message) {
-        SetStatusCode(status);
-        await WriteLineToRespAsync(message);
-        await RespWriter.FlushAsync();
-    }
-
     public async Task SetStatusCodeAndDisposeAsync(int status) {
         using (this) {
             SetStatusCode(status);
-            if (status != (int)HttpStatusCode.NotModified) { // NotModified must not write any data to response
+            await WriteToRespAsync("\n\n");
-                await WriteToRespAsync("\n\n");
+            await RespWriter.FlushAsync();
-                await RespWriter.FlushAsync();
+        }
-            }
+    }
+
+    public async Task SetStatusCodeAndDisposeAsync(HttpStatusCode status) {
+        using (this) {
+            SetStatusCode((int) status);
+            await WriteToRespAsync("\n\n");
+            await RespWriter.FlushAsync();
         }
     }
 
-    public async Task SetStatusCodeAndDisposeAsync(HttpStatusCode status) => await SetStatusCodeAndDisposeAsync((int) status);
 
     public async Task SetStatusCodeAndDisposeAsync(int status, string description) {
         using (this) {