Struct ockam_node::Context

pub struct Context { /* fields omitted */ }

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_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(&mut self) -> Result<()>

Signal to the local application runner to shut down

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 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