Struct actix_net::server::Server

pub struct Server { /* private fields */ }

Server

Implementations

impl Server

pub fn new() -> Server

Create new Server instance

pub fn workers(self, num: usize) -> Self

Set number of workers to start.

By default server uses number of available logical cpu as threads count.

pub fn maxconn(self, num: usize) -> Self

Sets the maximum per-worker number of concurrent connections.

All socket listeners will stop accepting connections when this limit is reached for each worker.

By default max connections is set to a 25k per worker.

pub fn system_exit(self) -> Self

Stop actix system.

SystemExit message stops currently running system.

pub fn disable_signals(self) -> Self

Disable signal handling

pub fn shutdown_timeout(self, sec: u16) -> Self

Timeout for graceful workers shutdown in seconds.

After receiving a stop signal, workers have this much time to finish serving requests. Workers still alive after the timeout are force dropped.

By default shutdown timeout sets to 30 seconds.

pub fn configure<F>(self, f: F) -> Result<Server>where
    F: Fn(&mut ServiceConfig) -> Result<()>,

Run external configuration as part of the server building process

This function is useful for moving parts of configuration to a different module or even library.

pub fn bind<F, U, N: AsRef<str>>(
    self,
    name: N,
    addr: U,
    factory: F
) -> Result<Self>where
    F: StreamServiceFactory,
    U: ToSocketAddrs,

Add new service to server

pub fn listen<F, N: AsRef<str>>(
    self,
    name: N,
    lst: TcpListener,
    factory: F
) -> Selfwhere
    F: StreamServiceFactory,

Add new service to server

pub fn listen2<F, N: AsRef<str>>(
    self,
    name: N,
    lst: TcpListener,
    factory: F
) -> Selfwhere
    F: ServiceFactory,

Add new service to server

pub fn run(self)

Spawn new thread and start listening for incoming connections.

This method spawns new thread and starts new actix system. Other than that it is similar to start() method. This method blocks.

This methods panics if no socket addresses get bound.

use actix_web::*;

fn main() {
    Server::new().
        .service(
           HttpServer::new(|| App::new().resource("/", |r| r.h(|_| HttpResponse::Ok())))
               .bind("127.0.0.1:0")
               .expect("Can not bind to 127.0.0.1:0"))
        .run();
}

pub fn start(self) -> Addr<Server>

Starts Server Actor and returns its address

Trait Implementations

impl Actor for Server

type Context = Context<Server>

Actor execution context type

fn started(&mut self, ctx: &mut Self::Context)

Method is called when actor get polled first time.

fn stopping(&mut self, ctx: &mut Self::Context) -> Running

Method is called after an actor is in Actor::Stopping state. There could be several reasons for stopping. Context::stop get called by the actor itself. All addresses to current actor get dropped and no more evented objects left in the context.

fn stopped(&mut self, ctx: &mut Self::Context)

Method is called after an actor is stopped, it can be used to perform any needed cleanup work or spawning more actors. This is final state, after this call actor get dropped.

fn start(self) -> Addr<Self>where
    Self: Actor<Context = Context<Self>>,

Start new asynchronous actor, returns address of newly created actor.

fn start_default() -> Addr<Self>where
    Self: Actor<Context = Context<Self>> + Default,

Start new asynchronous actor, returns address of newly created actor.

fn create<F>(f: F) -> Addr<Self>where
    Self: Actor<Context = Context<Self>>,
    F: 'static + FnOnce(&mut Context<Self>) -> Self,

Use create method, if you need Context object during actor initialization.

impl Default for Server

fn default() -> Self

Returns the “default value” for a type.

impl Handler<PauseServer> for Server

type Result = ()

The type of value that this handle will return

fn handle(&mut self, _: PauseServer, _: &mut Context<Self>)

Method is called for every message received by this Actor

impl Handler<ResumeServer> for Server

type Result = ()

The type of value that this handle will return

fn handle(&mut self, _: ResumeServer, _: &mut Context<Self>)

Method is called for every message received by this Actor

impl Handler<Signal> for Server

Signals support Handle SIGINT, SIGTERM, SIGQUIT signals and stop actix system message to System actor.

type Result = ()

The type of value that this handle will return

fn handle(&mut self, msg: Signal, ctx: &mut Context<Self>)

Method is called for every message received by this Actor

impl Handler<StopServer> for Server

type Result = Response<(), ()>

The type of value that this handle will return

fn handle(&mut self, msg: StopServer, ctx: &mut Context<Self>) -> Self::Result

Method is called for every message received by this Actor