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()
    .addrs("localhost:4433")
    .cert("./tls/localhost-4433.cert")
    .key("./tls/localhost-4433.key")
    .tcp_ttl(60)
    .tcp_nodelay(true)
    .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 certificate chain 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 tcp(self, tcp: impl Into<TcpListener>) -> 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. 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. 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.

If addr yields multiple addresses, bind will be attempted with each of the addresses until one succeeds and returns the listener. If none of the addresses succeed in creating a listener, the error returned from the last attempt (the last address) is returned.

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 tcp_nodelay(self, nodelay: bool) -> Self

Provides a TCP_NODELAY option for this tls listener.

pub fn tcp_ttl(self, ttl: u32) -> Self

Provides a TTL option for this tls listener, in seconds.

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.