Struct overclock::core::Rt

pub struct Rt<A: Actor<S>, S: Send> { /* private fields */ }

The actor’s local context

Implementations

impl<A: Actor<S>, S> Rt<A, S>where Self: Send, S: Send,

pub fn child<D: Into<String>>(&self, dir_name: D) -> LocateScopeId

Start traversing from the child with the provided dir name

pub fn parent(&self) -> LocateScopeId

Start traversing from the parent

pub fn sibling<D: Into<String>>(&self, dir_name: D) -> LocateScopeId

Start traversing from the sibling with the provided dir name

pub fn grandparent(&self) -> LocateScopeId

Start traversing from the grand parent

pub fn uncle<D: Into<String>>(&self, dir_name: D) -> LocateScopeId

Start traversing from the uncle

pub fn abortable<F>(&self, fut: F) -> Abortable<F> where F: Future + Send + Sync,

Create abortable future which will be aborted if the actor got shutdown signal.

pub async fn start<Dir: Into<Option<String>>, Child>( &mut self, directory: Dir, child: Child ) -> ActorResult<<Child::Channel as Channel>::Handle>where Child: 'static + Actor<<A::Channel as Channel>::Handle> + ChannelBuilder<Child::Channel>, <A::Channel as Channel>::Handle: SupHandle<Child>, Self: Send,

Spawn the provided child and await till it’s initialized

pub async fn spawn<Dir, Child>( &mut self, directory: Dir, child: Child ) -> ActorResult<(<Child::Channel as Channel>::Handle, InitializedRx)>where <A::Channel as Channel>::Handle: Clone + SupHandle<Child>, Child: 'static + ChannelBuilder<<Child as Actor<<A::Channel as Channel>::Handle>>::Channel> + Actor<<A::Channel as Channel>::Handle>, Child::Channel: Send, <Child as Actor<<A::Channel as Channel>::Handle>>::Channel: Send, Dir: Into<Option<String>>,

Spawn the child, and returns its handle and initialized rx to check if it got initialized

pub async fn start_with_channel<Dir: Into<Option<String>>, Child>( &mut self, directory: Dir, child: Child, channel: Child::Channel ) -> ActorResult<<Child::Channel as Channel>::Handle>where Child: 'static + Actor<<A::Channel as Channel>::Handle>, <A::Channel as Channel>::Handle: SupHandle<Child>, Self: Send,

Spawn the provided child and await till it’s initialized

pub async fn spawn_with_channel<Dir, Child>( &mut self, directory: Dir, child: Child, channel: Child::Channel ) -> ActorResult<(<Child::Channel as Channel>::Handle, InitializedRx)>where <A::Channel as Channel>::Handle: Clone + SupHandle<Child>, Child: 'static + Actor<<A::Channel as Channel>::Handle>, Dir: Into<Option<String>>,

Spawn the child, and returns its handle and initialized rx to check if it got initialized

pub fn upsert_microservice(&mut self, scope_id: ScopeId, service: Service)

Insert/Update microservice. Note: it will remove the children handles/joins if the provided service is stopped and store entry for it in inactive if does have directory

pub fn remove_microservice(&mut self, scope_id: ScopeId)

Remove the microservice microservice under the provided scope_id

pub fn inbox_mut(&mut self) -> &mut <A::Channel as Channel>::Inbox

Returns mutable reference to the actor’s inbox

pub fn handle_mut(&mut self) -> &mut <A::Channel as Channel>::Handle

Returns mutable reference to the actor’s handle

pub fn handle(&self) -> &<A::Channel as Channel>::Handle

Returns immutable reference to the actor’s handle

pub fn supervisor_handle_mut(&mut self) -> &mut S

Returns mutable reference to the actor’s supervisor handle

pub fn supervisor_handle(&self) -> &S

Returns immutable reference to the actor’s supervisor handle

pub fn service(&self) -> &Service

Get the local service

pub fn scope_id(&self) -> ScopeId

Return the actor’s scope id

pub fn depth(&self) -> Depth

Return the actor’s depth

pub fn parent_id(&self) -> Option<ScopeId>

Return the actor parent’s scope id

pub async fn shutdown_scope(&self, scope_id: ScopeId) -> Result<()>where Self: Send,

Shutdown the scope under the provided scope_id

pub fn microservices_stopped(&self) -> bool

Check if microservices are stopped

pub fn microservices_all(&self, are: fn(_: &Service) -> bool) -> bool

Check if all microservices are _

pub fn microservices_any(&self, is: fn(_: &Service) -> bool) -> bool

Check if any microservice is _

pub async fn shutdown_children(&mut self)

Shutdown all the children within this actor context

pub async fn shutdown_child( &mut self, child_scope_id: &ScopeId ) -> Option<JoinHandle<ActorResult<()>>>

Shutdown child using its scope_id

pub async fn shutdown_children_type<T: 'static + Actor<<A::Channel as Channel>::Handle>>( &mut self ) -> HashMap<ScopeId, JoinHandle<ActorResult<()>>>where <A::Channel as Channel>::Handle: SupHandle<T>,

Shutdown all the children of a given type within this actor context

pub async fn add_route<T: Send + 'static>(&self) -> Result<()>where <A::Channel as Channel>::Handle: Route<T>,

Add route for T

pub async fn remove_route<T: Send + 'static>(&self) -> Result<()>

Remove route of T

pub async fn send<T: Send + 'static>( &self, scope_id: ScopeId, message: T ) -> Result<()>where Self: Send + Sync,

Try to send message T, to the provided scope_i

impl<A: Actor<S>, S: SupHandle<A>> Rt<A, S>where Self: Send,

pub async fn update_status(&mut self, service_status: ServiceStatus)

Update the service status, and report to the supervisor and subscribers (if any)

pub async fn stop(&mut self)

Stop the microservices and update status to stopping

impl<A: Actor<S>, S: SupHandle<A>> Rt<A, S>

pub fn new( depth: usize, service: Service, scopes_index: usize, scope_id: ScopeId, parent_scope_id: Option<ScopeId>, sup_handle: S, handle: <A::Channel as Channel>::Handle, inbox: <A::Channel as Channel>::Inbox, abort_registration: AbortRegistration, visible_data: HashSet<TypeId> ) -> Self

Create Overclock context

pub fn register<T: Collector + Clone + 'static>( &mut self, metric: T ) -> Result<()>

Register a metric

impl<A: Actor<S>, S: SupHandle<A>> Rt<A, S>

pub async fn add_resource<T: Resource>(&mut self, resource: T)

Add exposed resource

pub async fn expose<T: Resource>(&mut self)

Expose resource as visible data

pub async fn highest_scope_id<T: Resource>(&self) -> Option<ScopeId>

Get the highest resource’s scope id (at the most top level) for a given global visiable resource

pub async fn lowest_scope_id<T: Resource>(&self) -> Option<ScopeId>

Gets the lowest resource’s scope id for a given global visiable resource

pub async fn try_borrow<'a, T: Resource, R>( &self, resource_scope_id: ScopeId, fn_once: fn(_: &T) -> R ) -> Option<R::Output>where R: Future + Send + 'static,

Try to borrow resource and invoke fn_once

pub async fn try_borrow_mut<'a, T: Resource, R>( &self, resource_scope_id: ScopeId, fn_once: fn(_: &T) -> R ) -> Option<R::Output>where R: Future + Send + 'static,

Try to borrow_mut the resource and invoke fn_once

pub async fn publish<T: Resource>(&self, resource: T)

Publish resource

pub async fn lookup<T: Resource>(&self, resource_scope_id: ScopeId) -> Option<T>

Lookup for resource T under the provider scope_id

pub async fn remove_resource<T: Resource>(&self) -> Option<T>

Remove the resource, and inform the interested dyn subscribers

pub async fn depends_on<T: Resource>( &self, resource_scope_id: ScopeId ) -> Result<T, Error>

Depends on resource T, it will await/block till the resource is available

pub async fn link<T: Resource>( &self, resource_scope_id: ScopeId, hard_link: bool ) -> Result<T, Error>

Link to resource, which will await till it’s available. NOTE: similar to depends_on, but only shutdown self actor if the resource got dropped hard_link: if shutdown the subscriber when the publisher publishes a new copy

pub async fn subscribe<T: Resource>( &self, resource_scope_id: ScopeId, resource_ref: ResourceRef ) -> Result<Option<T>, Error>where <A::Channel as Channel>::Handle: Route<Event<T>>,

Depends on dynamic Resource T