Struct solana_gossip::cluster_info::ClusterInfo

pub struct ClusterInfo {

    pub gossip: CrdsGossip,
    keypair: RwLock<Arc<Keypair>>,
    entrypoints: RwLock<Vec<LegacyContactInfo>>,
    outbound_budget: DataBudget,
    my_contact_info: RwLock<ContactInfo>,
    ping_cache: Mutex<PingCache>,
    stats: GossipStats,
    socket: UdpSocket,
    local_message_pending_push_queue: Mutex<Vec<CrdsValue>>,
    contact_debug_interval: u64,
    contact_save_interval: u64,
    instance: RwLock<NodeInstance>,
    contact_info_path: PathBuf,
    socket_addr_space: SocketAddrSpace,
}

Fields

gossip: CrdsGossip

The network

keypair: RwLock<Arc<Keypair>>

set the keypair that will be used to sign crds values generated. It is unset only in tests.

entrypoints: RwLock<Vec<LegacyContactInfo>>

Network entrypoints

outbound_budget: DataBudget

my_contact_info: RwLock<ContactInfo>

ping_cache: Mutex<PingCache>

stats: GossipStats

socket: UdpSocket

local_message_pending_push_queue: Mutex<Vec<CrdsValue>>

contact_debug_interval: u64

contact_save_interval: u64

instance: RwLock<NodeInstance>

contact_info_path: PathBuf

socket_addr_space: SocketAddrSpace

Implementations

impl ClusterInfo

pub fn new( contact_info: ContactInfo, keypair: Arc<Keypair>, socket_addr_space: SocketAddrSpace ) -> Self

pub fn set_contact_debug_interval(&mut self, new: u64)

pub fn socket_addr_space(&self) -> &SocketAddrSpace

fn push_self(&self)

fn refresh_push_active_set( &self, recycler: &PacketBatchRecycler, stakes: &HashMap<Pubkey, u64>, gossip_validators: Option<&HashSet<Pubkey>>, sender: &PacketBatchSender )

pub fn insert_legacy_info(&self, contact_info: LegacyContactInfo)

pub fn insert_info(&self, node: ContactInfo)

pub fn set_entrypoint(&self, entrypoint: LegacyContactInfo)

pub fn set_entrypoints(&self, entrypoints: Vec<LegacyContactInfo>)

pub fn save_contact_info(&self)

pub fn restore_contact_info( &mut self, contact_info_path: &Path, contact_save_interval: u64 )

pub fn id(&self) -> Pubkey

pub fn keypair(&self) -> RwLockReadGuard<'_, Arc<Keypair>>

pub fn set_keypair(&self, new_keypair: Arc<Keypair>)

pub fn set_tpu(&self, tpu_addr: SocketAddr) -> Result<(), ContactInfoError>

pub fn lookup_contact_info<F, Y>(&self, id: &Pubkey, map: F) -> Option<Y>where F: FnOnce(&LegacyContactInfo) -> Y,

pub fn lookup_contact_info_by_gossip_addr( &self, gossip_addr: &SocketAddr ) -> Option<LegacyContactInfo>

pub fn my_contact_info(&self) -> ContactInfo

pub fn my_shred_version(&self) -> u16

fn lookup_epoch_slots(&self, ix: EpochSlotsIndex) -> EpochSlots

pub fn rpc_info_trace(&self) -> String

pub fn contact_info_trace(&self) -> String

pub fn push_lowest_slot(&self, min: Slot)

pub fn push_epoch_slots(&self, update: &[Slot])

fn time_gossip_read_lock<'a>( &'a self, label: &'static str, counter: &'a Counter ) -> TimedGuard<'a, RwLockReadGuard<'_, Crds>>

pub fn push_message(&self, message: CrdsValue)

pub fn push_accounts_hashes(&self, accounts_hashes: Vec<(Slot, Hash)>)

pub fn push_legacy_snapshot_hashes(&self, snapshot_hashes: Vec<(Slot, Hash)>)

pub fn push_snapshot_hashes( &self, full: (Slot, Hash), incremental: Vec<(Slot, Hash)> ) -> Result<(), ClusterInfoError>

pub fn push_vote_at_index(&self, vote: Transaction, vote_index: u8)

pub fn push_vote(&self, tower: &[Slot], vote: Transaction)

pub fn refresh_vote(&self, vote: Transaction, vote_slot: Slot)

pub fn send_transaction( &self, transaction: &Transaction, tpu: Option<SocketAddr> ) -> Result<(), GossipError>

pub fn get_votes(&self, cursor: &mut Cursor) -> Vec<Transaction>

Returns votes inserted since the given cursor.

pub fn get_votes_with_labels( &self, cursor: &mut Cursor ) -> (Vec<CrdsValueLabel>, Vec<Transaction>)

Returns votes and the associated labels inserted since the given cursor.

pub fn push_duplicate_shred( &self, shred: &Shred, other_payload: &[u8] ) -> Result<(), GossipError>

pub fn get_accounts_hash_for_node<F, Y>( &self, pubkey: &Pubkey, map: F ) -> Option<Y>where F: FnOnce(&Vec<(Slot, Hash)>) -> Y,

pub fn get_legacy_snapshot_hash_for_node<F, Y>( &self, pubkey: &Pubkey, map: F ) -> Option<Y>where F: FnOnce(&Vec<(Slot, Hash)>) -> Y,

pub fn get_snapshot_hashes_for_node( &self, pubkey: &Pubkey ) -> Option<SnapshotHashes>

pub fn get_epoch_slots(&self, cursor: &mut Cursor) -> Vec<EpochSlots>

Returns epoch-slots inserted since the given cursor. Excludes entries from nodes with unkown or different shred version.

pub(crate) fn get_duplicate_shreds( &self, cursor: &mut Cursor ) -> Vec<DuplicateShred>

Returns duplicate-shreds inserted since the given cursor.

pub fn get_node_version(&self, pubkey: &Pubkey) -> Option<LegacyVersion2>

pub fn all_rpc_peers(&self) -> Vec<LegacyContactInfo>

all validators that have a valid rpc port regardless of shred_version.

pub fn all_peers(&self) -> Vec<(LegacyContactInfo, u64)>

pub fn gossip_peers(&self) -> Vec<LegacyContactInfo>

pub fn all_tvu_peers(&self) -> Vec<LegacyContactInfo>

all validators that have a valid tvu port regardless of shred_version.

pub fn tvu_peers(&self) -> Vec<LegacyContactInfo>

all validators that have a valid tvu port and are on the same shred_version.

pub fn repair_peers(&self, slot: Slot) -> Vec<LegacyContactInfo>

all tvu peers with valid gossip addrs that likely have the slot being requested

fn is_spy_node( contact_info: &LegacyContactInfo, socket_addr_space: &SocketAddrSpace ) -> bool

pub fn tpu_peers(&self) -> Vec<LegacyContactInfo>

compute broadcast table

fn insert_self(&self)

fn append_entrypoint_to_pulls( &self, thread_pool: &ThreadPool, pulls: &mut HashMap<LegacyContactInfo, Vec<CrdsFilter>> )

fn split_gossip_messages<I, T>( max_chunk_size: usize, data_feed: I ) -> impl Iterator<Item = Vec<T>>where T: Serialize + Debug, I: IntoIterator<Item = T>,

Splits an input feed of serializable data into chunks where the sum of serialized size of values within each chunk is no larger than max_chunk_size. Note: some messages cannot be contained within that size so in the worst case this returns N nested Vecs with 1 item each.

fn new_pull_requests( &self, thread_pool: &ThreadPool, gossip_validators: Option<&HashSet<Pubkey>>, stakes: &HashMap<Pubkey, u64> ) -> (Vec<(SocketAddr, Ping<[u8; 32]>)>, Vec<(SocketAddr, Protocol)>)

fn drain_push_queue(&self) -> Vec<CrdsValue>

pub fn flush_push_queue(&self)

fn new_push_requests( &self, stakes: &HashMap<Pubkey, u64> ) -> Vec<(SocketAddr, Protocol)>

fn generate_new_gossip_requests( &self, thread_pool: &ThreadPool, gossip_validators: Option<&HashSet<Pubkey>>, stakes: &HashMap<Pubkey, u64>, generate_pull_requests: bool ) -> Vec<(SocketAddr, Protocol)>

fn run_gossip( &self, thread_pool: &ThreadPool, gossip_validators: Option<&HashSet<Pubkey>>, recycler: &PacketBatchRecycler, stakes: &HashMap<Pubkey, u64>, sender: &PacketBatchSender, generate_pull_requests: bool ) -> Result<(), GossipError>

At random pick a node and try to get updated changes from them

fn process_entrypoints(&self) -> bool

fn handle_purge( &self, thread_pool: &ThreadPool, bank_forks: Option<&RwLock<BankForks>>, stakes: &HashMap<Pubkey, u64> )

fn trim_crds_table(&self, cap: usize, stakes: &HashMap<Pubkey, u64>)

pub fn gossip( self: Arc<Self>, bank_forks: Option<Arc<RwLock<BankForks>>>, sender: PacketBatchSender, gossip_validators: Option<HashSet<Pubkey>>, exit: Arc<AtomicBool> ) -> JoinHandle<()>

randomly pick a node and ask them for updates asynchronously

fn handle_batch_prune_messages( &self, messages: Vec<PruneData>, stakes: &HashMap<Pubkey, u64> )

fn handle_batch_pull_requests( &self, requests: Vec<(SocketAddr, CrdsFilter, CrdsValue)>, thread_pool: &ThreadPool, recycler: &PacketBatchRecycler, stakes: &HashMap<Pubkey, u64>, response_sender: &PacketBatchSender )

fn update_data_budget(&self, num_staked: usize) -> usize

fn check_pull_request<'a, R>( &'a self, now: Instant, rng: &'a mut R, packet_batch: &'a mut PacketBatch ) -> impl FnMut(&PullData) -> bool + 'awhere R: Rng + CryptoRng,

fn handle_pull_requests( &self, thread_pool: &ThreadPool, recycler: &PacketBatchRecycler, requests: Vec<PullData>, stakes: &HashMap<Pubkey, u64> ) -> PacketBatch

fn handle_batch_pull_responses( &self, responses: Vec<(Pubkey, Vec<CrdsValue>)>, thread_pool: &ThreadPool, stakes: &HashMap<Pubkey, u64>, epoch_duration: Duration )

fn handle_pull_response( &self, from: &Pubkey, crds_values: Vec<CrdsValue>, timeouts: &CrdsTimeouts<'_> ) -> (usize, usize, usize)

fn handle_batch_ping_messages<I>( &self, pings: I, recycler: &PacketBatchRecycler, response_sender: &PacketBatchSender )where I: IntoIterator<Item = (SocketAddr, Ping<[u8; 32]>)>,

fn handle_ping_messages<I>( &self, pings: I, recycler: &PacketBatchRecycler ) -> Option<PacketBatch>where I: IntoIterator<Item = (SocketAddr, Ping<[u8; 32]>)>,

fn handle_batch_pong_messages<I>(&self, pongs: I, now: Instant)where I: IntoIterator<Item = (SocketAddr, Pong)>,

fn handle_batch_push_messages( &self, messages: Vec<(Pubkey, Vec<CrdsValue>)>, thread_pool: &ThreadPool, recycler: &PacketBatchRecycler, stakes: &HashMap<Pubkey, u64>, response_sender: &PacketBatchSender )

fn require_stake_for_gossip(&self, stakes: &HashMap<Pubkey, u64>) -> bool

fn process_packets( &self, packets: VecDeque<(SocketAddr, Protocol)>, thread_pool: &ThreadPool, recycler: &PacketBatchRecycler, response_sender: &PacketBatchSender, stakes: &HashMap<Pubkey, u64>, _feature_set: Option<&FeatureSet>, epoch_duration: Duration, should_check_duplicate_instance: bool ) -> Result<(), GossipError>

fn run_socket_consume( &self, receiver: &PacketBatchReceiver, sender: &Sender<Vec<(SocketAddr, Protocol)>>, thread_pool: &ThreadPool ) -> Result<(), GossipError>

fn run_listen( &self, recycler: &PacketBatchRecycler, bank_forks: Option<&RwLock<BankForks>>, receiver: &Receiver<Vec<(SocketAddr, Protocol)>>, response_sender: &PacketBatchSender, thread_pool: &ThreadPool, last_print: &mut Instant, should_check_duplicate_instance: bool ) -> Result<(), GossipError>

Process messages from the network

pub(crate) fn start_socket_consume_thread( self: Arc<Self>, receiver: PacketBatchReceiver, sender: Sender<Vec<(SocketAddr, Protocol)>>, exit: Arc<AtomicBool> ) -> JoinHandle<()>

pub(crate) fn listen( self: Arc<Self>, bank_forks: Option<Arc<RwLock<BankForks>>>, requests_receiver: Receiver<Vec<(SocketAddr, Protocol)>>, response_sender: PacketBatchSender, should_check_duplicate_instance: bool, exit: Arc<AtomicBool> ) -> JoinHandle<()>

pub fn gossip_contact_info( id: Pubkey, gossip: SocketAddr, shred_version: u16 ) -> ContactInfo

pub fn gossip_node( id: Pubkey, gossip_addr: &SocketAddr, shred_version: u16 ) -> (ContactInfo, UdpSocket, Option<TcpListener>)

An alternative to Spy Node that has a valid gossip address and fully participate in Gossip.

pub fn spy_node( id: Pubkey, shred_version: u16 ) -> (ContactInfo, UdpSocket, Option<TcpListener>)

A Node with dummy ports to spy on gossip via pull requests