Struct Delegate 

pub struct Delegate<N, C, I = ()>
where
    N: LeadershipAwareNode<I> + 'static,
    C: Config<Node = N>,
{ /* private fields */ }

Delegate decoration.

Trait Implementations

impl<N, C, I> Decoration for Delegate<N, C, I>

where N: NodeImpl + LeadershipAwareNode<I> + 'static, C: Config<Node = N> + 'static,

type Arguments = C

Arguments this decoration requires.

type Decorated = N

Type of the decorated node.

fn wrap( decorated: Self::Decorated, arguments: Self::Arguments, ) -> Result<Self, Box<dyn Error + Send + Sync + 'static>>

Wraps this decoration around the given node, using the given arguments.

fn peek_into(decorated: &Self) -> &Self::Decorated

Returns a reference to the decorated node.

fn unwrap(decorated: Self) -> Self::Decorated

Unwraps this decoration.

impl<N, C, I> Node for Delegate<N, C, I>

where N: LeadershipAwareNode<I> + NodeImpl + 'static, C: Config<Node = N> + 'static,

type Invocation = <N as Node>::Invocation

Parametrization of the paxakos algorithm.

type Shutdown = <N as Node>::Shutdown

Type that will perform graceful shutdown if requsted.

fn id(&self) -> NodeIdOf<Self>

This node’s identifier.

fn status(&self) -> NodeStatus

Node’s current status.

fn participation(&self) -> Participation<RoundNumOf<Self>>

Node’s current mode of participation.

fn poll_events(&mut self, cx: &mut Context<'_>) -> Poll<EventFor<Self>>

Polls the node’s event stream.

fn handle(&self) -> HandleFor<Self>

Returns a handle for this node.

fn prepare_snapshot(&self) -> BoxFuture<'static, SnapshotFor<Self>>

Requests that snapshot of the node’s current state be taken.

fn affirm_snapshot( &self, snapshot: SnapshotFor<Self>, ) -> BoxFuture<'static, Result<(), AffirmSnapshotError>>

Affirms that the given snapshot was written to persistent storage.

fn install_snapshot( &self, snapshot: SnapshotFor<Self>, ) -> BoxFuture<'static, Result<(), InstallSnapshotError>>

Requests that the given snapshot be installed.

fn read_stale<F, T>(&self, f: F) -> BoxFuture<'_, Result<T, Disoriented>>

where F: FnOnce(&StateOf<Self>) -> T + Send + 'static, T: Send + 'static,

Reads the node’s current state.

fn read_stale_infallibly<F, T>(&self, f: F) -> BoxFuture<'_, T>

where F: FnOnce(Option<&StateOf<Self>>) -> T + Send + 'static, T: Send + 'static,

Reads the node’s current state.

fn read_stale_scoped<'read, F, T>( &self, f: F, ) -> BoxFuture<'read, Result<T, Disoriented>>

where F: FnOnce(&StateOf<Self>) -> T + Send + 'read, T: Send + 'static,

Reads the node’s current state.

fn read_stale_scoped_infallibly<'read, F, T>(&self, f: F) -> BoxFuture<'read, T>

where F: FnOnce(Option<&StateOf<Self>>) -> T + Send + 'read, T: Send + 'static,

Reads the node’s current state.

fn append<A, P, R>( &mut self, applicable: A, args: P, ) -> BoxFuture<'static, AppendResultFor<Self, A, R>>

where A: ApplicableTo<StateOf<Self>> + 'static, P: Into<AppendArgs<Self::Invocation, R>>, R: RetryPolicy<Invocation = Self::Invocation>, R::StaticError: From<ShutDownOr<R::Error>>,

Appends applicable to the shared log.

fn shut_down(self) -> Self::Shutdown

Begins a graceful shutdown of this node.

fn next_event(&mut self) -> NextEvent<'_, Self>

Returns a future that polls this node for events until the next one is returned.

fn events(&mut self) -> Events<'_, Self>

Returns a stream that polls this node for events.

impl<N, C, I> NodeImpl for Delegate<N, C, I>

where N: NodeImpl + LeadershipAwareNode<I> + 'static, C: Config<Node = N> + 'static,

fn append_impl<A, P, R>( &mut self, applicable: A, args: P, ) -> BoxFuture<'static, ImplAppendResultFor<Self, A, R>>

where A: ApplicableTo<StateOf<Self>> + 'static, P: Into<AppendArgs<Self::Invocation, R>>, R: RetryPolicy<Invocation = Self::Invocation>,

Appends applicable to the shared log.

fn await_commit_of( &mut self, log_entry_id: LogEntryIdOf<Self>, ) -> BoxFuture<'static, Result<CommitFor<Self>, ShutDown>>

Wait for the log entry with the given ID to be committed.

fn eject( &mut self, reason: EjectionOf<Self>, ) -> BoxFuture<'static, Result<bool, ShutDown>>

Eject the node’s state.

fn poll( &mut self, round_num: RoundNumOf<Self>, additional_nodes: Vec<NodeOf<Self>>, ) -> BoxFuture<'static, Result<bool, PollError<Self::Invocation>>>

Polls the given nodes for the log entry to apply to the given round.