Struct ockam_node::Context

pub struct Context { /* fields omitted */ }

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

Signal to the local application runner to shut down

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

Shut down a worker by its primary address

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, data: TransportMessage) -> Result<()>

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<'ctx, M: Message>(
    &'ctx mut self
) -> Result<Cancel<'ctx, M>>

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<'ctx, M, F>(
    &'ctx mut self,
    check: F
) -> Result<Cancel<'ctx, 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.

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

Trait Implementations

impl Drop for Context

fn drop(&mut self)

Executes the destructor for this type.