blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

If the node was loaded from a snapshot, advertise it in gossip (#8364) 

automerge
This commit is contained in:
Michael Vines 2020-02-20 19:53:26 -07:00 committed by GitHub
parent 2d665da3e1
commit 18fd52367e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 89 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
core/src/validator.rs
View File

@ -38,7 +38,6 @@ use solana_sdk::{
clock::{Slot, DEFAULT_SLOTS_PER_TURN}, clock::{Slot, DEFAULT_SLOTS_PER_TURN},
genesis_config::GenesisConfig, genesis_config::GenesisConfig,
hash::Hash, hash::Hash,
poh_config::PohConfig,
pubkey::Pubkey, pubkey::Pubkey,
signature::{Keypair, Signer}, signature::{Keypair, Signer},
timing::timestamp, timing::timestamp,
@ -159,14 +158,14 @@ impl Validator {
info!("creating bank..."); info!("creating bank...");
let ( let (
genesis_hash, genesis_config,
bank_forks, bank_forks,
bank_forks_info, bank_forks_info,
blockstore, blockstore,
ledger_signal_receiver, ledger_signal_receiver,
completed_slots_receiver, completed_slots_receiver,
leader_schedule_cache, leader_schedule_cache,
poh_config, snapshot_hash,
) = new_banks_from_blockstore( ) = new_banks_from_blockstore(
config.expected_genesis_hash, config.expected_genesis_hash,
ledger_path, ledger_path,
@ -196,8 +195,10 @@ impl Validator {
let validator_exit = Arc::new(RwLock::new(Some(validator_exit))); let validator_exit = Arc::new(RwLock::new(Some(validator_exit)));
node.info.wallclock = timestamp(); node.info.wallclock = timestamp();
node.info.shred_version = node.info.shred_version = compute_shred_version(
compute_shred_version(&genesis_hash, Some(&bank.hard_forks().read().unwrap())); &genesis_config.hash(),
Some(&bank.hard_forks().read().unwrap()),
);
Self::print_node_info(&node); Self::print_node_info(&node);
if let Some(expected_shred_version) = config.expected_shred_version { if let Some(expected_shred_version) = config.expected_shred_version {
@ -241,7 +242,7 @@ impl Validator {
block_commitment_cache.clone(), block_commitment_cache.clone(),
blockstore.clone(), blockstore.clone(),
cluster_info.clone(), cluster_info.clone(),
genesis_hash, genesis_config.hash(),
ledger_path, ledger_path,
storage_state.clone(), storage_state.clone(),
validator_exit.clone(), validator_exit.clone(),
@ -299,7 +300,7 @@ impl Validator {
std::thread::park(); std::thread::park();
} }
let poh_config = Arc::new(poh_config); let poh_config = Arc::new(genesis_config.poh_config);
let (mut poh_recorder, entry_receiver) = PohRecorder::new_with_clear_signal( let (mut poh_recorder, entry_receiver) = PohRecorder::new_with_clear_signal(
bank.tick_height(), bank.tick_height(),
bank.last_blockhash(), bank.last_blockhash(),
@ -343,6 +344,14 @@ impl Validator {
.set_entrypoint(entrypoint_info.clone()); .set_entrypoint(entrypoint_info.clone());
} }
// If the node was loaded from a snapshot, advertise it in gossip
if let Some(snapshot_hash) = snapshot_hash {
cluster_info
.write()
.unwrap()
.push_snapshot_hashes(vec![snapshot_hash]);
}
wait_for_supermajority(config, &bank, &cluster_info); wait_for_supermajority(config, &bank, &cluster_info);
let voting_keypair = if config.voting_disabled { let voting_keypair = if config.voting_disabled {
@ -505,20 +514,21 @@ impl Validator {
} }
} }
#[allow(clippy::type_complexity)]
fn new_banks_from_blockstore( fn new_banks_from_blockstore(
expected_genesis_hash: Option<Hash>, expected_genesis_hash: Option<Hash>,
blockstore_path: &Path, blockstore_path: &Path,
poh_verify: bool, poh_verify: bool,
config: &ValidatorConfig, config: &ValidatorConfig,
) -> ( ) -> (
Hash, GenesisConfig,
BankForks, BankForks,
Vec<BankForksInfo>, Vec<BankForksInfo>,
Blockstore, Blockstore,
Receiver<bool>, Receiver<bool>,
CompletedSlotsReceiver, CompletedSlotsReceiver,
LeaderScheduleCache, LeaderScheduleCache,
PohConfig, Option<(Slot, Hash)>,
) { ) {
let genesis_config = GenesisConfig::load(blockstore_path).unwrap_or_else(|err| { let genesis_config = GenesisConfig::load(blockstore_path).unwrap_or_else(|err| {
error!("Failed to load genesis from {:?}: {}", blockstore_path, err); error!("Failed to load genesis from {:?}: {}", blockstore_path, err);
@ -548,31 +558,32 @@ fn new_banks_from_blockstore(
..blockstore_processor::ProcessOptions::default() ..blockstore_processor::ProcessOptions::default()
}; };
let (mut bank_forks, bank_forks_info, mut leader_schedule_cache) = bank_forks_utils::load( let (mut bank_forks, bank_forks_info, mut leader_schedule_cache, snapshot_hash) =
&genesis_config, bank_forks_utils::load(
&blockstore, &genesis_config,
config.account_paths.clone(), &blockstore,
config.snapshot_config.as_ref(), config.account_paths.clone(),
process_options, config.snapshot_config.as_ref(),
) process_options,
.unwrap_or_else(|err| { )
error!("Failed to load ledger: {:?}", err); .unwrap_or_else(|err| {
std::process::exit(1); error!("Failed to load ledger: {:?}", err);
}); std::process::exit(1);
});
leader_schedule_cache.set_fixed_leader_schedule(config.fixed_leader_schedule.clone()); leader_schedule_cache.set_fixed_leader_schedule(config.fixed_leader_schedule.clone());
bank_forks.set_snapshot_config(config.snapshot_config.clone()); bank_forks.set_snapshot_config(config.snapshot_config.clone());
( (
genesis_hash, genesis_config,
bank_forks, bank_forks,
bank_forks_info, bank_forks_info,
blockstore, blockstore,
ledger_signal_receiver, ledger_signal_receiver,
completed_slots_receiver, completed_slots_receiver,
leader_schedule_cache, leader_schedule_cache,
genesis_config.poh_config, snapshot_hash,
) )
} }

12
ledger-tool/src/main.rs
View File

@ -9,7 +9,7 @@ use solana_ledger::{
bank_forks_utils, bank_forks_utils,
blockstore::Blockstore, blockstore::Blockstore,
blockstore_db::{self, Column, Database}, blockstore_db::{self, Column, Database},
blockstore_processor::{BankForksInfo, BlockstoreProcessorResult, ProcessOptions}, blockstore_processor::{BankForksInfo, ProcessOptions},
rooted_slot_iterator::RootedSlotIterator, rooted_slot_iterator::RootedSlotIterator,
shred_version::compute_shred_version, shred_version::compute_shred_version,
snapshot_utils, snapshot_utils,
@ -529,7 +529,7 @@ fn load_bank_forks(
ledger_path: &PathBuf, ledger_path: &PathBuf,
genesis_config: &GenesisConfig, genesis_config: &GenesisConfig,
process_options: ProcessOptions, process_options: ProcessOptions,
) -> BlockstoreProcessorResult { ) -> bank_forks_utils::LoadResult {
let snapshot_config = if arg_matches.is_present("no_snapshot") { let snapshot_config = if arg_matches.is_present("no_snapshot") {
None None
} else { } else {
@ -775,7 +775,7 @@ fn main() {
}; };
let genesis_config = open_genesis_config(&ledger_path); let genesis_config = open_genesis_config(&ledger_path);
match load_bank_forks(arg_matches, &ledger_path, &genesis_config, process_options) { match load_bank_forks(arg_matches, &ledger_path, &genesis_config, process_options) {
Ok((bank_forks, bank_forks_info, _leader_schedule_cache)) => { Ok((bank_forks, bank_forks_info, _leader_schedule_cache, _snapshot_hash)) => {
let bank_info = &bank_forks_info[0]; let bank_info = &bank_forks_info[0];
let bank = bank_forks[bank_info.bank_slot].clone(); let bank = bank_forks[bank_info.bank_slot].clone();
@ -849,7 +849,7 @@ fn main() {
&open_genesis_config(&ledger_path), &open_genesis_config(&ledger_path),
process_options, process_options,
) { ) {
Ok((bank_forks, bank_forks_info, _leader_schedule_cache)) => { Ok((bank_forks, bank_forks_info, _leader_schedule_cache, _snapshot_hash)) => {
let dot = graph_forks( let dot = graph_forks(
&bank_forks, &bank_forks,
&bank_forks_info, &bank_forks_info,
@ -889,7 +889,7 @@ fn main() {
}; };
let genesis_config = open_genesis_config(&ledger_path); let genesis_config = open_genesis_config(&ledger_path);
match load_bank_forks(arg_matches, &ledger_path, &genesis_config, process_options) { match load_bank_forks(arg_matches, &ledger_path, &genesis_config, process_options) {
Ok((bank_forks, _bank_forks_info, _leader_schedule_cache)) => { Ok((bank_forks, _bank_forks_info, _leader_schedule_cache, _snapshot_hash)) => {
let bank = bank_forks.get(snapshot_slot).unwrap_or_else(|| { let bank = bank_forks.get(snapshot_slot).unwrap_or_else(|| {
eprintln!("Error: Slot {} is not available", snapshot_slot); eprintln!("Error: Slot {} is not available", snapshot_slot);
exit(1); exit(1);
@ -950,7 +950,7 @@ fn main() {
}; };
let genesis_config = open_genesis_config(&ledger_path); let genesis_config = open_genesis_config(&ledger_path);
match load_bank_forks(arg_matches, &ledger_path, &genesis_config, process_options) { match load_bank_forks(arg_matches, &ledger_path, &genesis_config, process_options) {
Ok((bank_forks, bank_forks_info, _leader_schedule_cache)) => { Ok((bank_forks, bank_forks_info, _leader_schedule_cache, _snapshot_hash)) => {
let slot = dev_halt_at_slot.unwrap_or_else(|| { let slot = dev_halt_at_slot.unwrap_or_else(|| {
if bank_forks_info.len() > 1 { if bank_forks_info.len() > 1 {
eprintln!("Error: multiple forks present"); eprintln!("Error: multiple forks present");

66
ledger/src/bank_forks_utils.rs
View File

@ -1,13 +1,40 @@
use crate::{ use crate::{
bank_forks::SnapshotConfig, bank_forks::{BankForks, SnapshotConfig},
blockstore::Blockstore, blockstore::Blockstore,
blockstore_processor::{self, BlockstoreProcessorResult, ProcessOptions}, blockstore_processor::{
self, BankForksInfo, BlockstoreProcessorError, BlockstoreProcessorResult, ProcessOptions,
},
entry::VerifyRecyclers, entry::VerifyRecyclers,
leader_schedule_cache::LeaderScheduleCache,
snapshot_utils, snapshot_utils,
}; };
use log::*; use log::*;
use solana_sdk::genesis_config::GenesisConfig; use solana_sdk::{clock::Slot, genesis_config::GenesisConfig, hash::Hash};
use std::{fs, path::PathBuf, sync::Arc}; use std::{fs, path::PathBuf, result, sync::Arc};
pub type LoadResult = result::Result<
(
BankForks,
Vec<BankForksInfo>,
LeaderScheduleCache,
Option<(Slot, Hash)>,
),
BlockstoreProcessorError,
>;
fn to_loadresult(
brp: BlockstoreProcessorResult,
snapshot_hash: Option<(Slot, Hash)>,
) -> LoadResult {
brp.map(|(bank_forks, bank_forks_info, leader_schedule_cache)| {
(
bank_forks,
bank_forks_info,
leader_schedule_cache,
snapshot_hash,
)
})
}
pub fn load( pub fn load(
genesis_config: &GenesisConfig, genesis_config: &GenesisConfig,
@ -15,7 +42,7 @@ pub fn load(
account_paths: Vec<PathBuf>, account_paths: Vec<PathBuf>,
snapshot_config: Option<&SnapshotConfig>, snapshot_config: Option<&SnapshotConfig>,
process_options: ProcessOptions, process_options: ProcessOptions,
) -> BlockstoreProcessorResult { ) -> LoadResult {
if let Some(snapshot_config) = snapshot_config.as_ref() { if let Some(snapshot_config) = snapshot_config.as_ref() {
info!( info!(
"Initializing snapshot path: {:?}", "Initializing snapshot path: {:?}",
@ -43,12 +70,16 @@ pub fn load(
) )
.expect("Load from snapshot failed"); .expect("Load from snapshot failed");
return blockstore_processor::process_blockstore_from_root( let snapshot_hash = (deserialized_bank.slot(), deserialized_bank.hash());
genesis_config, return to_loadresult(
blockstore, blockstore_processor::process_blockstore_from_root(
Arc::new(deserialized_bank), genesis_config,
&process_options, blockstore,
&VerifyRecyclers::default(), Arc::new(deserialized_bank),
&process_options,
&VerifyRecyclers::default(),
),
Some(snapshot_hash),
); );
} else { } else {
info!("Snapshot package does not exist: {:?}", tar); info!("Snapshot package does not exist: {:?}", tar);
@ -58,10 +89,13 @@ pub fn load(
} }
info!("Processing ledger from genesis"); info!("Processing ledger from genesis");
blockstore_processor::process_blockstore( to_loadresult(
&genesis_config, blockstore_processor::process_blockstore(
&blockstore, &genesis_config,
account_paths, &blockstore,
process_options, account_paths,
process_options,
),
None,
) )
} }