Enum SystemMessage

pub enum SystemMessage {
    Join {
        world_id: WorldId,
        proc_id: ProcId,
        proc_message_port: PortRef<ProcMessage>,
        proc_addr: ChannelAddr,
        labels: HashMap<String, String>,
        lifecycle_mode: ProcLifecycleMode,
    },
    UpsertWorld {
        world_id: WorldId,
        shape: Shape,
        num_procs_per_host: usize,
        env: Environment,
        labels: HashMap<String, String>,
    },
    Snapshot {
        filter: SystemSnapshotFilter,
        ret: OncePortRef<SystemSnapshot>,
    },
    Stop {
        worlds: Option<Vec<WorldId>>,
        proc_timeout: Duration,
        reply_port: OncePortRef<()>,
    },
}

System messages.

Variants

Join

Join the system at the given proc id.

Fields

world_id: WorldId

The world that is being joined.

proc_id: ProcId

The proc id that is joining.

proc_message_port: PortRef<ProcMessage>

Reference to the proc actor managing the proc.

proc_addr: ChannelAddr

The channel address used to communicate with the proc.

labels: HashMap<String, String>

Arbitrary name/value pairs that can be used to identify the proc.

lifecycle_mode: ProcLifecycleMode

The lifecyle mode of the proc.

UpsertWorld

Create a new world or update an existing world.

Fields

world_id: WorldId

The world id.

shape: Shape

The shape of the world.

num_procs_per_host: usize

The number of procs per host.

env: Environment

How to spawn procs in the world.

labels: HashMap<String, String>

Arbitrary name/value pairs that can be used to identify the world.

Snapshot

Return a snapshot view of this system. Used for debugging.

Fields

filter: SystemSnapshotFilter

The filter used to filter the snapshot view.

ret: OncePortRef<SystemSnapshot>

Used to return the snapshot view to the caller.

Stop

Start the shutdown process of everything in this system. It tries to shutdown all the procs first, and then the system actor itself.

Note this shutdown sequence is best effort, yet not guaranteed. It is possible the system actor/proc might already stop, while the remote procs are still in the middle of shutting down.

Fields

worlds: Option<Vec<WorldId>>

List of worlds to stop. If provided, only the procs belonging to the list of worlds are stopped, otherwise all worlds are stopped including the system proc itself.

proc_timeout: Duration

The timeout used by ProcActor to stop the proc.

reply_port: OncePortRef<()>

Used to return success to the caller.

Trait Implementations

impl Clone for SystemMessage

fn clone(&self) -> SystemMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SystemMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SystemMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Handler<SystemMessage> for SystemActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, message: SystemMessage, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle the next M-typed message.

impl Named for SystemMessage

fn typename() -> &'static str

The globally unique type name for the type. This should typically be the fully qualified Rust name of the type.

fn typehash() -> u64

A globally unique hash for this type. TODO: actually enforce perfect hashing

fn arm(&self) -> Option<&'static str>

If the named type is an enum, this returns the name of the arm of the value self.

fn typeid() -> TypeId

The TypeId for this type. TypeIds are unique only within a binary, and should not be used for global identification.

fn port() -> u64

The globally unique port for this type. Typed ports are in the range of 1<<63..1<<64-1.

unsafe fn arm_unchecked(self_: *const ()) -> Option<&'static str>

An unsafe version of ‘arm’, accepting a pointer to the value, for use in type-erased settings.

impl PartialEq for SystemMessage

fn eq(&self, other: &SystemMessage) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SystemMessage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl RemoteHandles<SystemMessage> for SystemActor

impl StructuralPartialEq for SystemMessage