RemoteIngress 1.0.0

RemoteIngress Client Library

A .NET client library for the Lazy Ingress (Ephemeral Debug Ingress) service.

Features

• MuxClient: A strongly-typed HTTP client to register (Serve), remove (Unserve), and list routes on a Remote Ingress instance.
• RouteRegistry: The core in-memory routing logic, decoupled from ASP.NET Core, allowing you to embed the routing logic in your own applications if needed.

Usage

MuxClient

using Rayneforge.RemoteIngress;

var http = new HttpClient();
var client = new MuxClient(http, new Uri("http://localhost:8080"), "dev-token");

// Register a route
// Maps http://ingress/api/... -> http://127.0.0.1:3000/...
var route = await client.ServeAsync("api", 3000);

// List active routes
var routes = await client.ListAsync();

// Remove a route
await client.UnserveAsync("api");

RouteRegistry

If you are building a custom ingress or need the routing logic directly:

using Rayneforge.RemoteIngress;

var registry = new RouteRegistry();

// Add a route
registry.Serve(new ServeRequest("api", 3000));

// Resolve a route
if (registry.TryGetRoute("api", out var route))
{
    Console.WriteLine($"Forward to {route.Host}:{route.Port}");
}

Building the Ingress Server

You can use RouteRegistry combined with YARP to build the full ingress server:

using System.Net;
using Rayneforge.RemoteIngress;
using Yarp.ReverseProxy.Forwarder;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpForwarder();
builder.Services.AddSingleton<RouteRegistry>();

var app = builder.Build();

var forwarder = app.Services.GetRequiredService<IHttpForwarder>();
var registry = app.Services.GetRequiredService<RouteRegistry>();
var httpClient = new HttpMessageInvoker(new SocketsHttpHandler());
var requestConfig = new ForwarderRequestConfig { ActivityTimeout = TimeSpan.FromMinutes(30) };

// --- Control Plane ---

app.MapPost("/_mux/serve", async (HttpContext ctx) =>
{
    var req = await ctx.Request.ReadFromJsonAsync<ServeRequest>();
    if (req is null) return Results.BadRequest();
    
    var entry = registry.Serve(req);
    return Results.Ok(entry);
});

app.MapDelete("/_mux/serve/{name}", (HttpContext ctx, string name) =>
{
    return registry.Unserve(name) ? Results.Ok() : Results.NotFound();
});

app.MapGet("/_mux/list", (HttpContext ctx) =>
{
    return Results.Ok(registry.List());
});

// --- Data Plane ---

app.Map("/{**catchAll}", async (HttpContext ctx) =>
{
    // Don't proxy admin paths
    if (ctx.Request.Path.StartsWithSegments("/_mux")) return;

    // Helper to extract "api" from "/api/users"
    if (!TryExtractName(ctx.Request.Path, out var name))
    {
        ctx.Response.StatusCode = 404;
        return;
    }

    if (registry.TryGetRoute(name, out var route) && route != null)
    {
        var destination = $"http://{route.Host}:{route.Port}";
        
        // Optional: Strip prefix logic
        if (route.StripPrefix)
        {
            var prefix = "/" + name;
            if (ctx.Request.Path.StartsWithSegments(prefix, out var rest))
                ctx.Request.Path = rest.HasValue ? rest : "/";
        }

        await forwarder.SendAsync(ctx, destination, httpClient, requestConfig);
    }
    else
    {
        ctx.Response.StatusCode = 404;
    }
});

app.Run();

static bool TryExtractName(PathString path, out string name)
{
    var s = path.Value ?? "";
    var parts = s.Split('/', StringSplitOptions.RemoveEmptyEntries);
    if (parts.Length == 0) { name = ""; return false; }
    name = RouteRegistry.NormalizeName(parts[0]);
    return name.Length > 0;
}