Struct Server

pub struct Server { /* private fields */ }

General purpose TCP server that runs services receiving Tokio TcpStreams.

Handles creating worker threads, restarting faulted workers, connection accepting, and back-pressure logic.

Creates a worker per CPU core (or the number specified in ServerBuilder::workers) and distributes connections with a round-robin strategy.

The Server must be awaited or polled in order to start running. It will resolve when the server has fully shut down.

Shutdown Signals

On UNIX systems, SIGTERM will start a graceful shutdown and SIGQUIT or SIGINT will start a forced shutdown. On Windows, a Ctrl-C signal will start a forced shutdown.

A graceful shutdown will wait for all workers to stop first.

Examples

The following is a TCP echo server. Test using telnet 127.0.0.1 8080.

use std::io;

use actix_rt::net::TcpStream;
use actix_server::Server;
use actix_service::{fn_service, ServiceFactoryExt as _};
use bytes::BytesMut;
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};

#[actix_rt::main]
async fn main() -> io::Result<()> {
    let bind_addr = ("127.0.0.1", 8080);

    Server::build()
        .bind("echo", bind_addr, move || {
            fn_service(move |mut stream: TcpStream| {
                async move {
                    let mut size = 0;
                    let mut buf = BytesMut::new();

                    loop {
                        match stream.read_buf(&mut buf).await {
                            // end of stream; bail from loop
                            Ok(0) => break,

                            // write bytes back to stream
                            Ok(bytes_read) => {
                                stream.write_all(&buf[size..]).await.unwrap();
                                size += bytes_read;
                            }

                            Err(err) => {
                                eprintln!("Stream Error: {:?}", err);
                                return Err(());
                            }
                        }
                    }

                    Ok(())
                }
            })
            .map_err(|err| eprintln!("Service Error: {:?}", err))
        })?
        .run()
        .await
}

Implementations

impl Server

pub fn build() -> ServerBuilder

Create server build.

pub fn handle(&self) -> ServerHandle

Get a Server handle that can be used issue commands and change it’s state.

See ServerHandle for usage.

Trait Implementations

impl Future for Server

type Output = Result<(), Error>

The type of value produced on completion.

fn poll( self: Pin<&mut Server>, cx: &mut Context<'_>, ) -> Poll<<Server as Future>::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.