Enum actix_web::dev::Server

pub enum Server {
    Server(ServerInner),
    Error(Option<Error>),
}

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 to process stop commands and listen for OS signals. It will resolve when the server has fully shut down.

Shutdown Signals

On UNIX systems, SIGQUIT will start a graceful shutdown and SIGTERM 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
}

Variants

Server(ServerInner)

Tuple Fields

0: ServerInner

Error(Option<Error>)

Tuple Fields

0: Option<Error>

Implementations

impl Server

pub fn build() -> ServerBuilder

Create server build.

pub fn handle(&self) -> ServerHandle

Get a handle for ServerFuture that can be used to change state of actix server.

See ServerHandle for usage.

Trait Implementations

impl Future for Server

type Output = Result<(), Error>

The type of value produced on completion.

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

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