Enum StreamListener 

pub enum StreamListener {
    Unix(UnixListener),
    Tcp(TcpListener),
    OpenSsl(TcpListener, SslAcceptor, Duration),
}

ProSA socket object to handle TCP/SSL server socket

Variants

Unix(UnixListener)

Available on target_family=unix only.

Unix server socket (only on unix systems)

Tcp(TcpListener)

TCP server socket

OpenSsl(TcpListener, SslAcceptor, Duration)

Available on crate feature openssl only.

OpenSSL server socket

Implementations

impl StreamListener

pub const DEFAULT_SSL_TIMEOUT: Duration

Default SSL handshake timeout

pub fn local_addr(&self) -> Result<SocketAddr, Error>

Returns the local address that this listener is bound to.

This can be useful, for example, when binding to port 0 to figure out which port was actually bound.

use tokio::io;
use prosa::io::listener::StreamListener;
use prosa::io::SocketAddr;
use std::net::{Ipv4Addr, SocketAddrV4};

async fn accepting() -> Result<(), io::Error> {
    let stream_listener: StreamListener = StreamListener::bind("0.0.0.0:10000").await?;

    assert_eq!(stream_listener.local_addr()?,
               SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), 10000)));

    Ok(())
}

pub async fn bind<A: ToSocketAddrs>(addr: A) -> Result<StreamListener, Error>

Accept TCP connections from clients

graph LR clients[Clients] server[Server] clients -- TCP --> server

use tokio::io;
use prosa::io::listener::StreamListener;

async fn accepting() -> Result<(), io::Error> {
   let stream_listener: StreamListener = StreamListener::bind("0.0.0.0:10000").await?;

   loop {
       let (stream, addr) = stream_listener.accept().await?;

       // Handle the stream like any tokio stream
   }

   Ok(())
}

pub fn ssl_acceptor( self, ssl_acceptor: SslAcceptor, ssl_timeout: Option<Duration>, ) -> StreamListener

Set an OpenSSL acceptor to accept SSL connections from clients By default, the SSL connect timeout is 3 seconds

graph LR clients[Clients] server[Server] clients -- TLS --> server

use tokio::io;
use prosa_utils::config::ssl::{SslConfig, SslConfigContext};
use prosa::io::listener::StreamListener;

async fn accepting() -> Result<(), io::Error> {
   let ssl_acceptor = SslConfig::default().init_tls_server_context(None).unwrap().build();
   let stream_listener: StreamListener = StreamListener::bind("0.0.0.0:10000").await?.ssl_acceptor(ssl_acceptor, None);

   loop {
       // The client SSL handshake will happen here
       let (stream, addr) = stream_listener.accept().await?;

       // Handle the stream like any tokio stream
   }

   Ok(())
}

pub async fn accept(&self) -> Result<(Stream, SocketAddr), Error>

Method to accept a client after a bind

use tokio::io;
use prosa_utils::config::ssl::{SslConfig, SslConfigContext};
use prosa::io::listener::StreamListener;

async fn accepting() -> Result<(), io::Error> {
    let ssl_acceptor = SslConfig::default().init_tls_server_context(None).unwrap().build();
    let stream_listener: StreamListener = StreamListener::bind("0.0.0.0:10000").await?.ssl_acceptor(ssl_acceptor, None);

    loop {
        // The client SSL handshake will happen here
        let (stream, addr) = stream_listener.accept().await?;

        // Handle the stream like any tokio stream
    }

    Ok(())
}

pub async fn accept_raw(&self) -> Result<(Stream, SocketAddr), Error>

Method to accept a client after a bind without SSL handshake (must be done with handshake after)

use tokio::io;
use prosa_utils::config::ssl::{SslConfig, SslConfigContext};
use prosa::io::listener::StreamListener;

async fn accepting() -> Result<(), io::Error> {
    let ssl_acceptor = SslConfig::default().init_tls_server_context(None).unwrap().build();
    let stream_listener: StreamListener = StreamListener::bind("0.0.0.0:10000").await?.ssl_acceptor(ssl_acceptor, None);

    loop {
        let (stream, addr) = stream_listener.accept_raw().await?;

        // The client SSL handshake will happen here
        let stream = stream_listener.handshake(stream).await?;

        // Handle the stream like any tokio stream
    }

    Ok(())
}

pub async fn handshake(&self, stream: Stream) -> Result<Stream, Error>

Method to do an handshake with a client after an accept (Do nothing if the handshake is already done)

Trait Implementations

impl AsFd for StreamListener

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl AsRawFd for StreamListener

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for StreamListener

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

Formats the value using the given formatter.

impl Display for StreamListener

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

Formats the value using the given formatter.

impl From<TcpListener> for StreamListener

fn from(listener: TcpListener) -> Self

Converts to this type from the input type.

impl From<UnixListener> for StreamListener

Available on target_family=unix only.

fn from(listener: UnixListener) -> Self

Converts to this type from the input type.