Struct TlsListenerBuilder

pub struct TlsListenerBuilder<State> { /* private fields */ }

A builder for TlsListeners

This is created with a call to TlsListener::build. This also can be passed directly to tide::Server::listen, skipping the TlsListenerBuilder::finish call.

Examples

let listener = TlsListener::<()>::build()
    .addrs("localhost:4433")
    .cert("./tls/localhost-4433.cert")
    .key("./tls/localhost-4433.key")
    .finish();

let listener = TlsListener::<()>::build()
    .tcp(std::net::TcpListener::bind("localhost:4433").unwrap())
    .config(rustls::ServerConfig::new(rustls::NoClientAuth::new()))
    .finish();

Implementations

impl<State> TlsListenerBuilder<State>

pub fn key(self, path: impl AsRef<Path>) -> Self

Provide a path to a key file, in either pkcs8 or rsa formats. This is mutually exclusive with providing a server config with TlsListenerBuilder::config, but must be used in conjunction with TlsListenerBuilder::cert

Examples found in repository

examples/hello_tls.rs (line 24)

fn main() -> std::io::Result<()> {
    async_std::task::block_on(async {
        let mut app = tide::new();
        app.at("*").all(endpoint);
        app.at("/").all(endpoint);

        if let (Ok(cert), Ok(key)) = (env::var("TIDE_CERT"), env::var("TIDE_KEY")) {
            app.listen(
                TlsListener::build()
                    .addrs("localhost:4433")
                    .cert(cert)
                    .key(key),
            )
            .await?;
        } else {
            eprintln!(
                "
To run this app locally:
* install https://github.com/FiloSottile/mkcert
* $ mkcert -key-file key.pem -cert-file cert.pem localhost 127.0.0.1 ::1
* $ env TIDE_CERT=cert.pem TIDE_KEY=key.pem cargo run --example hello_tls
* $ curl -v https://localhost:4433/secure
"
            );
        }

        Ok(())
    })
}

pub fn cert(self, path: impl AsRef<Path>) -> Self

Provide a path to a cert file. This is mutually exclusive with providing a server config with TlsListenerBuilder::config, but must be used in conjunction with TlsListenerBuilder::key

Examples found in repository

examples/hello_tls.rs (line 23)

fn main() -> std::io::Result<()> {
    async_std::task::block_on(async {
        let mut app = tide::new();
        app.at("*").all(endpoint);
        app.at("/").all(endpoint);

        if let (Ok(cert), Ok(key)) = (env::var("TIDE_CERT"), env::var("TIDE_KEY")) {
            app.listen(
                TlsListener::build()
                    .addrs("localhost:4433")
                    .cert(cert)
                    .key(key),
            )
            .await?;
        } else {
            eprintln!(
                "
To run this app locally:
* install https://github.com/FiloSottile/mkcert
* $ mkcert -key-file key.pem -cert-file cert.pem localhost 127.0.0.1 ::1
* $ env TIDE_CERT=cert.pem TIDE_KEY=key.pem cargo run --example hello_tls
* $ curl -v https://localhost:4433/secure
"
            );
        }

        Ok(())
    })
}

pub fn config(self, config: ServerConfig) -> Self

Provide a prebuilt rustls::ServerConfig with any options. This is mutually exclusive with both TlsListenerBuilder::key and TlsListenerBuilder::cert, but provides the opportunity for more configuration choices.

pub fn tls_acceptor(self, acceptor: Arc<dyn CustomTlsAcceptor>) -> Self

Provides a custom acceptor for TLS connections. This is mutually exclusive with any of TlsListenerBuilder::key, TlsListenerBuilder::cert, and TlsListenerBuilder::config, but gives total control over accepting TLS connections, including multiplexing other streams or ALPN negotiations on the same TLS connection that tide should ignore.

pub fn tcp(self, tcp: impl Into<TcpListener>) -> Self

Provides a bound tcp listener (either async-std or std) to build this tls listener on. This is mutually exclusive with TlsListenerBuilder::addrs, but one of them is mandatory.

pub fn addrs(self, addrs: impl ToSocketAddrs) -> Self

Provides a std::net::ToSocketAddrs specification for this tls listener. This is mutually exclusive with TlsListenerBuilder::tcp but one of them is mandatory.

Examples found in repository

examples/hello_tls.rs (line 22)

fn main() -> std::io::Result<()> {
    async_std::task::block_on(async {
        let mut app = tide::new();
        app.at("*").all(endpoint);
        app.at("/").all(endpoint);

        if let (Ok(cert), Ok(key)) = (env::var("TIDE_CERT"), env::var("TIDE_KEY")) {
            app.listen(
                TlsListener::build()
                    .addrs("localhost:4433")
                    .cert(cert)
                    .key(key),
            )
            .await?;
        } else {
            eprintln!(
                "
To run this app locally:
* install https://github.com/FiloSottile/mkcert
* $ mkcert -key-file key.pem -cert-file cert.pem localhost 127.0.0.1 ::1
* $ env TIDE_CERT=cert.pem TIDE_KEY=key.pem cargo run --example hello_tls
* $ curl -v https://localhost:4433/secure
"
            );
        }

        Ok(())
    })
}

pub fn finish(self) -> Result<TlsListener<State>>

finishes building a TlsListener from this TlsListenerBuilder.

Errors

this will return an error unless all of the following conditions are met:

• either of these is provided, but not both
  • TlsListenerBuilder::tcp
  • TlsListenerBuilder::addrs
• exactly one of these is provided
  • both TlsListenerBuilder::cert AND TlsListenerBuilder::key
  • TlsListenerBuilder::config
  • TlsListenerBuilder::tls_acceptor

Trait Implementations

impl<State> Debug for TlsListenerBuilder<State>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<State> Default for TlsListenerBuilder<State>

fn default() -> Self

Returns the “default value” for a type.

impl<State: Clone + Send + Sync + 'static> ToListener<State> for TlsListenerBuilder<State>

type Listener = TlsListener<State>

What listener are we converting into?

fn to_listener(self) -> Result<Self::Listener>

Transform self into a Listener. Unless self is already bound/connected to the underlying io, converting to a listener does not initiate a connection. An Err return indicates an unsuccessful conversion to a listener, not an unsuccessful bind attempt.