Discussion
Luckily, this was enough to persuade myself not to think about this further right now, and I successfully postponed it to another day.
Yay!
Nevertheless, some progress was made: if I end up writing this, I'll use Roto for middleware. Will have to figure out how, but this feels like the right path forward.
One of the major reasons I'm thinking about this is that I'm increasingly unhappy with Caddy, and would love to replace it with something else.
I'm unhappy with Caddy is because it eats an entire core on Eru, and half a gig of resident memory to boot. I don't think that's fine. I'm okay with it, for now, because my other options are worse in other ways:
Besides, neither of them is in Rust, so embedding iocaine in either is not an option. I'd always have to pay the overhead of an external process, and some kind of IPC.
@algernon traefik can be configured nicely via nix, the rest is a bit annoying. Afaik HAProxy can do the same as traefik but with slightly more C and footguns, haven't tried the amount of footguns thoroughly for everything that isn't HTTPS proxying
@algernon I have no experience with haproxy but iirc it's configurable with lua, so ...
So I'm thinking about what I need, those needs are - in my opinion - very modest.
I don't need plugins, I don't need static file serving, I don't need container discovery, I don't need authentication, nor fastcgi, nor php, nor HTTP push, nor templates.
@algernon hmm, have you considered haproxy?
What I had in mind is a reverse proxy, built on top of iocaine, and extending its configuration.
Something like this:
acme {
// acme/LE configuration here
}
iocaine {
declare-handler nam-shub path=".../nam-shub-of-enki" {
inherits "default"
}
}
https-server main {
bind "0.0.0.0:443" http http2
use iocaine-handler=nam-shub
host "iocaine.madhouse-project.org" {
use middleware="iocaine.madhouse-project.org"
upstream "10.69.0.42:8096"
}
middleware "iocaine.madhouse-project.org" script-path="..." {
// middleware configuration
}
}
The "middleware" would be a Roto script with two functions: request_transform and response_transform. Requests & responses would be mutated by Roto, as the script sees fit.
The reason I'd use Roto here is that I'm doing a lot of rewrites and redirs, and I feel those would be easier to express in a programming language, rather than trying to do it declaratively in bespoke syntax.
My gut feeling is that using Roto here would also make it more efficient than evaluating expressions through something like CEL.
The middleware? How about this:
fn request_transform(request: Request) -> Request? {
if request.path.starts_with("/documentation/stable") {
let path = request.path
.replace_prefix("/documentation/stable", "/documentation/2")
.strip_suffix("index.html");
return redirect_found(path)
}
if request.path.starts_with("/configuration/") {
return redirect_moved(f"/documentation/2{request.path}");
}
# and so on...
Some(request)
}
Or:
fn request_transform(request: Request) -> Request? {
request
.replace_prefix("/documentation/stable", "/documentation/2)
.redirect(http.status.FOUND);
request
.move("/configuration/", "/documentation/2");
request
}
This would mutate things in-place.
Except, of course, neither of these is correct! These generate responses.
@algernon I've already decided to not pursue writing my own web server. This includes a reverse proxy. Sorry.
A space for Bonfire maintainers and contributors to communicate
