Struct tide::listener::ConcurrentListener

pub struct ConcurrentListener<State> { /* fields omitted */ }

ConcurrentListener allows tide to listen on any number of transports simultaneously (such as tcp ports, unix sockets, or tls).

Example:

fn main() -> Result<(), std::io::Error> {
   async_std::task::block_on(async {
       tide::log::start();
       let mut app = tide::new();
       app.at("/").get(|_| async { Ok("Hello, world!") });

       let mut listener = tide::listener::ConcurrentListener::new();
       listener.add("127.0.0.1:8000")?;
       listener.add(async_std::net::TcpListener::bind("127.0.0.1:8001").await?)?;
       listener.add("http+unix://unix.socket")?;
   
       app.listen(listener).await?;
       Ok(())
   })
}

Implementations

impl<State: Clone + Send + Sync + 'static> ConcurrentListener<State>

pub fn new() -> Self

creates a new ConcurrentListener

pub fn add<L>(&mut self, listener: L) -> Result<()> where
    L: ToListener<State>, 

Adds any ToListener to this ConcurrentListener. An error result represents a failure to convert the ToListener into a Listener.

let mut listener = tide::listener::ConcurrentListener::new();
listener.add("127.0.0.1:8000")?;
listener.add(("localhost", 8001))?;
listener.add(std::net::TcpListener::bind(("localhost", 8002))?)?;

pub fn with_listener<L>(self, listener: L) -> Self where
    L: ToListener<State>, 

ConcurrentListener::with_listener allows for chained construction of a ConcurrentListener:

app.listen(
    ConcurrentListener::new()
        .with_listener("127.0.0.1:8080")
        .with_listener(async_std::net::TcpListener::bind("127.0.0.1:8081").await?),
).await?;

Trait Implementations

impl<State> Debug for ConcurrentListener<State>

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

Formats the value using the given formatter.

impl<State: Default> Default for ConcurrentListener<State>

fn default() -> ConcurrentListener<State>

Returns the "default value" for a type.

impl<State> Display for ConcurrentListener<State>

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

Formats the value using the given formatter.

impl<State> Listener<State> for ConcurrentListener<State> where
    State: Clone + Send + Sync + 'static, 

fn bind<'life0, 'async_trait>(
    &'life0 mut self,
    app: Server<State>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Bind the listener. This starts the listening process by opening the necessary network ports, but not yet accepting incoming connections. This method must be called before accept.

fn accept<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Start accepting incoming connections. This method must be called only after bind has succeeded.

fn info(&self) -> Vec<ListenInfo>

Expose information about the connection. This should always return valid data after bind has succeeded.

impl<State> ToListener<State> for ConcurrentListener<State> where
    State: Clone + Send + Sync + 'static, 

type Listener = Self

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.