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

Move get_bank_forks() into ledger/ so its available for use by ledger-tool/ (#6720)

This commit is contained in:
Michael Vines 2019-11-04 19:10:06 -07:00 committed by GitHub
parent f54cfcdb8f
commit 4d52f47f87
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 98 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
core/src/validator.rs
View File

@ -20,10 +20,10 @@ use crate::{
};
use solana_ledger::{
bank_forks::{BankForks, SnapshotConfig},
bank_forks_utils,
blocktree::{Blocktree, CompletedSlotsReceiver},
blocktree_processor::{self, BankForksInfo},
leader_schedule_cache::LeaderScheduleCache,
snapshot_utils,
};
use solana_metrics::datapoint_info;
use solana_sdk::{
@ -37,7 +37,6 @@ use solana_sdk::{
};
use std::{
fs,
net::{IpAddr, Ipv4Addr, SocketAddr},
path::{Path, PathBuf},
process,
@ -409,67 +408,6 @@ impl Validator {
}
}
fn get_bank_forks(
genesis_block: &GenesisBlock,
blocktree: &Blocktree,
account_paths: Option<String>,
snapshot_config: Option<&SnapshotConfig>,
verify_ledger: bool,
dev_halt_at_slot: Option<Slot>,
) -> (BankForks, Vec<BankForksInfo>, LeaderScheduleCache) {
let process_options = blocktree_processor::ProcessOptions {
verify_ledger,
dev_halt_at_slot,
..blocktree_processor::ProcessOptions::default()
};
if let Some(snapshot_config) = snapshot_config.as_ref() {
info!(
"Initializing snapshot path: {:?}",
snapshot_config.snapshot_path
);
let _ = fs::remove_dir_all(&snapshot_config.snapshot_path);
fs::create_dir_all(&snapshot_config.snapshot_path)
.expect("Couldn't create snapshot directory");
let tar =
snapshot_utils::get_snapshot_tar_path(&snapshot_config.snapshot_package_output_path);
if tar.exists() {
info!("Loading snapshot package: {:?}", tar);
// Fail hard here if snapshot fails to load, don't silently continue
let deserialized_bank = snapshot_utils::bank_from_archive(
account_paths
.clone()
.expect("Account paths not present when booting from snapshot"),
&snapshot_config.snapshot_path,
&tar,
)
.expect("Load from snapshot failed");
return blocktree_processor::process_blocktree_from_root(
genesis_block,
blocktree,
Arc::new(deserialized_bank),
&process_options,
)
.expect("processing blocktree after loading snapshot failed");
} else {
info!("Snapshot package does not exist: {:?}", tar);
}
} else {
info!("Snapshots disabled");
}
info!("Processing ledger from genesis");
blocktree_processor::process_blocktree(
&genesis_block,
&blocktree,
account_paths,
process_options,
)
.expect("process_blocktree failed")
}
#[cfg(not(unix))]
fn adjust_ulimit_nofile() {}
@ -549,18 +487,25 @@ pub fn new_banks_from_blocktree(
let (blocktree, ledger_signal_receiver, completed_slots_receiver) =
Blocktree::open_with_signal(blocktree_path).expect("Failed to open ledger database");
let (mut bank_forks, bank_forks_info, leader_schedule_cache) = get_bank_forks(
let process_options = blocktree_processor::ProcessOptions {
verify_ledger,
dev_halt_at_slot,
..blocktree_processor::ProcessOptions::default()
};
let (mut bank_forks, bank_forks_info, leader_schedule_cache) = bank_forks_utils::load(
&genesis_block,
&blocktree,
account_paths,
snapshot_config.as_ref(),
verify_ledger,
dev_halt_at_slot,
);
process_options,
)
.unwrap_or_else(|err| {
error!("Failed to load ledger: {:?}", err);
std::process::exit(1);
});
if let Some(snapshot_config) = snapshot_config {
bank_forks.set_snapshot_config(snapshot_config);
}
bank_forks.set_snapshot_config(snapshot_config);
(
genesis_blockhash,

2
core/tests/bank_forks.rs
View File

@ -63,7 +63,7 @@ mod tests {
snapshot_package_output_path: PathBuf::from(snapshot_output_path.path()),
snapshot_path: PathBuf::from(snapshot_dir.path()),
};
bank_forks.set_snapshot_config(snapshot_config.clone());
bank_forks.set_snapshot_config(Some(snapshot_config.clone()));
SnapshotTestConfig {
accounts_dir,
snapshot_dir,

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

@ -1,15 +1,17 @@
use clap::{crate_description, crate_name, crate_version, value_t_or_exit, App, Arg, SubCommand};
use solana_ledger::blocktree::Blocktree;
use solana_ledger::blocktree_processor::{process_blocktree, ProcessOptions};
use solana_ledger::rooted_slot_iterator::RootedSlotIterator;
use solana_sdk::clock::Slot;
use solana_sdk::genesis_block::GenesisBlock;
use std::collections::BTreeMap;
use std::fs::File;
use std::io::{stdout, Write};
use std::path::PathBuf;
use std::process::exit;
use std::str::FromStr;
use solana_ledger::{
bank_forks_utils, blocktree::Blocktree, blocktree_processor,
rooted_slot_iterator::RootedSlotIterator,
};
use solana_sdk::{clock::Slot, genesis_block::GenesisBlock};
use std::{
collections::BTreeMap,
fs::File,
io::{stdout, Write},
path::PathBuf,
process::exit,
str::FromStr,
};
#[derive(PartialEq)]
enum LedgerOutputMethod {
@ -169,12 +171,12 @@ fn main() {
}
("verify", _) => {
println!("Verifying ledger...");
let options = ProcessOptions {
let process_options = blocktree_processor::ProcessOptions {
verify_ledger: true,
..ProcessOptions::default()
..blocktree_processor::ProcessOptions::default()
};
match process_blocktree(&genesis_block, &blocktree, None, options) {
Ok((_bank_forks, bank_forks_info, _)) => {
match bank_forks_utils::load(&genesis_block, &blocktree, None, None, process_options) {
Ok((_bank_forks, bank_forks_info, _leader_schedule_cache)) => {
println!("{:?}", bank_forks_info);
}
Err(err) => {

4
ledger/src/bank_forks.rs
View File

@ -292,8 +292,8 @@ impl BankForks {
.retain(|slot, _| slot == &root || descendants[&root].contains(slot));
}
pub fn set_snapshot_config(&mut self, snapshot_config: SnapshotConfig) {
self.snapshot_config = Some(snapshot_config);
pub fn set_snapshot_config(&mut self, snapshot_config: Option<SnapshotConfig>) {
self.snapshot_config = snapshot_config;
}
pub fn snapshot_config(&self) -> &Option<SnapshotConfig> {

62
ledger/src/bank_forks_utils.rs Normal file
View File

@ -0,0 +1,62 @@
use crate::{
bank_forks::{BankForks, SnapshotConfig},
blocktree::Blocktree,
blocktree_processor::{self, BankForksInfo, BlocktreeProcessorError, ProcessOptions},
leader_schedule_cache::LeaderScheduleCache,
snapshot_utils,
};
use log::*;
use solana_sdk::genesis_block::GenesisBlock;
use std::{fs, sync::Arc};
pub fn load(
genesis_block: &GenesisBlock,
blocktree: &Blocktree,
account_paths: Option<String>,
snapshot_config: Option<&SnapshotConfig>,
process_options: ProcessOptions,
) -> Result<(BankForks, Vec<BankForksInfo>, LeaderScheduleCache), BlocktreeProcessorError> {
if let Some(snapshot_config) = snapshot_config.as_ref() {
info!(
"Initializing snapshot path: {:?}",
snapshot_config.snapshot_path
);
let _ = fs::remove_dir_all(&snapshot_config.snapshot_path);
fs::create_dir_all(&snapshot_config.snapshot_path)
.expect("Couldn't create snapshot directory");
let tar =
snapshot_utils::get_snapshot_tar_path(&snapshot_config.snapshot_package_output_path);
if tar.exists() {
info!("Loading snapshot package: {:?}", tar);
// Fail hard here if snapshot fails to load, don't silently continue
let deserialized_bank = snapshot_utils::bank_from_archive(
account_paths
.clone()
.expect("Account paths not present when booting from snapshot"),
&snapshot_config.snapshot_path,
&tar,
)
.expect("Load from snapshot failed");
return blocktree_processor::process_blocktree_from_root(
genesis_block,
blocktree,
Arc::new(deserialized_bank),
&process_options,
);
} else {
info!("Snapshot package does not exist: {:?}", tar);
}
} else {
info!("Snapshots disabled");
}
info!("Processing ledger from genesis");
blocktree_processor::process_blocktree(
&genesis_block,
&blocktree,
account_paths,
process_options,
)
}

1
ledger/src/lib.rs
View File

@ -1,4 +1,5 @@
pub mod bank_forks;
pub mod bank_forks_utils;
pub mod block_error;
#[macro_use]
pub mod blocktree;