Struct ockam_node::Context

pub struct Context { /* private fields */ }

Context contains Node state and references to the runtime.

Implementations

impl Context

pub fn runtime(&self) -> Arc<Runtime>

Return runtime clone

impl Context

pub fn address(&self) -> Address

Return the primary worker address

pub fn aliases(&self) -> AddressSet

Return all addresses of this worker

pub async fn new_context<S: Into<Address>>(&self, addr: S) -> Result<Context>

Create a new context without spawning a full worker

pub async fn start_worker<NM, NW, S>(
    &self,
    address: S,
    worker: NW
) -> Result<()> where
    S: Into<AddressSet>,
    NM: Message + Send + 'static,
    NW: Worker<Context = Context, Message = NM>, 

Start a new worker handle at Address

pub async fn start_worker_with_access_control<NM, NW, NA, S>(
    &self,
    address: S,
    worker: NW,
    access_control: NA
) -> Result<()> where
    S: Into<AddressSet>,
    NM: Message + Send + 'static,
    NW: Worker<Context = Context, Message = NM>,
    NA: AccessControl, 

TODO: Worker builder?

pub async fn start_processor<P>(
    &self,
    address: impl Into<Address>,
    processor: P
) -> Result<()> where
    P: Processor<Context = Context>, 

Start a new processor at Address

pub async fn stop_worker<A: Into<Address>>(&self, addr: A) -> Result<()>

Shut down a worker by its primary address

pub async fn stop_processor<A: Into<Address>>(&self, addr: A) -> Result<()>

Shut down a processor by its address

pub async fn stop_now(&mut self) -> Result<()>

Signal to the local runtime to shut down immediately

WARNING: calling this function may result in data loss. It is recommended to use the much safer Context::stop function instead!

pub async fn stop(&mut self) -> Result<()>

Signal to the local runtime to shut down

This call will hang until a safe shutdown has been completed. The default timeout for a safe shutdown is 1 second. You can change this behaviour by calling Context::stop_timeout directly.

pub async fn stop_timeout(&mut self, seconds: u8) -> Result<()>

Signal to the local runtime to shut down

This call will hang until a safe shutdown has been completed or the desired timeout has been reached.

pub async fn send_to_self<A, M>(&self, from: A, addr: A, msg: M) -> Result<()> where
    A: Into<Address>,
    M: Message + Send + 'static, 

Send a message to another address associated with this worker

This function is a simple wrapper around Self::send() which validates the address given to it and will reject invalid addresses.

pub async fn send<R, M>(&self, route: R, msg: M) -> Result<()> where
    R: Into<Route>,
    M: Message + Send + 'static, 

Send a message via a fully qualified route

Routes can be constructed from a set of Addresses, or via the RouteBuilder type. Routes can contain middleware router addresses, which will re-address messages that need to be handled by specific domain workers.

pub async fn send_from_address<R, M>(
    &self,
    route: R,
    msg: M,
    sending_address: Address
) -> Result<()> where
    R: Into<Route>,
    M: Message + Send + 'static, 

Send a message via a fully qualified route using specific Worker address

Routes can be constructed from a set of Addresses, or via the RouteBuilder type. Routes can contain middleware router addresses, which will re-address messages that need to be handled by specific domain workers.

pub async fn forward(&self, local_msg: LocalMessage) -> Result<()>

Forward a transport message to its next routing destination

Similar to Context::send, but taking a TransportMessage, which contains the full destination route, and calculated return route for this hop.

Note: you most likely want to use Context::send instead, unless you are writing an external router implementation for ockam node.

pub async fn receive_block<M: Message>(&mut self) -> Result<Cancel<'_, M>>

Receive a message without a timeout

pub async fn receive<M: Message>(&mut self) -> Result<Cancel<'_, M>>

Block the current worker to wait for a typed message

This function may return a Err(FailedLoadData) if the underlying worker was shut down, or Err(Timeout) if the call was waiting for longer than the default timeout. Use receive_timeout to adjust the timeout period.

Will return None if the corresponding worker has been stopped, or the underlying Node has shut down.

pub async fn receive_timeout<M: Message>(
    &mut self,
    timeout_secs: u64
) -> Result<Cancel<'_, M>>

Block to wait for a typed message, with explicit timeout

pub async fn receive_match<M, F>(&mut self, check: F) -> Result<Cancel<'_, M>> where
    M: Message,
    F: Fn(&M) -> bool, 

Block the current worker to wait for a message satisfying a conditional

Will return Err if the corresponding worker has been stopped, or the underlying node has shut down. This operation has a default timeout.

Internally this function calls receive and .cancel() in a loop until a matching message is found.

pub async fn set_cluster<S: Into<String>>(&self, label: S) -> Result<()>

Assign the current worker to a cluster

A cluster is a set of workers that should be stopped together when the node is stopped or parts of the system are reloaded. This is not to be confused with supervisors!

By adding your worker to a cluster you signal to the runtime that your worker may be depended on by other workers that should be stopped first.

Your cluster name MUST NOT start with _internals. or ockam.!

Clusters are de-allocated in reverse order of their initialisation when the node is stopped.

pub async fn list_workers(&self) -> Result<Vec<Address>>

Return a list of all available worker addresses on a node

pub async fn register<A: Into<Address>>(&self, type_: u8, addr: A) -> Result<()>

Register a router for a specific address type

pub async fn set_access_control(&mut self) -> Result<()>

Set access control for current context

pub async fn wait_for<A: Into<Address>>(&mut self, addr: A) -> Result<()>

Wait for a particular address to become “ready”

Trait Implementations

impl AsyncTryClone for Context

fn async_try_clone<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Try cloning a object and return an Err in case of failure.