carte 0.5.0

Runs your apps' processes on demand behind *.localhost hostnames, one stack per git worktree
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//! The reverse proxy: accepts HTTP(S) on loopback (HTTP/2 over TLS when the
//! client offers it), asks a [`Router`] where each request goes, and forwards it
//! as HTTP/1.1 to an app on `127.0.0.1` or `::1`, or over a connection a [`Dialer`]
//! opens, including WebSocket upgrades.

mod body;
mod cookies;
mod error_page;
pub mod files;
mod forward;
mod listener;
mod router;
mod upstream;

use std::io;
use std::net::SocketAddr;
use std::sync::Arc;

pub use error_page::ErrorPage;
pub use listener::{Listener, ListenerOptions, is_loopback};
pub use router::{
    ActivityGuard, BoxFuture, Dial, Dialer, ListenerKind, Route, RouteRequest, Router,
    UpstreamError, UpstreamIo, UpstreamStream,
};

/// A router and a pool of upstream connections, shared by any number of
/// listeners.
#[derive(Clone)]
pub struct Proxy {
    shared: Arc<forward::Shared>,
}

impl Proxy {
    pub fn new(router: Arc<dyn Router>) -> Self {
        Self {
            shared: Arc::new(forward::Shared::new(router)),
        }
    }

    pub async fn bind(&self, addr: SocketAddr, options: ListenerOptions) -> io::Result<Listener> {
        let listener = tokio::net::TcpListener::bind(addr).await?;
        Ok(Listener::new(listener, options, self.shared.clone()))
    }

    /// Serves on a socket that is already bound and listening, such as one
    /// handed over by launchd or systemd.
    pub fn listen(
        &self,
        listener: std::net::TcpListener,
        options: ListenerOptions,
    ) -> io::Result<Listener> {
        listener.set_nonblocking(true)?;
        let listener = tokio::net::TcpListener::from_std(listener)?;
        Ok(Listener::new(listener, options, self.shared.clone()))
    }
}