Merge pull request #617 from Kaliumhexacyanoferrat/genhttp-kestrel

[C#] GenHTTP: Add Kestrel based tests (including H2/H3)

Author: MDA2AV

frameworks/genhttp-kestrel/Dockerfile

@@ -0,0 +1,24 @@
+FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
+WORKDIR /source
+
+COPY genhttp.csproj ./
+RUN dotnet restore
+
+COPY . .
+RUN dotnet publish -c Release --no-self-contained -o /app
+
+FROM mcr.microsoft.com/dotnet/aspnet:10.0
+
+ADD https://packages.microsoft.com/config/debian/12/packages-microsoft-prod.deb /packages-microsoft-prod.deb
+
+RUN dpkg -i packages-microsoft-prod.deb && rm packages-microsoft-prod.deb \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends libmsquic \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY --from=build /app .
+
+EXPOSE 8080 8081 8082 8443/tcp 8443/udp
+ENTRYPOINT ["dotnet", "genhttp.dll"]

frameworks/genhttp-kestrel/Model.cs

@@ -0,0 +1,41 @@
+namespace genhttp;
+
+public class DatasetItem
+{
+    public int Id { get; set; }
+    public string Name { get; set; } = "";
+    public string Category { get; set; } = "";
+    public int Price { get; set; }
+    public int Quantity { get; set; }
+    public bool Active { get; set; }
+    public List<string>? Tags { get; set; }
+    public RatingInfo? Rating { get; set; }
+}
+
+public class ProcessedItem
+{
+    public int Id { get; set; }
+    public string Name { get; set; } = "";
+    public string Category { get; set; } = "";
+    public int Price { get; set; }
+    public int Quantity { get; set; }
+    public bool Active { get; set; }
+    public List<string>? Tags { get; set; }
+    public RatingInfo? Rating { get; set; }
+    public long Total { get; set; }
+}
+
+public class RatingInfo
+{
+    public int Score { get; set; }
+    public int Count { get; set; }
+}
+
+public class ListWithCount<T>(List<T> items)
+{
+
+    public List<T> Items => items;
+    
+    public int Count => items.Count;
+
+}

frameworks/genhttp-kestrel/Program.cs

@@ -0,0 +1,27 @@
+using System.Net;
+using System.Security.Cryptography.X509Certificates;
+
+using genhttp;
+
+using GenHTTP.Engine.Kestrel;
+using GenHTTP.Modules.Compression;
+
+var certPath = Environment.GetEnvironmentVariable("TLS_CERT") ?? "/certs/server.crt";
+var keyPath = Environment.GetEnvironmentVariable("TLS_KEY") ?? "/certs/server.key";
+var hasCert = File.Exists(certPath) && File.Exists(keyPath);
+
+var app = Project.Create();
+
+var host = Host.Create()
+               .Handler(app)
+               .Compression();
+
+host.Bind(IPAddress.Any, 8080);
+
+if (hasCert)
+{
+    host.Bind(IPAddress.Any, 8081, X509Certificate2.CreateFromPemFile(certPath, keyPath));
+    host.Bind(IPAddress.Any, 8443, X509Certificate2.CreateFromPemFile(certPath, keyPath), enableQuic: true);
+}
+
+await host.RunAsync();

frameworks/genhttp-kestrel/Project.cs

@@ -0,0 +1,48 @@
+using GenHTTP.Api.Content;
+using GenHTTP.Modules.IO;
+using GenHTTP.Modules.Layouting;
+using GenHTTP.Modules.Layouting.Provider;
+using GenHTTP.Modules.Webservices;
+using GenHTTP.Modules.Websockets;
+
+using genhttp.Tests;
+
+namespace genhttp;
+
+public static class Project
+{
+    public static IHandlerBuilder Create()
+    {
+        var app = Layout.Create()
+                        .Add("pipeline", Content.From(Resource.FromString("ok")))
+                        .AddService<Baseline>("baseline11")
+                        .AddService<Baseline>("baseline2")
+                        .AddService<Upload>("upload")
+                        .AddService<Json>("json")
+                        .AddService<AsyncDatabase>("async-db")
+                        .AddStaticFiles()
+                        .AddWebsocket();
+
+        return app;
+    }
+
+    private static LayoutBuilder AddStaticFiles(this LayoutBuilder app)
+    {
+        if (Directory.Exists("/data/static"))
+        {
+            app.Add("static", Resources.From(ResourceTree.FromDirectory("/data/static")));
+        }
+
+        return app;
+    }
+
+    private static LayoutBuilder AddWebsocket(this LayoutBuilder app)
+    {
+        var websocket = Websocket.Imperative()
+                                 .DoNotAllocateFrameData()
+                                 .Handler(new EchoHandler());
+
+        return app.Add("ws", websocket);
+    }
+
+}

frameworks/genhttp-kestrel/README.md

@@ -0,0 +1,29 @@
+# GenHTTP
+
+Lightweight embeddable C# web server using the GenHTTP library on the Kestrel engine.
+
+## Stack
+
+- **Language:** C# / .NET 10 (Alpine)
+- **Framework:** GenHTTP
+- **Engine:** GenHTTP
+
+## Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/pipeline` | GET | Returns `ok` (plain text) |
+| `/baseline11` | GET | Sums query parameter values |
+| `/baseline11` | POST | Sums query parameters + request body |
+| `/baseline2` | GET | Sums query parameter values (HTTP/2 variant) |
+| `/json` | GET | Processes 50-item dataset, serializes JSON |
+| `/compression` | GET | Gzip-compressed large JSON response |
+| `/db` | GET | SQLite range query with JSON response |
+| `/upload` | POST | Receives 1 MB body, returns byte count |
+| `/static/{filename}` | GET | Serves preloaded static files with MIME types |
+
+## Notes
+
+- Implemented via web services and a layout router
+- Compression and routing modules
+- Self-contained single-file deployment

frameworks/genhttp-kestrel/Tests/AsyncDatabase.cs

@@ -0,0 +1,65 @@
+using System.Text.Json;
+
+using GenHTTP.Modules.Webservices;
+
+using Npgsql;
+
+namespace genhttp.Tests;
+
+public class AsyncDatabase
+{
+    private static readonly NpgsqlDataSource? PgDataSource = OpenPgPool();
+
+    private static NpgsqlDataSource? OpenPgPool()
+    {
+        var dbUrl = Environment.GetEnvironmentVariable("DATABASE_URL");
+        if (string.IsNullOrEmpty(dbUrl)) return null;
+        try
+        {
+            var uri = new Uri(dbUrl);
+            var userInfo = uri.UserInfo.Split(':');
+            var connStr = $"Host={uri.Host};Port={uri.Port};Username={userInfo[0]};Password={userInfo[1]};Database={uri.AbsolutePath.TrimStart('/')};Maximum Pool Size=256;Minimum Pool Size=64;Multiplexing=true;No Reset On Close=true;Max Auto Prepare=4;Auto Prepare Min Usages=1";
+            var builder = new NpgsqlDataSourceBuilder(connStr);
+            return builder.Build();
+        }
+        catch { return null; }
+    }
+
+    [ResourceMethod]
+    public async Task<ListWithCount<object>> Compute(int min = 10, int max = 50, int limit = 50)
+    {
+        if (PgDataSource == null)
+        {
+            return new ListWithCount<object>(new List<object>());
+        }
+
+        await using var cmd = PgDataSource.CreateCommand(
+            "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count FROM items WHERE price BETWEEN $1 AND $2 LIMIT $3");
+
+        cmd.Parameters.AddWithValue(min);
+        cmd.Parameters.AddWithValue(max);
+        cmd.Parameters.AddWithValue(limit);
+
+        await using var reader = await cmd.ExecuteReaderAsync();
+
+        var items = new List<object>(limit);
+
+        while (await reader.ReadAsync())
+        {
+            items.Add(new
+            {
+                id = reader.GetInt32(0),
+                name = reader.GetString(1),
+                category = reader.GetString(2),
+                price = reader.GetInt32(3),
+                quantity = reader.GetInt32(4),
+                active = reader.GetBoolean(5),
+                tags = JsonSerializer.Deserialize<List<string>>(reader.GetString(6)),
+                rating = new { score = reader.GetInt32(7), count = reader.GetInt32(8) },
+            });
+        }
+
+        return new ListWithCount<object>(items);
+    }
+
+}

frameworks/genhttp-kestrel/Tests/Baseline.cs

@@ -0,0 +1,16 @@
+using GenHTTP.Api.Protocol;
+using GenHTTP.Modules.Reflection;
+using GenHTTP.Modules.Webservices;
+
+namespace genhttp.Tests;
+
+public class Baseline
+{
+    
+    [ResourceMethod]
+    public int Sum(int a, int b) => a + b;
+    
+    [ResourceMethod(RequestMethod.Post)]
+    public int Sum(int a, int b, [FromBody] int c) => a + b + c;
+    
+}

frameworks/genhttp-kestrel/Tests/EchoHandler.cs

@@ -0,0 +1,23 @@
+using GenHTTP.Modules.Websockets;
+using GenHTTP.Modules.Websockets.Protocol;
+
+namespace genhttp.Tests;
+
+class EchoHandler : IImperativeHandler
+{
+    public async ValueTask HandleAsync(IImperativeConnection connection)
+    {
+        while (true)
+        {
+            var frame = await connection.ReadFrameAsync();
+
+            if (frame.Type == FrameType.Close)
+                break;
+
+            if (frame.Type == FrameType.Text || frame.Type == FrameType.Binary)
+            {
+                await connection.WriteAsync(frame.Data, frame.Type);
+            }
+        }
+    }
+}

frameworks/genhttp-kestrel/Tests/Json.cs

@@ -0,0 +1,60 @@
+using System.Text.Json;
+
+using GenHTTP.Api.Content;
+using GenHTTP.Api.Protocol;
+using GenHTTP.Modules.Webservices;
+
+namespace genhttp.Tests;
+
+public class Json
+{
+    private static readonly List<DatasetItem>? DatasetItems = LoadItems();
+
+    private static List<DatasetItem>? LoadItems()
+    {
+        var jsonOptions = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true,
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+        };
+
+        var datasetPath = Environment.GetEnvironmentVariable("DATASET_PATH") ?? "/data/dataset.json";
+
+        if (File.Exists(datasetPath))
+        {
+            return JsonSerializer.Deserialize<List<DatasetItem>>(File.ReadAllText(datasetPath), jsonOptions);
+        }
+
+        return null;
+    }
+
+    [ResourceMethod(":count")]
+    public ListWithCount<ProcessedItem> Compute(int count, int m = 1)
+    {
+        if (DatasetItems == null)
+        {
+            throw new ProviderException(ResponseStatus.InternalServerError, "No dataset");
+        }
+
+        if (count > DatasetItems.Count) count = DatasetItems.Count;
+        if (count < 0) count = 0;
+
+        var processed = new List<ProcessedItem>(count);
+
+        for (var i = 0; i < count; i++)
+        {
+            var d = DatasetItems[i];
+
+            processed.Add(new ProcessedItem
+            {
+                Id = d.Id, Name = d.Name, Category = d.Category,
+                Price = d.Price, Quantity = d.Quantity, Active = d.Active,
+                Tags = d.Tags, Rating = d.Rating,
+                Total = d.Price * d.Quantity * m
+            });
+        }
+
+        return new(processed);
+    }
+
+}

frameworks/genhttp-kestrel/Tests/Upload.cs

@@ -0,0 +1,38 @@
+using GenHTTP.Api.Protocol;
+using GenHTTP.Modules.Webservices;
+
+namespace genhttp.Tests;
+
+public class Upload
+{
+
+    [ResourceMethod(RequestMethod.Post)]
+    public ValueTask<long> Compute(Stream input)
+    {
+        if (input.CanSeek)
+        {
+            // internal engine
+            return ValueTask.FromResult(input.Length);
+        }
+
+        // kestrel
+        return ComputeManually(input);
+    }
+
+    private async ValueTask<long> ComputeManually(Stream input)
+    {
+        var buffer = new byte[8192];
+
+        long total = 0;
+
+        var read = 0;
+
+        while ((read = await input.ReadAsync(buffer)) > 0)
+        {
+            total += read;
+        }
+
+        return total;
+    }
+    
+}