Struct hotshot_orchestrator::OrchestratorState

pub(crate) struct OrchestratorState<KEY: SignatureKey> {

    pub(crate) latest_index: u16,
    pub(crate) tmp_latest_index: u16,
    pub(crate) config: NetworkConfig<KEY>,
    pub(crate) peer_pub_ready: bool,
    pub(crate) pub_posted: HashMap<Vec<u8>, (u64, bool)>,
    pub(crate) start: bool,
    pub(crate) nodes_connected: HashSet<PeerConfig<KEY>>,
    pub(crate) bench_results: BenchResults,
    pub(crate) nodes_post_results: u64,
    pub(crate) manual_start_allowed: bool,
    pub(crate) accepting_new_keys: bool,
    pub(crate) builders: Vec<Url>,
    pub(crate) fixed_stake_table: bool,
}

The state of the orchestrator

Fields

latest_index: u16

Tracks the latest node index we have generated a configuration for

tmp_latest_index: u16

Tracks the latest temporary index we have generated for init validator’s key pair

config: NetworkConfig<KEY>

The network configuration

peer_pub_ready: bool

Whether the network configuration has been updated with all the peer’s public keys/configs

pub_posted: HashMap<Vec<u8>, (u64, bool)>

A map from public keys to (node_index, is_da).

start: bool

Whether nodes should start their HotShot instances Will be set to true once all nodes post they are ready to start

nodes_connected: HashSet<PeerConfig<KEY>>

The total nodes that have posted they are ready to start

bench_results: BenchResults

The results of the benchmarks

nodes_post_results: u64

The number of nodes that have posted their results

manual_start_allowed: bool

Whether the orchestrator can be started manually

accepting_new_keys: bool

Whether we are still accepting new keys for registration

builders: Vec<Url>

Builder address pool

fixed_stake_table: bool

whether we are using a fixed stake table, disabling public key registration

Implementations

impl<KEY: SignatureKey + 'static> OrchestratorState<KEY>

pub fn new(network_config: NetworkConfig<KEY>) -> Self

create a new OrchestratorState

pub fn output_to_csv(&self)

Output the results to a csv file according to orchestrator state

impl<KEY> OrchestratorState<KEY>

where KEY: Serialize + Clone + SignatureKey + 'static,

pub(crate) fn register_unknown( &mut self, pubkey: &mut Vec<u8>, da_requested: bool, libp2p_address: Option<Multiaddr>, libp2p_public_key: Option<PeerId>, ) -> Result<(u64, bool), ServerError>

register a node with an unknown public key. this method should be used when we don’t have a fixed stake table

pub(crate) fn register_from_list( &mut self, pubkey: &mut Vec<u8>, da_requested: bool, libp2p_address: Option<Multiaddr>, libp2p_public_key: Option<PeerId>, ) -> Result<(u64, bool), ServerError>

register a node on the fixed stake table, which was loaded at startup

Trait Implementations

impl<KEY: Clone + SignatureKey> Clone for OrchestratorState<KEY>

fn clone(&self) -> OrchestratorState<KEY>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<KEY: Default + SignatureKey> Default for OrchestratorState<KEY>

fn default() -> OrchestratorState<KEY>

Returns the “default value” for a type.

impl<KEY> OrchestratorApi<KEY> for OrchestratorState<KEY>

where KEY: Serialize + Clone + SignatureKey + 'static,

fn post_identity( &mut self, libp2p_address: Option<Multiaddr>, libp2p_public_key: Option<PeerId>, ) -> Result<u16, ServerError>

Post an identity to the orchestrator. Takes in optional arguments so others can identify us on the Libp2p network.

Errors

If we were unable to serve the request

fn post_manual_start( &mut self, password_bytes: Vec<u8>, ) -> Result<(), ServerError>

Manually start the network

fn post_getconfig( &mut self, _node_index: u16, ) -> Result<NetworkConfig<KEY>, ServerError>

post endpoint for each node’s config

fn get_tmp_node_index(&mut self) -> Result<u16, ServerError>

get endpoint for the next available temporary node index

fn register_public_key( &mut self, pubkey: &mut Vec<u8>, da_requested: bool, libp2p_address: Option<Multiaddr>, libp2p_public_key: Option<PeerId>, ) -> Result<(u64, bool), ServerError>

post endpoint for each node’s public key

fn peer_pub_ready(&self) -> Result<bool, ServerError>

post endpoint for whether or not all peers public keys are ready

fn post_config_after_peer_collected( &mut self, ) -> Result<NetworkConfig<KEY>, ServerError>

get endpoint for the network config after all peers public keys are collected

fn get_start(&self) -> Result<bool, ServerError>

get endpoint for whether or not the run has started

fn post_ready( &mut self, peer_config: &PeerConfig<KEY>, ) -> Result<(), ServerError>

A node POSTs its public key to let the orchestrator know that it is ready

fn post_run_results(&mut self, metrics: BenchResults) -> Result<(), ServerError>

post endpoint for the results of the run

fn post_builder(&mut self, builder: Url) -> Result<(), ServerError>

post endpoint for registering a builder with the orchestrator

fn get_builders(&self) -> Result<Vec<Url>, ServerError>

get endpoints for builders