Struct SequencerContext 

pub struct SequencerContext<P: SequencerPersistence> {
    consensus_handle: Arc<ConsensusHandle<SeqTypes, Arc<P>>>,
    persistence: Arc<P>,
    pub request_response_protocol: RequestResponseProtocol<P>,
    state_signatures: Arc<RwLock<StateSignatureMemStorage>>,
    wait_for_orchestrator: Option<(Arc<OrchestratorClient>, PeerConfig<SeqTypes>)>,
    tasks: TaskList,
    detached: bool,
    node_state: NodeState,
    network_config: NetworkConfig<SeqTypes>,
    validator_config: ValidatorConfig<SeqTypes>,
}

The sequencer context contains a consensus handle and other sequencer specific information.

Fields

consensus_handle: Arc<ConsensusHandle<SeqTypes, Arc<P>>>

persistence: Arc<P>

request_response_protocol: RequestResponseProtocol<P>

The request-response protocol

state_signatures: Arc<RwLock<StateSignatureMemStorage>>

Light client state signatures produced by the state signer task.

wait_for_orchestrator: Option<(Arc<OrchestratorClient>, PeerConfig<SeqTypes>)>

An orchestrator to wait for before starting consensus, with the peer config this node registered there.

tasks: TaskList

Background tasks to shut down when the node is dropped.

detached: bool

node_state: NodeState

network_config: NetworkConfig<SeqTypes>

validator_config: ValidatorConfig<SeqTypes>

Implementations

impl<P> SequencerContext<P>

where P: SequencerPersistence,

pub async fn init<F>( network_config: NetworkConfig<SeqTypes>, upgrade: Upgrade, validator_config: ValidatorConfig<SeqTypes>, membership_coordinator: EpochMembershipCoordinator<SeqTypes>, initializer: HotShotInitializer<SeqTypes>, anchor_view: Option<ViewNumber>, storage: Option<RequestResponseStorage>, state_catchup: ParallelStateCatchup, persistence: Arc<P>, coordinator_network: F, state_relay_server: Option<Url>, metrics: &dyn Metrics, stake_table_capacity: usize, event_consumer: impl PersistenceEventConsumer + 'static, proposal_fetcher_cfg: ProposalFetcherConfig, bootstrap_epoch_catchup_timeout: Duration, empty_block_delay: Duration, block_sizes: BTreeMap<Version, u64>, leader_trace_dir: Option<PathBuf>, ) -> Result<Self>

where F: AsyncFnOnce(UpgradeLock<SeqTypes>) -> Result<Cliquenet<SeqTypes>, NetworkError>,

fn new( consensus_handle: Arc<ConsensusHandle<SeqTypes, Arc<P>>>, persistence: Arc<P>, state_signer: StateSigner<SequencerApiVersion>, external_event_handler: ExternalEventHandler, request_response_protocol: RequestResponseProtocol<P>, node_state: NodeState, network_config: NetworkConfig<SeqTypes>, validator_config: ValidatorConfig<SeqTypes>, event_consumer: impl PersistenceEventConsumer + 'static, anchor_view: Option<ViewNumber>, proposal_fetcher_cfg: ProposalFetcherConfig, metrics: &dyn Metrics, ) -> Self

Constructor

pub fn wait_for_orchestrator( self, client: OrchestratorClient, peer_config: PeerConfig<SeqTypes>, ) -> Self

Wait for a signal from the orchestrator before starting consensus.

peer_config is what this node registered with the orchestrator. /ready posts it again, and the orchestrator equality-checks it against known_nodes_with_stake.

pub(crate) fn with_task_list(self, tasks: TaskList) -> Self

Add a list of tasks to the given context.

pub fn state_signatures(&self) -> Arc<RwLock<StateSignatureMemStorage>>

Return the light client state signatures this node has produced.

pub fn event_stream(&self) -> BoxStream<'static, CoordinatorEvent<SeqTypes>>

Stream consensus events.

pub async fn submit_transaction(&self, tx: Transaction) -> Result<()>

pub fn consensus_handle(&self) -> Arc<ConsensusHandle<SeqTypes, Arc<P>>>

pub fn validator_config(&self) -> &ValidatorConfig<SeqTypes>

pub fn upgrade_lock(&self) -> UpgradeLock<SeqTypes>

pub async fn shutdown_consensus(&self)

pub async fn decided_leaf(&self) -> Leaf2<SeqTypes>

pub async fn state(&self, view: ViewNumber) -> Option<Arc<ValidatedState>>

pub async fn decided_state(&self) -> Option<Arc<ValidatedState>>

pub fn node_id(&self) -> u64

pub fn node_state(&self) -> NodeState

pub fn persistence(&self) -> Arc<P>

pub async fn start_consensus(&self)

Start participating in consensus.

pub fn spawn( &mut self, name: impl Display, task: impl Future<Output: Debug> + Send + 'static, )

Spawn a background task attached to this context.

When this context is dropped or shut_down, background tasks will be cancelled in the reverse order that they were spawned.

pub fn spawn_short_lived( &mut self, name: impl Display, task: impl Future<Output: Debug> + Send + 'static, )

Spawn a short-lived background task attached to this context.

When this context is dropped or shut_down, background tasks will be cancelled in the reverse order that they were spawned.

The only difference between a short-lived background task and a long-lived one is how urgently logging related to the task is treated.

pub async fn shut_down(&mut self)

Stop participating in consensus.

pub async fn join(&mut self)

Wait for consensus to complete.

Under normal conditions, this function will block forever, which is a convenient way of keeping the main thread from exiting as long as there are still active background tasks. It returns once the coordinator has stopped, so a node whose coordinator died exits instead of serving its last state.

pub fn detach(&mut self)

Allow this node to continue participating in consensus even after it is dropped.

pub fn network_config(&self) -> NetworkConfig<SeqTypes>

Get the network config

Trait Implementations

impl<P> ApiContext for SequencerContext<P>

where P: SequencerPersistence,

fn consensus(&self) -> Arc<dyn ConsensusSource>

fn membership(&self) -> Arc<dyn MembershipPersistence>

fn state_certs(&self) -> Arc<dyn StateCertPersistence>

fn node_state(&self) -> NodeState

fn network_config(&self) -> NetworkConfig<SeqTypes>

fn validator_config(&self) -> Option<&ValidatorConfig<SeqTypes>>

fn state_signatures(&self) -> Option<Arc<RwLock<StateSignatureMemStorage>>>

fn light_client(&self) -> Option<Arc<NodeLightClient>>

A light client the node already runs, for the query service to fetch through.

fn request_vid_shares( &self, block_number: u64, vid_common: VidCommonQueryData<SeqTypes>, timeout: Duration, ) -> BoxFuture<'static, Result<Vec<VidShare>>>

fn with_task_list(self, tasks: TaskList) -> Self

Options::serve hands a clone of the context to the API before calling this, so the tasks attached here must be shared with that clone: TaskList is that shared handle, and dropping any clone of it aborts every task.

impl<P: Clone + SequencerPersistence> Clone for SequencerContext<P>

fn clone(&self) -> SequencerContext<P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: SequencerPersistence> Debug for SequencerContext<P>

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P: SequencerPersistence> Drop for SequencerContext<P>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.