Struct actix::System

source ·

pub struct System { /* private fields */ }

Expand description

A manager for a per-thread distributed async runtime.

Implementations§

source §

impl System

source

pub fn new() -> SystemRunner

Create a new system.

§Panics

Panics if underlying Tokio runtime can not be created.

Examples found in repository ?

examples/ring.rs (line 59)

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(())
}

source

pub fn with_tokio_rt<F>(runtime_factory: F) -> SystemRunner
where F: Fn() -> Runtime,

Create a new System using the Tokio Runtime returned from a closure.

source §

impl System

source

pub fn current() -> System

Get current running system.

§Panics

Panics if no system is registered on the current thread.

Examples found in repository ?

examples/ring.rs (line 38)

    fn handle(&mut self, msg: Payload, _: &mut Context<Self>) {
        if msg.0 >= self.limit {
            println!(
                "Actor {} reached limit of {} (payload was {})",
                self.id, self.limit, msg.0
            );

            System::current().stop();
            return;
        }

        // Some prime in order for different actors to report progress.
        // Large enough to print about once per second in debug mode.
        if msg.0 % 498989 == 1 {
            println!(
                "Actor {} received message {} of {} ({:.2}%)",
                self.id,
                msg.0,
                self.limit,
                100.0 * msg.0 as f32 / self.limit as f32
            );
        }

        self.next.do_send(Payload(msg.0 + 1));
    }

source

pub fn try_current() -> Option<System>

Try to get current running system.

Returns None if no System has been started.

Unlike current, this never panics.

source

pub fn arbiter(&self) -> &ArbiterHandle

Get handle to a the System’s initial Arbiter.

source

pub fn is_registered() -> bool

Check if there is a System registered on the current thread.

source

pub fn id(&self) -> usize

Numeric system identifier.

Useful when using multiple Systems.

source

pub fn stop(&self)

Stop the system (with code 0).

Examples found in repository ?

examples/ring.rs (line 38)

    fn handle(&mut self, msg: Payload, _: &mut Context<Self>) {
        if msg.0 >= self.limit {
            println!(
                "Actor {} reached limit of {} (payload was {})",
                self.id, self.limit, msg.0
            );

            System::current().stop();
            return;
        }

        // Some prime in order for different actors to report progress.
        // Large enough to print about once per second in debug mode.
        if msg.0 % 498989 == 1 {
            println!(
                "Actor {} received message {} of {} ({:.2}%)",
                self.id,
                msg.0,
                self.limit,
                100.0 * msg.0 as f32 / self.limit as f32
            );
        }

        self.next.do_send(Payload(msg.0 + 1));
    }