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: Into<Option<String>>, Child>(
    &mut self,
    directory: Dir,
    child: Child
) -> ActorResult<(<Child::Channel as Channel>::Handle, InitializedRx)> where
    <A::Channel as Channel>::Handle: Clone,
    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>>,
    <A::Channel as Channel>::Handle: SupHandle<Child>, 

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: Into<Option<String>>, Child>(
    &mut self,
    directory: Dir,
    child: Child,
    channel: Child::Channel
) -> ActorResult<(<Child::Channel as Channel>::Handle, InitializedRx)> where
    <A::Channel as Channel>::Handle: Clone,
    Child: 'static + Actor<<A::Channel as Channel>::Handle>,
    Dir: Into<Option<String>>,
    <A::Channel as Channel>::Handle: SupHandle<Child>, 

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