Switch to express, started mapping

Author: Kaliumhexacyanoferrat

Adapters/WiredIO/Adapter.cs

@@ -7,39 +7,24 @@
 using GenHTTP.Modules.ErrorHandling;
 using GenHTTP.Modules.IO;
 
-using Wired.IO.App;
-using Wired.IO.Http11.Context;
+using Wired.IO.Builder;
+using Wired.IO.Http11Express;
+using Wired.IO.Http11Express.Context;
 
 namespace GenHTTP.Adapters.WiredIO;
 
 public static class Adapter
 {
 
-    /// <summary>
-    /// Registers the given handler to respond to requests to the specified path.
-    /// </summary>
-    /// <param name="app">The application to add the mapping to</param>
-    /// <param name="path">The path to register the handler for</param>
-    /// <param name="handler">The handler to be registered</param>
-    /// <param name="companion">An object that will be informed about handled requests and any error</param>
-    public static void Map(this WiredApp<Http11Context> app, string path, IHandlerBuilder handler, IServerCompanion? companion = null)
-        => Map(app, path, handler.Build(), companion);
+    // ToDo: IBaseRequest and IBaseResponse do not feature basic access (such as headers), so we cannot be generic here
 
-    /// <summary>
-    /// Registers the given handler to respond to requests to the specified path.
-    /// </summary>
-    /// <param name="app">The application to add the mapping to</param>
-    /// <param name="path">The path to register the handler for</param>
-    /// <param name="handler">The handler to be registered</param>
-    /// <param name="companion">An object that will be informed about handled requests and any error</param>
-    public static void Map(this WiredApp<Http11Context> app, string path, IHandler handler, IServerCompanion? companion = null)
-        => app.Map(path + "/{*any}", async context => await Bridge.MapAsync(context, handler, companion: companion, registeredPath: path));
+    public static void Map(this Builder<WiredHttp11Express<Http11ExpressContext>, Http11ExpressContext> builder, string path, IHandlerBuilder handler, IServerCompanion? companion = null)
+        => Map(builder, path, handler.Build(), companion);
 
-    public static void BuildPipeline(this WiredApp<Http11Context> app, IHandlerBuilder handler, IServer server)
-        => app.BuildPipeline(handler, server);
-
-    public static void BuildPipeline(this WiredApp<Http11Context> app, IHandler handler, IServer server)
-        => app.BuildPipeline(new List<Func<Http11Context, Func<Http11Context, Task>, Task>>(), context => Bridge.MapAsync(context, handler, server));
+    public static void Map(this Builder<WiredHttp11Express<Http11ExpressContext>, Http11ExpressContext> builder, string path, IHandler handler, IServerCompanion? companion = null)
+    {
+        builder.UseMiddleware(scope => async (c, n) => await Bridge.MapAsync(c, n, handler, companion: companion, registeredPath: path));
+    }
 
     /// <summary>
     /// Enables default features on the given handler. This should be used on the

Adapters/WiredIO/GenHTTP.Adapters.WiredIO.csproj

@@ -11,7 +11,7 @@
 
     <ItemGroup>
 
-        <PackageReference Include="Wired.IO" Version="9.5.0" />
+        <PackageReference Include="Wired.IO" Version="9.5.3" />
 
         <ProjectReference Include="..\..\API\GenHTTP.Api.csproj"/>
 

Adapters/WiredIO/Mapping/Bridge.cs

@@ -5,20 +5,22 @@
 using GenHTTP.Api.Infrastructure;
 using GenHTTP.Api.Protocol;
 
-using Wired.IO.Http11.Context;
+using Wired.IO.Http11Express.Context;
+
+using WR = Wired.IO.Protocol.Response;
 
 namespace GenHTTP.Adapters.WiredIO.Mapping;
 
 public static class Bridge
 {
 
-    public static async ValueTask MapAsync(Http11Context context, IHandler handler, IServer? server = null, IServerCompanion? companion = null, string? registeredPath = null)
+    public static async Task MapAsync(Http11ExpressContext context, Func<Http11ExpressContext, Task> next, IHandler handler, IServerCompanion? companion = null, string? registeredPath = null)
     {
-        var actualServer = server ?? new ImplicitServer(handler, companion);
+        var server = new ImplicitServer(handler, companion);
 
         try
         {
-            using var request = new Request(actualServer, context);
+            using var request = new Request(server, context.Request);
 
             if (registeredPath != null)
             {
@@ -27,33 +29,34 @@ public static async ValueTask MapAsync(Http11Context context, IHandler handler,
 
             using var response = await handler.HandleAsync(request);
 
-            if (response == null)
+            if (response != null)
             {
-                context.Response.StatusCode = 404;
+                await WriteAsync(response, context);
+
+                server.Companion?.OnRequestHandled(request, response);
             }
             else
             {
-                await WriteAsync(response, context);
-
-                actualServer.Companion?.OnRequestHandled(request, response);
+                await next(context);
             }
         }
         catch (Exception e)
         {
-            actualServer.Companion?.OnServerError(ServerErrorScope.ServerConnection, context.Connection.RemoteIpAddress, e);
+            // todo: cannot tell the IP of the client in wired
+            server.Companion?.OnServerError(ServerErrorScope.ServerConnection, null, e);
             throw;
         }
     }
 
-    private static async ValueTask WriteAsync(IResponse response, HttpContext context)
+    private static async ValueTask WriteAsync(IResponse response, Http11ExpressContext context)
     {
-        var target = context.Response;
+        var target = context.Respond();
 
-        target.StatusCode = response.Status.RawStatus;
+        target.Status((WR.ResponseStatus)response.Status.RawStatus);
 
         foreach (var header in response.Headers)
         {
-            target.Headers.Append(header.Key, header.Value);
+            target.Header(header.Key, header.Value);
         }
 
         if (response.Modified != null)

Adapters/WiredIO/Server/ImplicitServer.cs

@@ -17,6 +17,7 @@ public bool Development
     {
         get
         {
+            // todo: is there something like development mode in wired?
             var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
             return string.Compare(env, "Development", StringComparison.OrdinalIgnoreCase) == 0;
         }
@@ -48,7 +49,7 @@ public ImplicitServer(IHandler handler, IServerCompanion? companion)
 
     public ValueTask DisposeAsync() => new();
 
-    public ValueTask StartAsync() => throw new InvalidOperationException("Server is managed by ASP.NET Core and cannot be started");
+    public ValueTask StartAsync() => throw new InvalidOperationException("Server is managed by WiredIO and cannot be started");
 
     #endregion
 

Adapters/WiredIO/Types/ClientConnection.cs

@@ -4,35 +4,35 @@
 using GenHTTP.Api.Infrastructure;
 using GenHTTP.Api.Protocol;
 
+using Wired.IO.Http11Express.Request;
+
 namespace GenHTTP.Adapters.WiredIO.Types;
 
 public sealed class ClientConnection : IClientConnection
 {
 
     #region Get-/Setters
 
-    public IPAddress IPAddress => Info.RemoteIpAddress ?? throw new InvalidOperationException("Remote client IP address is not known");
+    public IPAddress IPAddress => throw new InvalidOperationException("Remote client IP address is not known");
 
     public ClientProtocol? Protocol { get; }
 
-    public string? Host => Request.Host.HasValue ? Request.Host.Value : null;
-
-    public X509Certificate? Certificate => Info.ClientCertificate;
+    public string? Host => Request.Headers.GetValueOrDefault("Host");
 
-    private ConnectionInfo Info { get; }
+    public X509Certificate? Certificate => null;
 
-    private HttpRequest Request { get; }
+    private IExpressRequest Request { get; }
 
     #endregion
 
     #region Initialization
 
-    public ClientConnection(ConnectionInfo info, HttpRequest request)
+    public ClientConnection(IExpressRequest request)
     {
-        Info = info;
         Request = request;
 
-        Protocol = (request.IsHttps) ? ClientProtocol.Https : ClientProtocol.Http;
+        // todo: wired does not expose this information
+        Protocol = ClientProtocol.Http;
     }
 
     #endregion

Adapters/WiredIO/Types/Request.cs

@@ -1,13 +1,10 @@
 using GenHTTP.Api.Infrastructure;
 using GenHTTP.Api.Protocol;
 using GenHTTP.Api.Routing;
-using GenHTTP.Engine.Shared.Types;
-
-using Wired.IO.Http11.Context;
 
-using HttpProtocol = GenHTTP.Api.Protocol.HttpProtocol;
+using GenHTTP.Engine.Shared.Types;
 
-using WiredRequest = Wired.IO.Http11.Request.IRequest;
+using Wired.IO.Http11Express.Request;
 
 namespace GenHTTP.Adapters.WiredIO.Types;
 
@@ -23,8 +20,6 @@ public sealed class Request : IRequest
 
     private Headers? _Headers;
 
-    private readonly IEndPoint? _EndPoint;
-
     #region Get-/Setters
 
     public IRequestProperties Properties
@@ -34,7 +29,7 @@ public IRequestProperties Properties
 
     public IServer Server { get; }
 
-    public IEndPoint EndPoint => _EndPoint ?? throw new InvalidOperationException("EndPoint is not available as it is managed by ASP.NET Core");
+    public IEndPoint EndPoint => throw new InvalidOperationException("EndPoint is not available as it is managed by WiredIO");
 
     public IClientConnection Client { get; }
 
@@ -56,65 +51,67 @@ public IRequestProperties Properties
 
     public IRequestQuery Query
     {
-        get { return _Query ??= new Query(Context); }
+        get { return _Query ??= new Query(InnerRequest); }
     }
 
     public ICookieCollection Cookies
     {
-        get { return _Cookies ??= new Cookies(Context); }
+        get { return _Cookies ??= new Cookies(InnerRequest); }
     }
 
     public IForwardingCollection Forwardings => _Forwardings;
 
     public IHeaderCollection Headers
     {
-        get { return _Headers ??= new Headers(Context); }
+        get { return _Headers ??= new Headers(InnerRequest); }
     }
 
-    public Stream Content => Context.BodyReader.AsStream(true);
+    // todo: this is quite inefficient
+    public Stream Content => (InnerRequest.Content != null) ? new MemoryStream(InnerRequest.Content) : Stream.Null;
 
-    public FlexibleContentType? ContentType => (Context.ContentType != null) ? new(Context.ContentType) : null;
+    public FlexibleContentType? ContentType
+    {
+        get
+        {
+            if (InnerRequest.Headers.TryGetValue("Content-Type", out var contentType))
+            {
+                return FlexibleContentType.Parse(contentType);
+            }
 
-    private WiredRequest Context { get; }
+            return null;
+        }
+    }
+
+    private IExpressRequest InnerRequest { get; }
 
     #endregion
 
     #region Initialization
 
-    public Request(IServer server, Http11Context context)
+    public Request(IServer server, IExpressRequest request)
     {
         Server = server;
-        Context = context.Request;
+        InnerRequest = request;
 
-        ProtocolType = Context.ConnectionType switch
-        {
-            "HTTP/1.0" => HttpProtocol.Http10,
-            "HTTP/1.1" => HttpProtocol.Http11,
-            "HTTP/2" => HttpProtocol.Http2,
-            "HTTP/3" => HttpProtocol.Http3,
-            _ => HttpProtocol.Http11
-        };
+        // todo: no API provided by wired
+        ProtocolType = HttpProtocol.Http11;
 
-        Method = FlexibleRequestMethod.Get(Context.Method);
-        Target = new RoutingTarget(WebPath.FromString(Context.Path));
+        Method = FlexibleRequestMethod.Get(request.HttpMethod);
+        Target = new RoutingTarget(WebPath.FromString(request.Route));
 
-        if (context.Request.Headers.TryGetValue("forwarded", out var forwardings))
+        if (request.Headers.TryGetValue("forwarded", out var entry))
         {
-            foreach (var entry in forwardings)
-            {
-                if (entry != null) _Forwardings.Add(entry);
-            }
+            _Forwardings.Add(entry);
         }
         else
         {
             _Forwardings.TryAddLegacy(Headers);
         }
 
-        LocalClient = new ClientConnection(context.Connection, context.Request);
-
-        Client = _Forwardings.DetermineClient(context.Connection.ClientCertificate) ?? LocalClient;
+        LocalClient = new ClientConnection(request);
 
-        _EndPoint = Server.EndPoints.FirstOrDefault(e => e.Port == context.Connection.LocalPort);
+        // todo: potential client certificate is not exposed by wired
+        Client = _Forwardings.DetermineClient(null) ?? LocalClient;
     }
 
     #endregion