How to listen on multiple sockets?

[cmcqueen]

I'd like to know how to listen on multiple sockets. I envisage a few scenarios:

1. Listen on separate IPv4 and IPv6 addresses. Eg listen on IPv4 address 192.0.2.1 and IPv6 address 2001:db8:1:2:3:4:5:6.
2. Provide HTTP on port 80, HTTPS on port 443.
3. Provide a web site on port 80, a REST API on port 9000.

It's the 3rd option that I'm interested in right now.

How can such scenarios be set up?

[jebrosen]

Those options have a pretty wide range of solutions! Here are a few rough ideas that may help:

• Each Rocket server can only "listen" on one address. But, under some operating system versions and configurations, listening on specific addresses such as [::] listens on both IPv4 and IPv6.
• You could run multiple Rocket servers with different configurations for address/port, but with the same routes mounted.
• You could use a reverse proxy (such as HAProxy or nginx) to listen on multiple ports, redirecting them to the same (or different) web servers.
• You could run multiple Rocket servers in the same process, by using launch(). launch() returns a Future that can be spawn()ed or select!ed with other servers.
• You could run multiple Rocket servers in separate processes (e.g. separate binaries, or one binary that decides which server to run based on a command line). Sometimes this is preferable for other reasons, such as different levels of privilege between the two servers.

[cmcqueen]

Regarding the first point — On Linux with sysctl net.ipv6.bindv6only = 0, I can listen on IPv6 generic address ::, and it also accepts incoming IPv4 on the same socket. It can be done explicitly on Linux, and on Windows too, by setting socket option IPV6_V6ONLY to 0. In Rust needs code something like this, using the socket2 crate. I assume Rocket doesn't support that currently.

[vincentjorgensen]

How would I run multiple Rocket servers in the same process? Do you have an example @jebrosen ? Currently I have the HTTP site working (see below). Do I just create another #[launch] ?

#[launch]
fn rocket() -> _ {
    let port: u16 = parse_env("PORT").unwrap_or(DEFAULT_PORT);
    // let ssl_port: u16 = parse_env("SSL_PORT").unwrap_or(DEFAULT_SSL_PORT);

    let helloworld: HelloWorld = HelloWorld {
        version: parse_env("SERVICE_VERSION").unwrap_or(DEFAULT_VERSION.into()),
        zone: parse_env("ZONE").unwrap_or(DEFAULT_ZONE.into()),
        region: parse_env("REGION").unwrap_or(DEFAULT_REGION.into()),
        hostname: parse_env("HOSTNAME").unwrap_or(DEFAULT_HOSTNAME.into()),
    };

    let figment = rocket::Config::figment().merge(("port", port));

    rocket::custom(figment)
        .mount("/", routes![index])
        .mount("/", routes![healthz])
        .mount("/", routes![version])
        .manage(helloworld)
}

[vincentjorgensen]

I'm getting close!

#[rocket::main]
  async fn main() {
      // Recall that an uninspected `Error` will cause a pretty-printed panic,
      // so rest assured errors do not go undetected when using `#[launch]`.
      //    let _ = http_rocket().launch().await;
      let http_rocket = http_rocket();
      if env::var("SSL_PORT").is_ok() {
>>        http_rocket.spawn(https_rocket().launch()); // This part is very wrong
      }
      let _ = http_rocket.launch().await;
  }

  fn http_rocket() -> Rocket<Build> {
...
}
  fn https_rocket() -> Rocket<Build> {
...
}