How to run servers on multiple ports simultaneously?

[joshtriplett]

I'd love to see an example showing that trillium can handle spawning HTTP servers on two different ports simultaneously, and serve different things to each.

[jbr]

I converted this issue to a discussion because there are a large number of examples that people might want, and they don't necessarily all need to be in the trillium repository. I'll throw together a gist for your request and update this answer.

Do you want one handler that responds on two different ports, or two different handlers that are running on different ports within the same binary?

[joshtriplett]

I understand. Having an example in the trillium repository is much less important to me; my primary goal was understanding that this is something trillium supports doing, and the general shape of it so I know if what I'm doing fits with trillium's model.

In an ideal world, I'd love to have three endpoints /a, /b, and /c, and two ports, one of which answers to /a and /b, and the other of which answers /a and /c. Understanding how the common bits get shared with minimal duplication would be really helpful.

[jbr]

This is definitely something trillium supports doing, and in fact as a relatively-unopinionated toolkit, there are a few different ways of doing it. I'll offer the most straightforward way to meet the constraints, but depending on how much you've simplified, it may not be the ideal solution.

use trillium::Conn;
use trillium_router::router;
use trillium_smol::{async_global_executor::block_on, config};

async fn a(conn: Conn) -> Conn {
    conn.ok("a")
}

async fn b(conn: Conn) -> Conn {
    conn.ok("b")
}

async fn c(conn: Conn) -> Conn {
    conn.ok("c")
}

fn main() {
    block_on(async {
        let leader = config()
            .with_port(8080)
            .with_host("0.0.0.0")
            .spawn(router().get("/a", a).get("/c", c));

        config()
            .without_signals() // this server doesn't manage shut down
            .with_port(8081)
            .with_host("127.0.0.1")
            .with_stopper(leader.stopper()) // shut down when the other server shuts down
            .with_observer(leader.observer()) // but not until our requests are finished too
            .spawn(router().get("/a", a).get("/b", b));

        leader.await // we could await either server handle here
    });
}

The without_signals, with_stopper and with_observer lines can be omitted if you don't care about coupling the graceful shutdown behavior of the servers, but then you'd want to race or join the two server handles at the end, depending on your needs.

Assuming the handlers are more complex than a simple function, you'd want to wrap them in an Arc in order to share between servers or implement Clone (the latter of which is preferable). Depending on the specifics, you may want to wait for the leader to start with leader.info().await in order to ensure that init is not called in two handlers simultaneously. This would be especially true for example if a shared handler were connecting to a database or something with similar external side effects.

[joshtriplett]

Thank you very much! This looks like exactly what I need.