Struct rama::tcp::server::TcpListener

pub struct TcpListener<S> { /* private fields */ }

A TCP socket server, listening for incoming connections once served using one of the serve methods such as TcpListener::serve.

Implementations

impl TcpListener<()>

pub fn build() -> TcpListenerBuilder<()>

Create a new TcpListenerBuilder without a state, which can be used to configure a TcpListener.

pub fn build_with_state<S>(state: S) -> TcpListenerBuilder<S>

where S: Send + Sync + 'static,

Create a new TcpListenerBuilder with the given state, which can be used to configure a TcpListener.

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

where A: ToSocketAddrs,

Creates a new TcpListener, which will be bound to the specified address.

The returned listener is ready for accepting connections.

Binding with a port number of 0 will request that the OS assigns a port to this listener. The port allocated can be queried via the local_addr method.

impl<S> TcpListener<S>

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.

pub fn ttl(&self) -> Result<u32, Error>

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl.

pub fn state(&self) -> &S

Gets a reference to the listener’s state.

impl<State> TcpListener<State>

where State: Send + Sync + 'static,

pub async fn serve<S>(self, service: S)

where S: Service<State, TcpStream>,

Serve connections from this listener with the given service.

This method will block the current listener for each incoming connection, the underlying service can choose to spawn a task to handle the accepted stream.

pub async fn serve_fn<F, T, R, O, E>(self, f: F)

where F: Factory<T, R, O, E>, R: Future<Output = Result<O, E>> + Send + Sync + 'static, O: Send + Sync + 'static, E: Send + Sync + 'static, T: FromContextRequest<State, TcpStream>,

Serve connections from this listener with the given service function.

See Self::serve for more details.

pub async fn serve_graceful<S>(self, guard: ShutdownGuard, service: S)

where S: Service<State, TcpStream>,

Serve gracefully connections from this listener with the given service.

This method does the same as Self::serve but it will respect the given rama_core::graceful::ShutdownGuard, and also pass it to the service.

pub async fn serve_fn_graceful<F, T, R, O, E>( self, guard: ShutdownGuard, service: F, )

where F: Factory<T, R, O, E>, R: Future<Output = Result<O, E>> + Send + Sync + 'static, O: Send + Sync + 'static, E: Send + Sync + 'static, T: FromContextRequest<State, TcpStream>,

Serve gracefully connections from this listener with the given service function.

See Self::serve_graceful for more details.

Trait Implementations

impl<S> Debug for TcpListener<S>

where S: Debug,

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

Formats the value using the given formatter.