Struct actix::SystemRunner

pub struct SystemRunner { /* private fields */ }

Runner that keeps a System’s event loop alive until stop message is received.

Implementations

impl SystemRunner

pub fn run(self) -> Result<(), Error>

Starts event loop and will return once System is stopped.

Examples found in repository

examples/ring.rs (line 103)

fn main() -> io::Result<()> {
    let sys = System::new();

    let (n_nodes, n_rounds) = parse_args();

    let now = SystemTime::now();

    sys.block_on(async {
        println!("Setting up {} nodes", n_nodes);
        let limit = n_nodes * n_rounds;

        let node = Node::create(move |ctx| {
            let first_addr = ctx.address();

            let mut prev_addr = Node {
                id: 1,
                limit,
                next: first_addr.recipient(),
            }
            .start();

            for id in 2..n_nodes {
                prev_addr = Node {
                    id,
                    limit,
                    next: prev_addr.recipient(),
                }
                .start();
            }

            Node {
                id: n_nodes,
                limit,
                next: prev_addr.recipient(),
            }
        });

        println!(
            "Sending start message and waiting for termination after {} messages...",
            limit
        );

        node.send(Payload(1)).await.unwrap();
    });

    sys.run().unwrap();

    match now.elapsed() {
        Ok(elapsed) => println!(
            "Time taken: {}.{:06} seconds ({} msg/second)",
            elapsed.as_secs(),
            elapsed.subsec_micros(),
            (n_nodes * n_rounds * 1000000) as u128 / elapsed.as_micros()
        ),
        Err(e) => println!("An error occurred: {:?}", e),
    }

    Ok(())
}

pub fn run_with_code(self) -> Result<i32, Error>

Runs the event loop until stopped, returning the exit code.

pub fn runtime(&self) -> &Runtime

Retrieves a reference to the underlying Actix runtime associated with this SystemRunner instance.

The Actix runtime is responsible for managing the event loop for an Actix system and executing asynchronous tasks. This method provides access to the runtime, allowing direct interaction with its features.

In a typical use case, you might need to share the same runtime between different parts of your project. For example, some components might require a [actix_rt::Runtime] to spawn tasks on the same runtime.

Example

let system_runner = actix_rt::System::new();
let actix_runtime = system_runner.runtime();

// Use the runtime to spawn an async task or perform other operations

Read more in the documentation for [actix_rt::Runtime]

Returns

An immutable reference to the [actix_rt::Runtime] instance associated with this [actix_rt::SystemRunner] instance.

Note

While this method provides an immutable reference to the Actix runtime, which is safe to share across threads, be aware that spawning blocking tasks on the Actix runtime could potentially impact system performance. This is because the Actix runtime is responsible for driving the system, and blocking tasks could delay other tasks in the run loop.

pub fn block_on<F>(&self, fut: F) -> <F as Future>::Output

where F: Future,

Runs the provided future, blocking the current thread until the future completes.

Examples found in repository

examples/ring.rs (lines 65-101)

fn main() -> io::Result<()> {
    let sys = System::new();

    let (n_nodes, n_rounds) = parse_args();

    let now = SystemTime::now();

    sys.block_on(async {
        println!("Setting up {} nodes", n_nodes);
        let limit = n_nodes * n_rounds;

        let node = Node::create(move |ctx| {
            let first_addr = ctx.address();

            let mut prev_addr = Node {
                id: 1,
                limit,
                next: first_addr.recipient(),
            }
            .start();

            for id in 2..n_nodes {
                prev_addr = Node {
                    id,
                    limit,
                    next: prev_addr.recipient(),
                }
                .start();
            }

            Node {
                id: n_nodes,
                limit,
                next: prev_addr.recipient(),
            }
        });

        println!(
            "Sending start message and waiting for termination after {} messages...",
            limit
        );

        node.send(Payload(1)).await.unwrap();
    });

    sys.run().unwrap();

    match now.elapsed() {
        Ok(elapsed) => println!(
            "Time taken: {}.{:06} seconds ({} msg/second)",
            elapsed.as_secs(),
            elapsed.subsec_micros(),
            (n_nodes * n_rounds * 1000000) as u128 / elapsed.as_micros()
        ),
        Err(e) => println!("An error occurred: {:?}", e),
    }

    Ok(())
}

Trait Implementations

impl Debug for SystemRunner

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

Formats the value using the given formatter.