Struct ockam::Context

pub struct Context { /* fields omitted */ }

Implementations

impl Context

pub fn address(&self) -> Address

Return the current context address

During initialisation and shutdown this will return the primary worker address. During message handling it will return the address the message was addressed to.

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

Start a new worker handle at Address

pub async fn stop(&'_ self) -> Result<(), Error>

Signal to the local application runner to shut down

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

Shut down a worker by its primary address

pub async fn send_message<R, M>(&'_ self, route: R, msg: M) -> Result<(), Error> 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 forward_message(
    &'_ self,
    data: TransportMessage
) -> Result<(), Error>

Forward a transport message to its next routing destination

Similar to Context::send_message, 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_message instead, unless you are writing an external router implementation for ockam node.

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

Block the current worker to wait for a typed message

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

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

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.

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

pub async fn list_workers(&'_ self) -> Result<Vec<Address, Global>, Error>

Return a list of all available worker addresses on a node

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

Register a router for a specific address type