Struct actix_rt::System

pub struct System { /* fields omitted */ }

System is a runtime manager.

Implementations

impl System

pub fn builder() -> Builder

Build a new system with a customized tokio runtime.

This allows to customize the runtime. See struct level docs on Builder for more information.

pub fn new<T: Into<String>>(name: T) -> SystemRunner

Create new system.

This method panics if it can not create tokio runtime

pub fn run_in_tokio<T: Into<String>>(
    name: T,
    local: &LocalSet
) -> impl Future<Output = Result<()>>

Create new system using provided tokio LocalSet.

This method panics if it can not spawn system arbiter

Note: This method uses provided LocalSet to create a System future only. All the Arbiters will be started in separate threads using their own tokio Runtimes. It means that using this method currently it is impossible to make actix-rt work in the alternative tokio Runtimes (e.g. provided by tokio_compat).

Examples

use tokio::{runtime::Runtime, task::LocalSet};
use actix_rt::System;
use futures_util::future::try_join_all;

async fn run_application() {
    let first_task = tokio::spawn(async {
        // ...
    });

    let second_task = tokio::spawn(async {
        // ...
    });

    try_join_all(vec![first_task, second_task])
        .await
        .expect("Some of the futures finished unexpectedly");
}


let runtime = tokio::runtime::Builder::new_multi_thread()
    .worker_threads(2)
    .enable_all()
    .build()
    .unwrap();


let actix_system_task = LocalSet::new();
let sys = System::run_in_tokio("actix-main-system", &actix_system_task);
actix_system_task.spawn_local(sys);

let rest_operations = run_application();
runtime.block_on(actix_system_task.run_until(rest_operations));

pub fn attach_to_tokio<Fut, R>(
    name: impl Into<String>,
    runtime: Runtime,
    rest_operations: Fut
) -> R where
    Fut: Future<Output = R>, 

Consume the provided tokio Runtime and start the System in it. This method will create a LocalSet object and occupy the current thread for the created System exclusively. All the other asynchronous tasks that should be executed as well must be aggregated into one future, provided as the last argument to this method.

Note: This method uses provided Runtime to create a System future only. All the Arbiters will be started in separate threads using their own tokio Runtimes. It means that using this method currently it is impossible to make actix-rt work in the alternative tokio Runtimes (e.g. provided by tokio_compat).

Arguments

• name: Name of the System
• runtime: A tokio Runtime to run the system in.
• rest_operations: A future to be executed in the runtime along with the System.

Examples

use tokio::runtime::Runtime;
use actix_rt::System;
use futures_util::future::try_join_all;

async fn run_application() {
    let first_task = tokio::spawn(async {
        // ...
    });

    let second_task = tokio::spawn(async {
        // ...
    });

    try_join_all(vec![first_task, second_task])
        .await
        .expect("Some of the futures finished unexpectedly");
}


let runtime = tokio::runtime::Builder::new_multi_thread()
    .worker_threads(2)
    .enable_all()
    .build()
    .unwrap();

let rest_operations = run_application();
System::attach_to_tokio("actix-main-system", runtime, rest_operations);

pub fn current() -> System

Get current running system.

pub fn is_set() -> bool

Check if current system is set, i.e., as already been started.

pub fn with_current<F, R>(f: F) -> R where
    F: FnOnce(&System) -> R, 

Execute function with system reference.

pub fn id(&self) -> usize

System id

pub fn stop(&self)

Stop the system

pub fn stop_with_code(&self, code: i32)

Stop the system with a particular exit code.

pub fn stop_on_panic(&self) -> bool

Return status of 'stop_on_panic' option which controls whether the System is stopped when an uncaught panic is thrown from a worker thread.

pub fn arbiter(&self) -> &Arbiter

System arbiter

pub fn run<F>(f: F) -> Result<()> where
    F: FnOnce(), 

This function will start tokio runtime and will finish once the System::stop() message get called. Function f get called within tokio runtime context.

Trait Implementations

impl Clone for System

pub fn clone(&self) -> System

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for System

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

Formats the value using the given formatter.