gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Reformat imports to a consistent style for imports

Browse Source 
rustfmt.toml configuration:
        imports_granularity = "One"
         group_imports = "One"
This commit is contained in:
Michael Vines
2021-12-03 09:20:02 -08:00
parent 5a7b487e3d
commit 139d15cd84
380 changed files with 6067 additions and 5293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
account-decoder/src/lib.rs
View File

@@ -17,8 +17,10 @@ pub mod validator_info;
use { use {
crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount}, crate::parse_account_data::{parse_account_data, AccountAdditionalData, ParsedAccount},
solana_sdk::{ solana_sdk::{
account::ReadableAccount, account::WritableAccount, clock::Epoch, account::{ReadableAccount, WritableAccount},
fee_calculator::FeeCalculator, pubkey::Pubkey, clock::Epoch,
fee_calculator::FeeCalculator,
pubkey::Pubkey,
}, },
std::{ std::{
io::{Read, Write}, io::{Read, Write},
@@ -202,8 +204,10 @@ fn slice_data(data: &[u8], data_slice_config: Option<UiDataSliceConfig>) -> &[u8
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_sdk::account::{Account, AccountSharedData}; super::*,
solana_sdk::account::{Account, AccountSharedData},
};
#[test] #[test]
fn test_slice_data() { fn test_slice_data() {

40
account-decoder/src/parse_account_data.rs
View File

@@ -1,17 +1,19 @@
use crate::{ use {
parse_bpf_loader::parse_bpf_upgradeable_loader, crate::{
parse_config::parse_config, parse_bpf_loader::parse_bpf_upgradeable_loader,
parse_nonce::parse_nonce, parse_config::parse_config,
parse_stake::parse_stake, parse_nonce::parse_nonce,
parse_sysvar::parse_sysvar, parse_stake::parse_stake,
parse_token::{parse_token, spl_token_id}, parse_sysvar::parse_sysvar,
parse_vote::parse_vote, parse_token::{parse_token, spl_token_id},
parse_vote::parse_vote,
},
inflector::Inflector,
serde_json::Value,
solana_sdk::{instruction::InstructionError, pubkey::Pubkey, stake, system_program, sysvar},
std::collections::HashMap,
thiserror::Error,
}; };
use inflector::Inflector;
use serde_json::Value;
use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, stake, system_program, sysvar};
use std::collections::HashMap;
use thiserror::Error;
lazy_static! { lazy_static! {
static ref BPF_UPGRADEABLE_LOADER_PROGRAM_ID: Pubkey = solana_sdk::bpf_loader_upgradeable::id(); static ref BPF_UPGRADEABLE_LOADER_PROGRAM_ID: Pubkey = solana_sdk::bpf_loader_upgradeable::id();
@@ -112,12 +114,14 @@ pub fn parse_account_data(
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_sdk::nonce::{ super::*,
state::{Data, Versions}, solana_sdk::nonce::{
State, state::{Data, Versions},
State,
},
solana_vote_program::vote_state::{VoteState, VoteStateVersions},
}; };
use solana_vote_program::vote_state::{VoteState, VoteStateVersions};
#[test] #[test]
fn test_parse_account_data() { fn test_parse_account_data() {

16
account-decoder/src/parse_bpf_loader.rs
View File

@@ -1,9 +1,11 @@
use crate::{ use {
parse_account_data::{ParsableAccount, ParseAccountError}, crate::{
UiAccountData, UiAccountEncoding, parse_account_data::{ParsableAccount, ParseAccountError},
UiAccountData, UiAccountEncoding,
},
bincode::{deserialize, serialized_size},
solana_sdk::{bpf_loader_upgradeable::UpgradeableLoaderState, pubkey::Pubkey},
}; };
use bincode::{deserialize, serialized_size};
use solana_sdk::{bpf_loader_upgradeable::UpgradeableLoaderState, pubkey::Pubkey};
pub fn parse_bpf_upgradeable_loader( pub fn parse_bpf_upgradeable_loader(
data: &[u8], data: &[u8],
@@ -90,9 +92,7 @@ pub struct UiProgramData {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {super::*, bincode::serialize, solana_sdk::pubkey::Pubkey};
use bincode::serialize;
use solana_sdk::pubkey::Pubkey;
#[test] #[test]
fn test_parse_bpf_upgradeable_loader_accounts() { fn test_parse_bpf_upgradeable_loader_accounts() {

29
account-decoder/src/parse_config.rs
View File

@@ -1,12 +1,16 @@
use crate::{ use {
parse_account_data::{ParsableAccount, ParseAccountError}, crate::{
validator_info, parse_account_data::{ParsableAccount, ParseAccountError},
validator_info,
},
bincode::deserialize,
serde_json::Value,
solana_config_program::{get_config_data, ConfigKeys},
solana_sdk::{
pubkey::Pubkey,
stake::config::{self as stake_config, Config as StakeConfig},
},
}; };
use bincode::deserialize;
use serde_json::Value;
use solana_config_program::{get_config_data, ConfigKeys};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::stake::config::{self as stake_config, Config as StakeConfig};
pub fn parse_config(data: &[u8], pubkey: &Pubkey) -> Result<ConfigAccountType, ParseAccountError> { pub fn parse_config(data: &[u8], pubkey: &Pubkey) -> Result<ConfigAccountType, ParseAccountError> {
let parsed_account = if pubkey == &stake_config::id() { let parsed_account = if pubkey == &stake_config::id() {
@@ -87,11 +91,10 @@ pub struct UiConfig<T> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use crate::validator_info::ValidatorInfo; super::*, crate::validator_info::ValidatorInfo, serde_json::json,
use serde_json::json; solana_config_program::create_config_account, solana_sdk::account::ReadableAccount,
use solana_config_program::create_config_account; };
use solana_sdk::account::ReadableAccount;
#[test] #[test]
fn test_parse_config() { fn test_parse_config() {

26
account-decoder/src/parse_nonce.rs
View File

@@ -1,7 +1,9 @@
use crate::{parse_account_data::ParseAccountError, UiFeeCalculator}; use {
use solana_sdk::{ crate::{parse_account_data::ParseAccountError, UiFeeCalculator},
instruction::InstructionError, solana_sdk::{
nonce::{state::Versions, State}, instruction::InstructionError,
nonce::{state::Versions, State},
},
}; };
pub fn parse_nonce(data: &[u8]) -> Result<UiNonceState, ParseAccountError> { pub fn parse_nonce(data: &[u8]) -> Result<UiNonceState, ParseAccountError> {
@@ -42,14 +44,16 @@ pub struct UiNonceData {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_sdk::{ super::*,
hash::Hash, solana_sdk::{
nonce::{ hash::Hash,
state::{Data, Versions}, nonce::{
State, state::{Data, Versions},
State,
},
pubkey::Pubkey,
}, },
pubkey::Pubkey,
}; };
#[test] #[test]

19
account-decoder/src/parse_stake.rs
View File

@@ -1,10 +1,14 @@
use crate::{ use {
parse_account_data::{ParsableAccount, ParseAccountError}, crate::{
StringAmount, parse_account_data::{ParsableAccount, ParseAccountError},
StringAmount,
},
bincode::deserialize,
solana_sdk::{
clock::{Epoch, UnixTimestamp},
stake::state::{Authorized, Delegation, Lockup, Meta, Stake, StakeState},
},
}; };
use bincode::deserialize;
use solana_sdk::clock::{Epoch, UnixTimestamp};
use solana_sdk::stake::state::{Authorized, Delegation, Lockup, Meta, Stake, StakeState};
pub fn parse_stake(data: &[u8]) -> Result<StakeAccountType, ParseAccountError> { pub fn parse_stake(data: &[u8]) -> Result<StakeAccountType, ParseAccountError> {
let stake_state: StakeState = deserialize(data) let stake_state: StakeState = deserialize(data)
@@ -132,8 +136,7 @@ impl From<Delegation> for UiDelegation {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {super::*, bincode::serialize};
use bincode::serialize;
#[test] #[test]
fn test_parse_stake() { fn test_parse_stake() {

42
account-decoder/src/parse_sysvar.rs
View File

@@ -1,18 +1,20 @@
use crate::{ use {
parse_account_data::{ParsableAccount, ParseAccountError}, crate::{
StringAmount, UiFeeCalculator, parse_account_data::{ParsableAccount, ParseAccountError},
}; StringAmount, UiFeeCalculator,
use bincode::deserialize; },
use bv::BitVec; bincode::deserialize,
use solana_sdk::{ bv::BitVec,
clock::{Clock, Epoch, Slot, UnixTimestamp}, solana_sdk::{
epoch_schedule::EpochSchedule, clock::{Clock, Epoch, Slot, UnixTimestamp},
pubkey::Pubkey, epoch_schedule::EpochSchedule,
rent::Rent, pubkey::Pubkey,
slot_hashes::SlotHashes, rent::Rent,
slot_history::{self, SlotHistory}, slot_hashes::SlotHashes,
stake_history::{StakeHistory, StakeHistoryEntry}, slot_history::{self, SlotHistory},
sysvar::{self, fees::Fees, recent_blockhashes::RecentBlockhashes, rewards::Rewards}, stake_history::{StakeHistory, StakeHistoryEntry},
sysvar::{self, fees::Fees, recent_blockhashes::RecentBlockhashes, rewards::Rewards},
},
}; };
pub fn parse_sysvar(data: &[u8], pubkey: &Pubkey) -> Result<SysvarAccountType, ParseAccountError> { pub fn parse_sysvar(data: &[u8], pubkey: &Pubkey) -> Result<SysvarAccountType, ParseAccountError> {
@@ -212,10 +214,12 @@ pub struct UiStakeHistoryEntry {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_sdk::{ super::*,
account::create_account_for_test, fee_calculator::FeeCalculator, hash::Hash, solana_sdk::{
sysvar::recent_blockhashes::IterItem, account::create_account_for_test, fee_calculator::FeeCalculator, hash::Hash,
sysvar::recent_blockhashes::IterItem,
},
}; };
#[test] #[test]

22
account-decoder/src/parse_token.rs
View File

@@ -1,15 +1,17 @@
use crate::{ use {
parse_account_data::{ParsableAccount, ParseAccountError}, crate::{
StringAmount, StringDecimals, parse_account_data::{ParsableAccount, ParseAccountError},
}; StringAmount, StringDecimals,
use solana_sdk::pubkey::Pubkey;
use spl_token::{
solana_program::{
program_option::COption, program_pack::Pack, pubkey::Pubkey as SplTokenPubkey,
}, },
state::{Account, AccountState, Mint, Multisig}, solana_sdk::pubkey::Pubkey,
spl_token::{
solana_program::{
program_option::COption, program_pack::Pack, pubkey::Pubkey as SplTokenPubkey,
},
state::{Account, AccountState, Mint, Multisig},
},
std::str::FromStr,
}; };
use std::str::FromStr;
// A helper function to convert spl_token::id() as spl_sdk::pubkey::Pubkey to // A helper function to convert spl_token::id() as spl_sdk::pubkey::Pubkey to
// solana_sdk::pubkey::Pubkey // solana_sdk::pubkey::Pubkey

15
account-decoder/src/parse_vote.rs
View File

@@ -1,9 +1,11 @@
use crate::{parse_account_data::ParseAccountError, StringAmount}; use {
use solana_sdk::{ crate::{parse_account_data::ParseAccountError, StringAmount},
clock::{Epoch, Slot}, solana_sdk::{
pubkey::Pubkey, clock::{Epoch, Slot},
pubkey::Pubkey,
},
solana_vote_program::vote_state::{BlockTimestamp, Lockout, VoteState},
}; };
use solana_vote_program::vote_state::{BlockTimestamp, Lockout, VoteState};
pub fn parse_vote(data: &[u8]) -> Result<VoteAccountType, ParseAccountError> { pub fn parse_vote(data: &[u8]) -> Result<VoteAccountType, ParseAccountError> {
let mut vote_state = VoteState::deserialize(data).map_err(ParseAccountError::from)?; let mut vote_state = VoteState::deserialize(data).map_err(ParseAccountError::from)?;
@@ -121,8 +123,7 @@ struct UiEpochCredits {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {super::*, solana_vote_program::vote_state::VoteStateVersions};
use solana_vote_program::vote_state::VoteStateVersions;
#[test] #[test]
fn test_parse_vote() { fn test_parse_vote() {

22
accounts-bench/src/main.rs
View File

@@ -1,17 +1,19 @@
#![allow(clippy::integer_arithmetic)] #![allow(clippy::integer_arithmetic)]
#[macro_use] #[macro_use]
extern crate log; extern crate log;
use clap::{crate_description, crate_name, value_t, App, Arg}; use {
use rayon::prelude::*; clap::{crate_description, crate_name, value_t, App, Arg},
use solana_measure::measure::Measure; rayon::prelude::*,
use solana_runtime::{ solana_measure::measure::Measure,
accounts::{create_test_accounts, update_accounts_bench, Accounts}, solana_runtime::{
accounts_db::AccountShrinkThreshold, accounts::{create_test_accounts, update_accounts_bench, Accounts},
accounts_index::AccountSecondaryIndexes, accounts_db::AccountShrinkThreshold,
ancestors::Ancestors, accounts_index::AccountSecondaryIndexes,
ancestors::Ancestors,
},
solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey},
std::{env, fs, path::PathBuf},
}; };
use solana_sdk::{genesis_config::ClusterType, pubkey::Pubkey};
use std::{env, fs, path::PathBuf};
fn main() { fn main() {
solana_logger::setup(); solana_logger::setup();

78
accounts-cluster-bench/src/main.rs
View File

@@ -1,36 +1,38 @@
#![allow(clippy::integer_arithmetic)] #![allow(clippy::integer_arithmetic)]
use clap::{crate_description, crate_name, value_t, values_t_or_exit, App, Arg}; use {
use log::*; clap::{crate_description, crate_name, value_t, values_t_or_exit, App, Arg},
use rand::{thread_rng, Rng}; log::*,
use rayon::prelude::*; rand::{thread_rng, Rng},
use solana_account_decoder::parse_token::spl_token_pubkey; rayon::prelude::*,
use solana_clap_utils::input_parsers::pubkey_of; solana_account_decoder::parse_token::spl_token_pubkey,
use solana_client::rpc_client::RpcClient; solana_clap_utils::input_parsers::pubkey_of,
use solana_faucet::faucet::{request_airdrop_transaction, FAUCET_PORT}; solana_client::rpc_client::RpcClient,
use solana_gossip::gossip_service::discover; solana_faucet::faucet::{request_airdrop_transaction, FAUCET_PORT},
use solana_measure::measure::Measure; solana_gossip::gossip_service::discover,
use solana_runtime::inline_spl_token; solana_measure::measure::Measure,
use solana_sdk::{ solana_runtime::inline_spl_token,
commitment_config::CommitmentConfig, solana_sdk::{
message::Message, commitment_config::CommitmentConfig,
pubkey::Pubkey, message::Message,
rpc_port::DEFAULT_RPC_PORT, pubkey::Pubkey,
signature::{read_keypair_file, Keypair, Signature, Signer}, rpc_port::DEFAULT_RPC_PORT,
system_instruction, system_program, signature::{read_keypair_file, Keypair, Signature, Signer},
timing::timestamp, system_instruction, system_program,
transaction::Transaction, timing::timestamp,
}; transaction::Transaction,
use solana_streamer::socket::SocketAddrSpace; },
use solana_transaction_status::parse_token::spl_token_instruction; solana_streamer::socket::SocketAddrSpace,
use std::{ solana_transaction_status::parse_token::spl_token_instruction,
net::SocketAddr, std::{
process::exit, net::SocketAddr,
sync::{ process::exit,
atomic::{AtomicBool, AtomicU64, Ordering}, sync::{
Arc, RwLock, atomic::{AtomicBool, AtomicU64, Ordering},
Arc, RwLock,
},
thread::{sleep, Builder, JoinHandle},
time::{Duration, Instant},
}, },
thread::{sleep, Builder, JoinHandle},
time::{Duration, Instant},
}; };
// Create and close messages both require 2 signatures; if transaction construction changes, update // Create and close messages both require 2 signatures; if transaction construction changes, update
@@ -701,13 +703,15 @@ fn main() {
#[cfg(test)] #[cfg(test)]
pub mod test { pub mod test {
use super::*; use {
use solana_core::validator::ValidatorConfig; super::*,
use solana_local_cluster::{ solana_core::validator::ValidatorConfig,
local_cluster::{ClusterConfig, LocalCluster}, solana_local_cluster::{
validator_configs::make_identical_validator_configs, local_cluster::{ClusterConfig, LocalCluster},
validator_configs::make_identical_validator_configs,
},
solana_sdk::poh_config::PohConfig,
}; };
use solana_sdk::poh_config::PohConfig;
#[test] #[test]
fn test_accounts_cluster_bench() { fn test_accounts_cluster_bench() {

1
accountsdb-plugin-postgres/src/accountsdb_plugin_postgres.rs
View File

@@ -1,5 +1,4 @@
use solana_measure::measure::Measure; use solana_measure::measure::Measure;
/// Main entry for the PostgreSQL plugin /// Main entry for the PostgreSQL plugin
use { use {
crate::{ crate::{

65
banking-bench/src/main.rs
View File

@@ -1,36 +1,37 @@
#![allow(clippy::integer_arithmetic)] #![allow(clippy::integer_arithmetic)]
use clap::{crate_description, crate_name, value_t, App, Arg}; use {
use crossbeam_channel::unbounded; clap::{crate_description, crate_name, value_t, App, Arg},
use log::*; crossbeam_channel::unbounded,
use rand::{thread_rng, Rng}; log::*,
use rayon::prelude::*; rand::{thread_rng, Rng},
use solana_core::banking_stage::BankingStage; rayon::prelude::*,
use solana_gossip::{cluster_info::ClusterInfo, cluster_info::Node}; solana_core::banking_stage::BankingStage,
use solana_ledger::{ solana_gossip::cluster_info::{ClusterInfo, Node},
blockstore::Blockstore, solana_ledger::{
genesis_utils::{create_genesis_config, GenesisConfigInfo}, blockstore::Blockstore,
get_tmp_ledger_path, genesis_utils::{create_genesis_config, GenesisConfigInfo},
}; get_tmp_ledger_path,
use solana_measure::measure::Measure; },
use solana_perf::packet::to_packets_chunked; solana_measure::measure::Measure,
use solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry}; solana_perf::packet::to_packets_chunked,
use solana_runtime::{ solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry},
accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks, solana_runtime::{
cost_model::CostModel, accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
}; cost_model::CostModel,
use solana_sdk::{ },
hash::Hash, solana_sdk::{
signature::Keypair, hash::Hash,
signature::Signature, signature::{Keypair, Signature},
system_transaction, system_transaction,
timing::{duration_as_us, timestamp}, timing::{duration_as_us, timestamp},
transaction::Transaction, transaction::Transaction,
}; },
use solana_streamer::socket::SocketAddrSpace; solana_streamer::socket::SocketAddrSpace,
use std::{ std::{
sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex, RwLock}, sync::{atomic::Ordering, mpsc::Receiver, Arc, Mutex, RwLock},
thread::sleep, thread::sleep,
time::{Duration, Instant}, time::{Duration, Instant},
},
}; };
fn check_txs( fn check_txs(

79
banks-client/src/lib.rs
View File

@@ -5,37 +5,38 @@
//! but they are undocumented, may change over time, and are generally more //! but they are undocumented, may change over time, and are generally more
//! cumbersome to use. //! cumbersome to use.
use borsh::BorshDeserialize;
use futures::{future::join_all, Future, FutureExt};
pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus}; pub use solana_banks_interface::{BanksClient as TarpcClient, TransactionStatus};
use solana_banks_interface::{BanksRequest, BanksResponse}; use {
use solana_program::{ borsh::BorshDeserialize,
clock::Clock, futures::{future::join_all, Future, FutureExt},
clock::Slot, solana_banks_interface::{BanksRequest, BanksResponse},
fee_calculator::FeeCalculator, solana_program::{
hash::Hash, clock::{Clock, Slot},
program_pack::Pack, fee_calculator::FeeCalculator,
pubkey::Pubkey, hash::Hash,
rent::Rent, program_pack::Pack,
sysvar::{self, Sysvar}, pubkey::Pubkey,
rent::Rent,
sysvar::{self, Sysvar},
},
solana_sdk::{
account::{from_account, Account},
commitment_config::CommitmentLevel,
signature::Signature,
transaction::{self, Transaction},
transport,
},
std::io::{self, Error, ErrorKind},
tarpc::{
client::{self, channel::RequestDispatch, NewClient},
context::{self, Context},
rpc::{ClientMessage, Response},
serde_transport::tcp,
Transport,
},
tokio::{net::ToSocketAddrs, time::Duration},
tokio_serde::formats::Bincode,
}; };
use solana_sdk::{
account::{from_account, Account},
commitment_config::CommitmentLevel,
signature::Signature,
transaction::{self, Transaction},
transport,
};
use std::io::{self, Error, ErrorKind};
use tarpc::{
client::{self, channel::RequestDispatch, NewClient},
context::{self, Context},
rpc::{ClientMessage, Response},
serde_transport::tcp,
Transport,
};
use tokio::{net::ToSocketAddrs, time::Duration};
use tokio_serde::formats::Bincode;
// This exists only for backward compatibility // This exists only for backward compatibility
pub trait BanksClientExt {} pub trait BanksClientExt {}
@@ -348,16 +349,18 @@ pub async fn start_tcp_client<T: ToSocketAddrs>(addr: T) -> io::Result<BanksClie
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_banks_server::banks_server::start_local_server; super::*,
use solana_runtime::{ solana_banks_server::banks_server::start_local_server,
bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache, solana_runtime::{
genesis_utils::create_genesis_config, bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache,
genesis_utils::create_genesis_config,
},
solana_sdk::{message::Message, signature::Signer, system_instruction},
std::sync::{Arc, RwLock},
tarpc::transport,
tokio::{runtime::Runtime, time::sleep},
}; };
use solana_sdk::{message::Message, signature::Signer, system_instruction};
use std::sync::{Arc, RwLock};
use tarpc::transport;
use tokio::{runtime::Runtime, time::sleep};
#[test] #[test]
fn test_banks_client_new() { fn test_banks_client_new() {

28
banks-interface/src/lib.rs
View File

@@ -1,13 +1,15 @@
use serde::{Deserialize, Serialize}; use {
use solana_sdk::{ serde::{Deserialize, Serialize},
account::Account, solana_sdk::{
clock::Slot, account::Account,
commitment_config::CommitmentLevel, clock::Slot,
fee_calculator::FeeCalculator, commitment_config::CommitmentLevel,
hash::Hash, fee_calculator::FeeCalculator,
pubkey::Pubkey, hash::Hash,
signature::Signature, pubkey::Pubkey,
transaction::{self, Transaction, TransactionError}, signature::Signature,
transaction::{self, Transaction, TransactionError},
},
}; };
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -47,8 +49,10 @@ pub trait Banks {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use tarpc::{client, transport}; super::*,
tarpc::{client, transport},
};
#[test] #[test]
fn test_banks_client_new() { fn test_banks_client_new() {

78
banks-server/src/banks_server.rs
View File

@@ -1,43 +1,45 @@
use crate::send_transaction_service::{SendTransactionService, TransactionInfo}; use {
use bincode::{deserialize, serialize}; crate::send_transaction_service::{SendTransactionService, TransactionInfo},
use futures::{ bincode::{deserialize, serialize},
future, futures::{
prelude::stream::{self, StreamExt}, future,
}; prelude::stream::{self, StreamExt},
use solana_banks_interface::{
Banks, BanksRequest, BanksResponse, TransactionConfirmationStatus, TransactionStatus,
};
use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache};
use solana_sdk::{
account::Account,
clock::Slot,
commitment_config::CommitmentLevel,
feature_set::FeatureSet,
fee_calculator::FeeCalculator,
hash::Hash,
pubkey::Pubkey,
signature::Signature,
transaction::{self, Transaction},
};
use std::{
io,
net::{Ipv4Addr, SocketAddr},
sync::{
mpsc::{channel, Receiver, Sender},
Arc, RwLock,
}, },
thread::Builder, solana_banks_interface::{
time::Duration, Banks, BanksRequest, BanksResponse, TransactionConfirmationStatus, TransactionStatus,
},
solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache},
solana_sdk::{
account::Account,
clock::Slot,
commitment_config::CommitmentLevel,
feature_set::FeatureSet,
fee_calculator::FeeCalculator,
hash::Hash,
pubkey::Pubkey,
signature::Signature,
transaction::{self, Transaction},
},
std::{
io,
net::{Ipv4Addr, SocketAddr},
sync::{
mpsc::{channel, Receiver, Sender},
Arc, RwLock,
},
thread::Builder,
time::Duration,
},
tarpc::{
context::Context,
rpc::{transport::channel::UnboundedChannel, ClientMessage, Response},
serde_transport::tcp,
server::{self, Channel, Handler},
transport,
},
tokio::time::sleep,
tokio_serde::formats::Bincode,
}; };
use tarpc::{
context::Context,
rpc::{transport::channel::UnboundedChannel, ClientMessage, Response},
serde_transport::tcp,
server::{self, Channel, Handler},
transport,
};
use tokio::time::sleep;
use tokio_serde::formats::Bincode;
#[derive(Clone)] #[derive(Clone)]
struct BanksServer { struct BanksServer {

33
banks-server/src/rpc_banks_service.rs
View File

@@ -1,21 +1,23 @@
//! The `rpc_banks_service` module implements the Solana Banks RPC API. //! The `rpc_banks_service` module implements the Solana Banks RPC API.
use crate::banks_server::start_tcp_server; use {
use futures::{future::FutureExt, pin_mut, prelude::stream::StreamExt, select}; crate::banks_server::start_tcp_server,
use solana_runtime::{bank_forks::BankForks, commitment::BlockCommitmentCache}; futures::{future::FutureExt, pin_mut, prelude::stream::StreamExt, select},
use std::{ solana_runtime::{bank_forks::BankForks, commitment::BlockCommitmentCache},
net::SocketAddr, std::{
sync::{ net::SocketAddr,
atomic::{AtomicBool, Ordering}, sync::{
Arc, RwLock, atomic::{AtomicBool, Ordering},
Arc, RwLock,
},
thread::{self, Builder, JoinHandle},
}, },
thread::{self, Builder, JoinHandle}, tokio::{
runtime::Runtime,
time::{self, Duration},
},
tokio_stream::wrappers::IntervalStream,
}; };
use tokio::{
runtime::Runtime,
time::{self, Duration},
};
use tokio_stream::wrappers::IntervalStream;
pub struct RpcBanksService { pub struct RpcBanksService {
thread_hdl: JoinHandle<()>, thread_hdl: JoinHandle<()>,
@@ -101,8 +103,7 @@ impl RpcBanksService {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {super::*, solana_runtime::bank::Bank};
use solana_runtime::bank::Bank;
#[test] #[test]
fn test_rpc_banks_server_exit() { fn test_rpc_banks_server_exit() {

38
banks-server/src/send_transaction_service.rs
View File

@@ -1,17 +1,19 @@
// TODO: Merge this implementation with the one at `core/src/send_transaction_service.rs` // TODO: Merge this implementation with the one at `core/src/send_transaction_service.rs`
use log::*; use {
use solana_metrics::{datapoint_warn, inc_new_counter_info}; log::*,
use solana_runtime::{bank::Bank, bank_forks::BankForks}; solana_metrics::{datapoint_warn, inc_new_counter_info},
use solana_sdk::signature::Signature; solana_runtime::{bank::Bank, bank_forks::BankForks},
use std::{ solana_sdk::signature::Signature,
collections::HashMap, std::{
net::{SocketAddr, UdpSocket}, collections::HashMap,
sync::{ net::{SocketAddr, UdpSocket},
mpsc::{Receiver, RecvTimeoutError}, sync::{
Arc, RwLock, mpsc::{Receiver, RecvTimeoutError},
Arc, RwLock,
},
thread::{self, Builder, JoinHandle},
time::{Duration, Instant},
}, },
thread::{self, Builder, JoinHandle},
time::{Duration, Instant},
}; };
/// Maximum size of the transaction queue /// Maximum size of the transaction queue
@@ -183,12 +185,14 @@ impl SendTransactionService {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_sdk::{ super::*,
genesis_config::create_genesis_config, pubkey::Pubkey, signature::Signer, solana_sdk::{
system_transaction, genesis_config::create_genesis_config, pubkey::Pubkey, signature::Signer,
system_transaction,
},
std::sync::mpsc::channel,
}; };
use std::sync::mpsc::channel;
#[test] #[test]
fn service_exit() { fn service_exit() {

74
bench-exchange/src/bench.rs
View File

@@ -1,43 +1,45 @@
#![allow(clippy::useless_attribute)] #![allow(clippy::useless_attribute)]
#![allow(clippy::integer_arithmetic)] #![allow(clippy::integer_arithmetic)]
use crate::order_book::*; use {
use itertools::izip; crate::order_book::*,
use log::*; itertools::izip,
use rand::{thread_rng, Rng}; log::*,
use rayon::prelude::*; rand::{thread_rng, Rng},
use solana_client::perf_utils::{sample_txs, SampleStats}; rayon::prelude::*,
use solana_core::gen_keys::GenKeys; solana_client::perf_utils::{sample_txs, SampleStats},
use solana_exchange_program::{exchange_instruction, exchange_state::*, id}; solana_core::gen_keys::GenKeys,
use solana_faucet::faucet::request_airdrop_transaction; solana_exchange_program::{exchange_instruction, exchange_state::*, id},
use solana_genesis::Base64Account; solana_faucet::faucet::request_airdrop_transaction,
use solana_metrics::datapoint_info; solana_genesis::Base64Account,
use solana_sdk::{ solana_metrics::datapoint_info,
client::{Client, SyncClient}, solana_sdk::{
commitment_config::CommitmentConfig, client::{Client, SyncClient},
message::Message, commitment_config::CommitmentConfig,
pubkey::Pubkey, message::Message,
signature::{Keypair, Signer}, pubkey::Pubkey,
timing::{duration_as_ms, duration_as_s}, signature::{Keypair, Signer},
transaction::Transaction, system_instruction, system_program,
{system_instruction, system_program}, timing::{duration_as_ms, duration_as_s},
}; transaction::Transaction,
use std::{ },
cmp, std::{
collections::{HashMap, VecDeque}, cmp,
fs::File, collections::{HashMap, VecDeque},
io::prelude::*, fs::File,
mem, io::prelude::*,
net::SocketAddr, mem,
path::Path, net::SocketAddr,
process::exit, path::Path,
sync::{ process::exit,
atomic::{AtomicBool, AtomicUsize, Ordering}, sync::{
mpsc::{channel, Receiver, Sender}, atomic::{AtomicBool, AtomicUsize, Ordering},
Arc, RwLock, mpsc::{channel, Receiver, Sender},
Arc, RwLock,
},
thread::{sleep, Builder},
time::{Duration, Instant},
}, },
thread::{sleep, Builder},
time::{Duration, Instant},
}; };
// TODO Chunk length as specified results in a bunch of failures, divide by 10 helps... // TODO Chunk length as specified results in a bunch of failures, divide by 10 helps...

14
bench-exchange/src/cli.rs
View File

@@ -1,10 +1,10 @@
use clap::{crate_description, crate_name, value_t, App, Arg, ArgMatches}; use {
use solana_core::gen_keys::GenKeys; clap::{crate_description, crate_name, value_t, App, Arg, ArgMatches},
use solana_faucet::faucet::FAUCET_PORT; solana_core::gen_keys::GenKeys,
use solana_sdk::signature::{read_keypair_file, Keypair}; solana_faucet::faucet::FAUCET_PORT,
use std::net::SocketAddr; solana_sdk::signature::{read_keypair_file, Keypair},
use std::process::exit; std::{net::SocketAddr, process::exit, time::Duration},
use std::time::Duration; };
pub struct Config { pub struct Config {
pub entrypoint_addr: SocketAddr, pub entrypoint_addr: SocketAddr,

12
bench-exchange/src/main.rs
View File

@@ -3,11 +3,13 @@ pub mod bench;
mod cli; mod cli;
pub mod order_book; pub mod order_book;
use crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config}; use {
use log::*; crate::bench::{airdrop_lamports, create_client_accounts_file, do_bench_exchange, Config},
use solana_gossip::gossip_service::{discover_cluster, get_multi_client}; log::*,
use solana_sdk::signature::Signer; solana_gossip::gossip_service::{discover_cluster, get_multi_client},
use solana_streamer::socket::SocketAddrSpace; solana_sdk::signature::Signer,
solana_streamer::socket::SocketAddrSpace,
};
fn main() { fn main() {
solana_logger::setup(); solana_logger::setup();

18
bench-exchange/src/order_book.rs
View File

@@ -1,11 +1,13 @@
use itertools::EitherOrBoth::{Both, Left, Right}; use {
use itertools::Itertools; itertools::{
use log::*; EitherOrBoth::{Both, Left, Right},
use solana_exchange_program::exchange_state::*; Itertools,
use solana_sdk::pubkey::Pubkey; },
use std::cmp::Ordering; log::*,
use std::collections::BinaryHeap; solana_exchange_program::exchange_state::*,
use std::{error, fmt}; solana_sdk::pubkey::Pubkey,
std::{cmp::Ordering, collections::BinaryHeap, error, fmt},
};
#[derive(Clone, Debug, Eq, PartialEq)] #[derive(Clone, Debug, Eq, PartialEq)]
pub struct ToOrder { pub struct ToOrder {

38
bench-exchange/tests/bench_exchange.rs
View File

@@ -1,22 +1,24 @@
use log::*; use {
use solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config}; log::*,
use solana_core::validator::ValidatorConfig; solana_bench_exchange::bench::{airdrop_lamports, do_bench_exchange, Config},
use solana_exchange_program::{ solana_core::validator::ValidatorConfig,
exchange_processor::process_instruction, id, solana_exchange_program, solana_exchange_program::{
exchange_processor::process_instruction, id, solana_exchange_program,
},
solana_faucet::faucet::run_local_faucet_with_port,
solana_gossip::gossip_service::{discover_cluster, get_multi_client},
solana_local_cluster::{
local_cluster::{ClusterConfig, LocalCluster},
validator_configs::make_identical_validator_configs,
},
solana_runtime::{bank::Bank, bank_client::BankClient},
solana_sdk::{
genesis_config::create_genesis_config,
signature::{Keypair, Signer},
},
solana_streamer::socket::SocketAddrSpace,
std::{process::exit, sync::mpsc::channel, time::Duration},
}; };
use solana_faucet::faucet::run_local_faucet_with_port;
use solana_gossip::gossip_service::{discover_cluster, get_multi_client};
use solana_local_cluster::{
local_cluster::{ClusterConfig, LocalCluster},
validator_configs::make_identical_validator_configs,
};
use solana_runtime::{bank::Bank, bank_client::BankClient};
use solana_sdk::{
genesis_config::create_genesis_config,
signature::{Keypair, Signer},
};
use solana_streamer::socket::SocketAddrSpace;
use std::{process::exit, sync::mpsc::channel, time::Duration};
#[test] #[test]
#[ignore] #[ignore]

30
bench-streamer/src/main.rs
View File

@@ -1,16 +1,22 @@
#![allow(clippy::integer_arithmetic)] #![allow(clippy::integer_arithmetic)]
use clap::{crate_description, crate_name, App, Arg}; use {
use solana_streamer::packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE}; clap::{crate_description, crate_name, App, Arg},
use solana_streamer::streamer::{receiver, PacketReceiver}; solana_streamer::{
use std::cmp::max; packet::{Packet, Packets, PacketsRecycler, PACKET_DATA_SIZE},
use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; streamer::{receiver, PacketReceiver},
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; },
use std::sync::mpsc::channel; std::{
use std::sync::Arc; cmp::max,
use std::thread::sleep; net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
use std::thread::{spawn, JoinHandle, Result}; sync::{
use std::time::Duration; atomic::{AtomicBool, AtomicUsize, Ordering},
use std::time::SystemTime; mpsc::channel,
Arc,
},
thread::{sleep, spawn, JoinHandle, Result},
time::{Duration, SystemTime},
},
};
fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> { fn producer(addr: &SocketAddr, exit: Arc<AtomicBool>) -> JoinHandle<()> {
let send = UdpSocket::bind("0.0.0.0:0").unwrap(); let send = UdpSocket::bind("0.0.0.0:0").unwrap();

76
bench-tps/src/bench.rs
View File

@@ -1,34 +1,36 @@
use crate::cli::Config; use {
use log::*; crate::cli::Config,
use rayon::prelude::*; log::*,
use solana_client::perf_utils::{sample_txs, SampleStats}; rayon::prelude::*,
use solana_core::gen_keys::GenKeys; solana_client::perf_utils::{sample_txs, SampleStats},
use solana_faucet::faucet::request_airdrop_transaction; solana_core::gen_keys::GenKeys,
use solana_measure::measure::Measure; solana_faucet::faucet::request_airdrop_transaction,
use solana_metrics::{self, datapoint_info}; solana_measure::measure::Measure,
use solana_sdk::{ solana_metrics::{self, datapoint_info},
client::Client, solana_sdk::{
clock::{DEFAULT_S_PER_SLOT, MAX_PROCESSING_AGE}, client::Client,
commitment_config::CommitmentConfig, clock::{DEFAULT_S_PER_SLOT, MAX_PROCESSING_AGE},
fee_calculator::FeeCalculator, commitment_config::CommitmentConfig,
hash::Hash, fee_calculator::FeeCalculator,
message::Message, hash::Hash,
pubkey::Pubkey, message::Message,
signature::{Keypair, Signer}, pubkey::Pubkey,
system_instruction, system_transaction, signature::{Keypair, Signer},
timing::{duration_as_ms, duration_as_s, duration_as_us, timestamp}, system_instruction, system_transaction,
transaction::Transaction, timing::{duration_as_ms, duration_as_s, duration_as_us, timestamp},
}; transaction::Transaction,
use std::{ },
collections::{HashSet, VecDeque}, std::{
net::SocketAddr, collections::{HashSet, VecDeque},
process::exit, net::SocketAddr,
sync::{ process::exit,
atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering}, sync::{
Arc, Mutex, RwLock, atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering},
Arc, Mutex, RwLock,
},
thread::{sleep, Builder, JoinHandle},
time::{Duration, Instant},
}, },
thread::{sleep, Builder, JoinHandle},
time::{Duration, Instant},
}; };
// The point at which transactions become "too old", in seconds. // The point at which transactions become "too old", in seconds.
@@ -924,12 +926,14 @@ pub fn generate_and_fund_keypairs<T: 'static + Client + Send + Sync>(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_runtime::bank::Bank; super::*,
use solana_runtime::bank_client::BankClient; solana_runtime::{bank::Bank, bank_client::BankClient},
use solana_sdk::client::SyncClient; solana_sdk::{
use solana_sdk::fee_calculator::FeeRateGovernor; client::SyncClient, fee_calculator::FeeRateGovernor,
use solana_sdk::genesis_config::create_genesis_config; genesis_config::create_genesis_config,
},
};
#[test] #[test]
fn test_bench_tps_bank_client() { fn test_bench_tps_bank_client() {

16
bench-tps/src/cli.rs
View File

@@ -1,11 +1,13 @@
use clap::{crate_description, crate_name, App, Arg, ArgMatches}; use {
use solana_faucet::faucet::FAUCET_PORT; clap::{crate_description, crate_name, App, Arg, ArgMatches},
use solana_sdk::fee_calculator::FeeRateGovernor; solana_faucet::faucet::FAUCET_PORT,
use solana_sdk::{ solana_sdk::{
pubkey::Pubkey, fee_calculator::FeeRateGovernor,
signature::{read_keypair_file, Keypair}, pubkey::Pubkey,
signature::{read_keypair_file, Keypair},
},
std::{net::SocketAddr, process::exit, time::Duration},
}; };
use std::{net::SocketAddr, process::exit, time::Duration};
const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL; const NUM_LAMPORTS_PER_ACCOUNT_DEFAULT: u64 = solana_sdk::native_token::LAMPORTS_PER_SOL;

26
bench-tps/src/main.rs
View File

@@ -1,14 +1,20 @@
#![allow(clippy::integer_arithmetic)] #![allow(clippy::integer_arithmetic)]
use log::*; use {
use solana_bench_tps::bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs}; log::*,
use solana_bench_tps::cli; solana_bench_tps::{
use solana_genesis::Base64Account; bench::{do_bench_tps, generate_and_fund_keypairs, generate_keypairs},
use solana_gossip::gossip_service::{discover_cluster, get_client, get_multi_client}; cli,
use solana_sdk::fee_calculator::FeeRateGovernor; },
use solana_sdk::signature::{Keypair, Signer}; solana_genesis::Base64Account,
use solana_sdk::system_program; solana_gossip::gossip_service::{discover_cluster, get_client, get_multi_client},
use solana_streamer::socket::SocketAddrSpace; solana_sdk::{
use std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc}; fee_calculator::FeeRateGovernor,
signature::{Keypair, Signer},
system_program,
},
solana_streamer::socket::SocketAddrSpace,
std::{collections::HashMap, fs::File, io::prelude::*, path::Path, process::exit, sync::Arc},
};
/// Number of signatures for all transactions in ~1 week at ~100K TPS /// Number of signatures for all transactions in ~1 week at ~100K TPS
pub const NUM_SIGNATURES_FOR_TXS: u64 = 100_000 * 60 * 60 * 24 * 7; pub const NUM_SIGNATURES_FOR_TXS: u64 = 100_000 * 60 * 60 * 24 * 7;

38
bench-tps/tests/bench_tps.rs
View File

@@ -1,22 +1,24 @@
#![allow(clippy::integer_arithmetic)] #![allow(clippy::integer_arithmetic)]
use serial_test::serial; use {
use solana_bench_tps::{ serial_test::serial,
bench::{do_bench_tps, generate_and_fund_keypairs}, solana_bench_tps::{
cli::Config, bench::{do_bench_tps, generate_and_fund_keypairs},
}; cli::Config,
use solana_client::thin_client::create_client; },
use solana_core::validator::ValidatorConfig; solana_client::thin_client::create_client,
use solana_faucet::faucet::run_local_faucet_with_port; solana_core::validator::ValidatorConfig,
use solana_gossip::cluster_info::VALIDATOR_PORT_RANGE; solana_faucet::faucet::run_local_faucet_with_port,
use solana_local_cluster::{ solana_gossip::cluster_info::VALIDATOR_PORT_RANGE,
local_cluster::{ClusterConfig, LocalCluster}, solana_local_cluster::{
validator_configs::make_identical_validator_configs, local_cluster::{ClusterConfig, LocalCluster},
}; validator_configs::make_identical_validator_configs,
use solana_sdk::signature::{Keypair, Signer}; },
use solana_streamer::socket::SocketAddrSpace; solana_sdk::signature::{Keypair, Signer},
use std::{ solana_streamer::socket::SocketAddrSpace,
sync::{mpsc::channel, Arc}, std::{
time::Duration, sync::{mpsc::channel, Arc},
time::Duration,
},
}; };
fn test_bench_tps_local_cluster(config: Config) { fn test_bench_tps_local_cluster(config: Config) {

10
clap-utils/src/input_parsers.rs
View File

@@ -196,10 +196,12 @@ pub fn commitment_of(matches: &ArgMatches<'_>, name: &str) -> Option<CommitmentC
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use clap::{App, Arg}; super::*,
use solana_sdk::signature::write_keypair_file; clap::{App, Arg},
use std::fs; solana_sdk::signature::write_keypair_file,
std::fs,
};
fn app<'ab, 'v>() -> App<'ab, 'v> { fn app<'ab, 'v>() -> App<'ab, 'v> {
App::new("test") App::new("test")

3
clap-utils/src/input_validators.rs
View File

@@ -7,8 +7,7 @@ use {
pubkey::{Pubkey, MAX_SEED_LEN}, pubkey::{Pubkey, MAX_SEED_LEN},
signature::{read_keypair_file, Signature}, signature::{read_keypair_file, Signature},
}, },
std::fmt::Display, std::{fmt::Display, str::FromStr},
std::str::FromStr,
}; };
fn is_parsable_generic<U, T>(string: T) -> Result<(), String> fn is_parsable_generic<U, T>(string: T) -> Result<(), String>

16
clap-utils/src/keypair.rs
View File

@@ -1123,14 +1123,14 @@ fn sanitize_seed_phrase(seed_phrase: &str) -> String {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::offline::OfflineArgs; super::*,
use clap::{value_t_or_exit, App, Arg}; crate::offline::OfflineArgs,
use solana_remote_wallet::locator::Manufacturer; clap::{value_t_or_exit, App, Arg},
use solana_remote_wallet::remote_wallet::initialize_wallet_manager; solana_remote_wallet::{locator::Manufacturer, remote_wallet::initialize_wallet_manager},
use solana_sdk::signer::keypair::write_keypair_file; solana_sdk::{signer::keypair::write_keypair_file, system_instruction},
use solana_sdk::system_instruction; tempfile::{NamedTempFile, TempDir},
use tempfile::{NamedTempFile, TempDir}; };
#[test] #[test]
fn test_sanitize_seed_phrase() { fn test_sanitize_seed_phrase() {

8
cli-config/src/config.rs
View File

@@ -1,7 +1,9 @@
// Wallet settings that can be configured for long-term use // Wallet settings that can be configured for long-term use
use serde_derive::{Deserialize, Serialize}; use {
use std::{collections::HashMap, io, path::Path}; serde_derive::{Deserialize, Serialize},
use url::Url; std::{collections::HashMap, io, path::Path},
url::Url,
};
lazy_static! { lazy_static! {
pub static ref CONFIG_FILE: Option<String> = { pub static ref CONFIG_FILE: Option<String> = {

1
cli-config/src/lib.rs
View File

@@ -3,7 +3,6 @@ extern crate lazy_static;
mod config; mod config;
pub use config::{Config, CONFIG_FILE}; pub use config::{Config, CONFIG_FILE};
use std::{ use std::{
fs::{create_dir_all, File}, fs::{create_dir_all, File},
io::{self, Write}, io::{self, Write},

18
cli-output/src/cli_output.rs
View File

@@ -2525,14 +2525,16 @@ impl VerboseDisplay for CliGossipNodes {}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use clap::{App, Arg}; super::*,
use solana_sdk::{ clap::{App, Arg},
message::Message, solana_sdk::{
pubkey::Pubkey, message::Message,
signature::{keypair_from_seed, NullSigner, Signature, Signer, SignerError}, pubkey::Pubkey,
system_instruction, signature::{keypair_from_seed, NullSigner, Signature, Signer, SignerError},
transaction::Transaction, system_instruction,
transaction::Transaction,
},
}; };
#[test] #[test]

6
cli-output/src/display.rs
View File

@@ -8,8 +8,7 @@ use {
program_utils::limited_deserialize, pubkey::Pubkey, stake, transaction::Transaction, program_utils::limited_deserialize, pubkey::Pubkey, stake, transaction::Transaction,
}, },
solana_transaction_status::UiTransactionStatusMeta, solana_transaction_status::UiTransactionStatusMeta,
spl_memo::id as spl_memo_id, spl_memo::{id as spl_memo_id, v1::id as spl_memo_v1_id},
spl_memo::v1::id as spl_memo_v1_id,
std::{collections::HashMap, fmt, io}, std::{collections::HashMap, fmt, io},
}; };
@@ -431,8 +430,7 @@ pub fn unix_timestamp_to_string(unix_timestamp: UnixTimestamp) -> String {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {super::*, solana_sdk::pubkey::Pubkey};
use solana_sdk::pubkey::Pubkey;
#[test] #[test]
fn test_format_labeled_address() { fn test_format_labeled_address() {

34
cli/src/checks.rs
View File

@@ -1,11 +1,13 @@
use crate::cli::CliError; use {
use solana_client::{ crate::cli::CliError,
client_error::{ClientError, Result as ClientResult}, solana_client::{
rpc_client::RpcClient, client_error::{ClientError, Result as ClientResult},
}; rpc_client::RpcClient,
use solana_sdk::{ },
commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message, solana_sdk::{
native_token::lamports_to_sol, pubkey::Pubkey, commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message,
native_token::lamports_to_sol, pubkey::Pubkey,
},
}; };
pub fn check_account_for_fee( pub fn check_account_for_fee(
@@ -149,14 +151,16 @@ pub fn check_unique_pubkeys(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use serde_json::json; super::*,
use solana_client::{ serde_json::json,
rpc_request::RpcRequest, solana_client::{
rpc_response::{Response, RpcResponseContext}, rpc_request::RpcRequest,
rpc_response::{Response, RpcResponseContext},
},
solana_sdk::system_instruction,
std::collections::HashMap,
}; };
use solana_sdk::system_instruction;
use std::collections::HashMap;
#[test] #[test]
fn test_check_account_for_fees() { fn test_check_account_for_fees() {

14
cli/src/clap_app.rs
View File

@@ -1,10 +1,12 @@
use crate::{ use {
cli::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*, stake::*, crate::{
validator_info::*, vote::*, wallet::*, cli::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*, stake::*,
validator_info::*, vote::*, wallet::*,
},
clap::{App, AppSettings, Arg, ArgGroup, SubCommand},
solana_clap_utils::{self, input_validators::*, keypair::*},
solana_cli_config::CONFIG_FILE,
}; };
use clap::{App, AppSettings, Arg, ArgGroup, SubCommand};
use solana_clap_utils::{self, input_validators::*, keypair::*};
use solana_cli_config::CONFIG_FILE;
pub fn get_clap_app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, 'v> { pub fn get_clap_app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, 'v> {
App::new(name) App::new(name)

104
cli/src/cli.rs
View File

@@ -1,37 +1,41 @@
use crate::{ use {
clap_app::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*, spend_utils::*, crate::{
stake::*, validator_info::*, vote::*, wallet::*, clap_app::*, cluster_query::*, feature::*, inflation::*, nonce::*, program::*,
spend_utils::*, stake::*, validator_info::*, vote::*, wallet::*,
},
clap::{crate_description, crate_name, value_t_or_exit, ArgMatches, Shell},
log::*,
num_traits::FromPrimitive,
serde_json::{self, Value},
solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*},
solana_cli_output::{
display::println_name_value, CliSignature, CliValidatorsSortOrder, OutputFormat,
},
solana_client::{
blockhash_query::BlockhashQuery,
client_error::{ClientError, Result as ClientResult},
nonce_utils,
rpc_client::RpcClient,
rpc_config::{
RpcLargestAccountsFilter, RpcSendTransactionConfig, RpcTransactionLogsFilter,
},
},
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{
clock::{Epoch, Slot},
commitment_config::CommitmentConfig,
decode_error::DecodeError,
hash::Hash,
instruction::InstructionError,
pubkey::Pubkey,
signature::{Signature, Signer, SignerError},
stake::{instruction::LockupArgs, state::Lockup},
transaction::{Transaction, TransactionError},
},
solana_vote_program::vote_state::VoteAuthorize,
std::{collections::HashMap, error, io::stdout, str::FromStr, sync::Arc, time::Duration},
thiserror::Error,
}; };
use clap::{crate_description, crate_name, value_t_or_exit, ArgMatches, Shell};
use log::*;
use num_traits::FromPrimitive;
use serde_json::{self, Value};
use solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*};
use solana_cli_output::{
display::println_name_value, CliSignature, CliValidatorsSortOrder, OutputFormat,
};
use solana_client::{
blockhash_query::BlockhashQuery,
client_error::{ClientError, Result as ClientResult},
nonce_utils,
rpc_client::RpcClient,
rpc_config::{RpcLargestAccountsFilter, RpcSendTransactionConfig, RpcTransactionLogsFilter},
};
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
clock::{Epoch, Slot},
commitment_config::CommitmentConfig,
decode_error::DecodeError,
hash::Hash,
instruction::InstructionError,
pubkey::Pubkey,
signature::{Signature, Signer, SignerError},
stake::{instruction::LockupArgs, state::Lockup},
transaction::{Transaction, TransactionError},
};
use solana_vote_program::vote_state::VoteAuthorize;
use std::{collections::HashMap, error, io::stdout, str::FromStr, sync::Arc, time::Duration};
use thiserror::Error;
pub const DEFAULT_RPC_TIMEOUT_SECONDS: &str = "30"; pub const DEFAULT_RPC_TIMEOUT_SECONDS: &str = "30";
pub const DEFAULT_CONFIRM_TX_TIMEOUT_SECONDS: &str = "5"; pub const DEFAULT_CONFIRM_TX_TIMEOUT_SECONDS: &str = "5";
@@ -1585,22 +1589,26 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use serde_json::{json, Value}; super::*,
use solana_client::{ serde_json::{json, Value},
blockhash_query, solana_client::{
mock_sender::SIGNATURE, blockhash_query,
rpc_request::RpcRequest, mock_sender::SIGNATURE,
rpc_response::{Response, RpcResponseContext}, rpc_request::RpcRequest,
rpc_response::{Response, RpcResponseContext},
},
solana_sdk::{
pubkey::Pubkey,
signature::{
keypair_from_seed, read_keypair_file, write_keypair_file, Keypair, Presigner,
},
stake, system_program,
transaction::TransactionError,
},
solana_transaction_status::TransactionConfirmationStatus,
std::path::PathBuf,
}; };
use solana_sdk::{
pubkey::Pubkey,
signature::{keypair_from_seed, read_keypair_file, write_keypair_file, Keypair, Presigner},
stake, system_program,
transaction::TransactionError,
};
use solana_transaction_status::TransactionConfirmationStatus;
use std::path::PathBuf;
fn make_tmp_path(name: &str) -> String { fn make_tmp_path(name: &str) -> String {
let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string()); let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());

150
cli/src/cluster_query.rs
View File

@@ -1,76 +1,78 @@
use crate::{ use {
cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult}, crate::{
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount}, cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
}; spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
use clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand};
use console::{style, Emoji};
use serde::{Deserialize, Serialize};
use solana_clap_utils::{
input_parsers::*,
input_validators::*,
keypair::DefaultSigner,
offline::{blockhash_arg, BLOCKHASH_ARG},
};
use solana_cli_output::{
display::{
build_balance_message, format_labeled_address, new_spinner_progress_bar,
println_name_value, println_transaction, unix_timestamp_to_string, writeln_name_value,
}, },
*, clap::{value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand},
}; console::{style, Emoji},
use solana_client::{ serde::{Deserialize, Serialize},
client_error::ClientErrorKind, solana_clap_utils::{
pubsub_client::PubsubClient, input_parsers::*,
rpc_client::{GetConfirmedSignaturesForAddress2Config, RpcClient}, input_validators::*,
rpc_config::{ keypair::DefaultSigner,
RpcAccountInfoConfig, RpcBlockConfig, RpcGetVoteAccountsConfig, RpcLargestAccountsConfig, offline::{blockhash_arg, BLOCKHASH_ARG},
RpcLargestAccountsFilter, RpcProgramAccountsConfig, RpcTransactionConfig,
RpcTransactionLogsConfig, RpcTransactionLogsFilter,
}, },
rpc_filter, solana_cli_output::{
rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE, display::{
rpc_response::SlotInfo, build_balance_message, format_labeled_address, new_spinner_progress_bar,
}; println_name_value, println_transaction, unix_timestamp_to_string, writeln_name_value,
use solana_remote_wallet::remote_wallet::RemoteWalletManager; },
use solana_sdk::{ *,
account::from_account,
account_utils::StateMut,
clock::{self, Clock, Slot},
commitment_config::CommitmentConfig,
epoch_schedule::Epoch,
hash::Hash,
message::Message,
native_token::lamports_to_sol,
nonce::State as NonceState,
pubkey::{self, Pubkey},
rent::Rent,
rpc_port::DEFAULT_RPC_PORT_STR,
signature::Signature,
slot_history,
stake::{self, state::StakeState},
system_instruction, system_program,
sysvar::{
self,
slot_history::SlotHistory,
stake_history::{self},
}, },
timing, solana_client::{
transaction::Transaction, client_error::ClientErrorKind,
}; pubsub_client::PubsubClient,
use solana_transaction_status::UiTransactionEncoding; rpc_client::{GetConfirmedSignaturesForAddress2Config, RpcClient},
use solana_vote_program::vote_state::VoteState; rpc_config::{
use std::{ RpcAccountInfoConfig, RpcBlockConfig, RpcGetVoteAccountsConfig,
collections::{BTreeMap, HashMap, VecDeque}, RpcLargestAccountsConfig, RpcLargestAccountsFilter, RpcProgramAccountsConfig,
fmt, RpcTransactionConfig, RpcTransactionLogsConfig, RpcTransactionLogsFilter,
str::FromStr, },
sync::{ rpc_filter,
atomic::{AtomicBool, Ordering}, rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE,
Arc, rpc_response::SlotInfo,
}, },
thread::sleep, solana_remote_wallet::remote_wallet::RemoteWalletManager,
time::{Duration, Instant, SystemTime, UNIX_EPOCH}, solana_sdk::{
account::from_account,
account_utils::StateMut,
clock::{self, Clock, Slot},
commitment_config::CommitmentConfig,
epoch_schedule::Epoch,
hash::Hash,
message::Message,
native_token::lamports_to_sol,
nonce::State as NonceState,
pubkey::{self, Pubkey},
rent::Rent,
rpc_port::DEFAULT_RPC_PORT_STR,
signature::Signature,
slot_history,
stake::{self, state::StakeState},
system_instruction, system_program,
sysvar::{
self,
slot_history::SlotHistory,
stake_history::{self},
},
timing,
transaction::Transaction,
},
solana_transaction_status::UiTransactionEncoding,
solana_vote_program::vote_state::VoteState,
std::{
collections::{BTreeMap, HashMap, VecDeque},
fmt,
str::FromStr,
sync::{
atomic::{AtomicBool, Ordering},
Arc,
},
thread::sleep,
time::{Duration, Instant, SystemTime, UNIX_EPOCH},
},
thiserror::Error,
}; };
use thiserror::Error;
static CHECK_MARK: Emoji = Emoji("✅ ", ""); static CHECK_MARK: Emoji = Emoji("✅ ", "");
static CROSS_MARK: Emoji = Emoji("❌ ", ""); static CROSS_MARK: Emoji = Emoji("❌ ", "");
@@ -2140,11 +2142,13 @@ pub fn process_calculate_rent(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{clap_app::get_clap_app, cli::parse_command}; super::*,
use solana_sdk::signature::{write_keypair, Keypair}; crate::{clap_app::get_clap_app, cli::parse_command},
use std::str::FromStr; solana_sdk::signature::{write_keypair, Keypair},
use tempfile::NamedTempFile; std::str::FromStr,
tempfile::NamedTempFile,
};
fn make_tmp_file() -> (String, NamedTempFile) { fn make_tmp_file() -> (String, NamedTempFile) {
let tmp_file = NamedTempFile::new().unwrap(); let tmp_file = NamedTempFile::new().unwrap();

52
cli/src/feature.rs
View File

@@ -1,28 +1,30 @@
use crate::{ use {
cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult}, crate::{
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount}, cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
}; spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
use clap::{App, AppSettings, Arg, ArgMatches, SubCommand}; },
use console::style; clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
use serde::{Deserialize, Serialize}; console::style,
use solana_clap_utils::{input_parsers::*, input_validators::*, keypair::*}; serde::{Deserialize, Serialize},
use solana_cli_output::{QuietDisplay, VerboseDisplay}; solana_clap_utils::{input_parsers::*, input_validators::*, keypair::*},
use solana_client::{client_error::ClientError, rpc_client::RpcClient}; solana_cli_output::{QuietDisplay, VerboseDisplay},
use solana_remote_wallet::remote_wallet::RemoteWalletManager; solana_client::{client_error::ClientError, rpc_client::RpcClient},
use solana_sdk::{ solana_remote_wallet::remote_wallet::RemoteWalletManager,
account::Account, solana_sdk::{
clock::Slot, account::Account,
feature::{self, Feature}, clock::Slot,
feature_set::FEATURE_NAMES, feature::{self, Feature},
message::Message, feature_set::FEATURE_NAMES,
pubkey::Pubkey, message::Message,
transaction::Transaction, pubkey::Pubkey,
}; transaction::Transaction,
use std::{ },
cmp::Ordering, std::{
collections::{HashMap, HashSet}, cmp::Ordering,
fmt, collections::{HashMap, HashSet},
sync::Arc, fmt,
sync::Arc,
},
}; };
#[derive(Copy, Clone, Debug, PartialEq)] #[derive(Copy, Clone, Debug, PartialEq)]

28
cli/src/inflation.rs
View File

@@ -1,17 +1,19 @@
use crate::cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult}; use {
use clap::{App, Arg, ArgMatches, SubCommand}; crate::cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
use solana_clap_utils::{ clap::{App, Arg, ArgMatches, SubCommand},
input_parsers::{pubkeys_of, value_of}, solana_clap_utils::{
input_validators::is_valid_pubkey, input_parsers::{pubkeys_of, value_of},
keypair::*, input_validators::is_valid_pubkey,
keypair::*,
},
solana_cli_output::{
CliEpochRewardshMetadata, CliInflation, CliKeyedEpochReward, CliKeyedEpochRewards,
},
solana_client::rpc_client::RpcClient,
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{clock::Epoch, pubkey::Pubkey},
std::sync::Arc,
}; };
use solana_cli_output::{
CliEpochRewardshMetadata, CliInflation, CliKeyedEpochReward, CliKeyedEpochRewards,
};
use solana_client::rpc_client::RpcClient;
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{clock::Epoch, pubkey::Pubkey};
use std::sync::Arc;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum InflationCliCommand { pub enum InflationCliCommand {

32
cli/src/main.rs
View File

@@ -1,19 +1,21 @@
use clap::{crate_description, crate_name, value_t_or_exit, ArgMatches}; use {
use console::style; clap::{crate_description, crate_name, value_t_or_exit, ArgMatches},
use solana_clap_utils::{ console::style,
input_validators::normalize_to_url_if_moniker, solana_clap_utils::{
keypair::{CliSigners, DefaultSigner}, input_validators::normalize_to_url_if_moniker,
DisplayError, keypair::{CliSigners, DefaultSigner},
DisplayError,
},
solana_cli::{
clap_app::get_clap_app,
cli::{parse_command, process_command, CliCommandInfo, CliConfig, SettingType},
},
solana_cli_config::Config,
solana_cli_output::{display::println_name_value, OutputFormat},
solana_client::rpc_config::RpcSendTransactionConfig,
solana_remote_wallet::remote_wallet::RemoteWalletManager,
std::{collections::HashMap, error, path::PathBuf, sync::Arc, time::Duration},
}; };
use solana_cli::{
clap_app::get_clap_app,
cli::{parse_command, process_command, CliCommandInfo, CliConfig, SettingType},
};
use solana_cli_config::Config;
use solana_cli_output::{display::println_name_value, OutputFormat};
use solana_client::rpc_config::RpcSendTransactionConfig;
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use std::{collections::HashMap, error, path::PathBuf, sync::Arc, time::Duration};
pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType) { pub fn println_name_value_or(name: &str, value: &str, setting_type: SettingType) {
let description = match setting_type { let description = match setting_type {

7
cli/src/memo.rs
View File

@@ -1,6 +1,7 @@
use solana_sdk::instruction::Instruction; use {
use solana_sdk::pubkey::Pubkey; solana_sdk::{instruction::Instruction, pubkey::Pubkey},
use spl_memo::id; spl_memo::id,
};
pub trait WithMemo { pub trait WithMemo {
fn with_memo<T: AsRef<str>>(self, memo: Option<T>) -> Self; fn with_memo<T: AsRef<str>>(self, memo: Option<T>) -> Self;

98
cli/src/nonce.rs
View File

@@ -1,41 +1,43 @@
use crate::{ use {
checks::{check_account_for_fee_with_commitment, check_unique_pubkeys}, crate::{
cli::{ checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
log_instruction_custom_error, log_instruction_custom_error_ex, CliCommand, CliCommandInfo, cli::{
CliConfig, CliError, ProcessResult, log_instruction_custom_error, log_instruction_custom_error_ex, CliCommand,
CliCommandInfo, CliConfig, CliError, ProcessResult,
},
feature::get_feature_is_active,
memo::WithMemo,
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
}, },
feature::get_feature_is_active, clap::{App, Arg, ArgMatches, SubCommand},
memo::WithMemo, solana_clap_utils::{
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount}, input_parsers::*,
}; input_validators::*,
use clap::{App, Arg, ArgMatches, SubCommand}; keypair::{DefaultSigner, SignerIndex},
use solana_clap_utils::{ memo::{memo_arg, MEMO_ARG},
input_parsers::*, nonce::*,
input_validators::*,
keypair::{DefaultSigner, SignerIndex},
memo::{memo_arg, MEMO_ARG},
nonce::*,
};
use solana_cli_output::CliNonceAccount;
use solana_client::{nonce_utils::*, rpc_client::RpcClient};
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
account::Account,
feature_set::merge_nonce_error_into_system_error,
hash::Hash,
instruction::InstructionError,
message::Message,
nonce::{self, State},
pubkey::Pubkey,
system_instruction::{
advance_nonce_account, authorize_nonce_account, create_nonce_account,
create_nonce_account_with_seed, instruction_to_nonce_error, withdraw_nonce_account,
NonceError, SystemError,
}, },
system_program, solana_cli_output::CliNonceAccount,
transaction::{Transaction, TransactionError}, solana_client::{nonce_utils::*, rpc_client::RpcClient},
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{
account::Account,
feature_set::merge_nonce_error_into_system_error,
hash::Hash,
instruction::InstructionError,
message::Message,
nonce::{self, State},
pubkey::Pubkey,
system_instruction::{
advance_nonce_account, authorize_nonce_account, create_nonce_account,
create_nonce_account_with_seed, instruction_to_nonce_error, withdraw_nonce_account,
NonceError, SystemError,
},
system_program,
transaction::{Transaction, TransactionError},
},
std::sync::Arc,
}; };
use std::sync::Arc;
pub trait NonceSubCommands { pub trait NonceSubCommands {
fn nonce_subcommands(self) -> Self; fn nonce_subcommands(self) -> Self;
@@ -650,19 +652,21 @@ pub fn process_withdraw_from_nonce_account(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{clap_app::get_clap_app, cli::parse_command}; super::*,
use solana_sdk::{ crate::{clap_app::get_clap_app, cli::parse_command},
account::Account, solana_sdk::{
account_utils::StateMut, account::Account,
fee_calculator::FeeCalculator, account_utils::StateMut,
hash::hash, fee_calculator::FeeCalculator,
nonce::{self, state::Versions, State}, hash::hash,
nonce_account, nonce::{self, state::Versions, State},
signature::{read_keypair_file, write_keypair, Keypair, Signer}, nonce_account,
system_program, signature::{read_keypair_file, write_keypair, Keypair, Signer},
system_program,
},
tempfile::NamedTempFile,
}; };
use tempfile::NamedTempFile;
fn make_tmp_file() -> (String, NamedTempFile) { fn make_tmp_file() -> (String, NamedTempFile) {
let tmp_file = NamedTempFile::new().unwrap(); let tmp_file = NamedTempFile::new().unwrap();

119
cli/src/program.rs
View File

@@ -1,56 +1,55 @@
use crate::{ use {
checks::*, crate::{
cli::{ checks::*,
log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, cli::{
ProcessResult, log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
ProcessResult,
},
},
bip39::{Language, Mnemonic, MnemonicType, Seed},
clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
log::*,
solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig},
solana_bpf_loader_program::{bpf_verifier, BpfError, ThisInstructionMeter},
solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*},
solana_cli_output::{
CliProgram, CliProgramAccountType, CliProgramAuthority, CliProgramBuffer, CliProgramId,
CliUpgradeableBuffer, CliUpgradeableBuffers, CliUpgradeableProgram,
CliUpgradeableProgramClosed, CliUpgradeablePrograms,
},
solana_client::{
client_error::ClientErrorKind,
rpc_client::RpcClient,
rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig, RpcSendTransactionConfig},
rpc_filter::{Memcmp, MemcmpEncodedBytes, RpcFilterType},
tpu_client::{TpuClient, TpuClientConfig},
},
solana_rbpf::vm::{Config, Executable},
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{
account::Account,
account_utils::StateMut,
bpf_loader, bpf_loader_deprecated,
bpf_loader_upgradeable::{self, UpgradeableLoaderState},
instruction::{Instruction, InstructionError},
loader_instruction,
message::Message,
native_token::Sol,
packet::PACKET_DATA_SIZE,
pubkey::Pubkey,
signature::{keypair_from_seed, read_keypair_file, Keypair, Signature, Signer},
system_instruction::{self, SystemError},
system_program,
transaction::{Transaction, TransactionError},
},
std::{
fs::File,
io::{Read, Write},
mem::size_of,
path::PathBuf,
str::FromStr,
sync::Arc,
}, },
};
use bip39::{Language, Mnemonic, MnemonicType, Seed};
use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
use log::*;
use solana_account_decoder::{UiAccountEncoding, UiDataSliceConfig};
use solana_bpf_loader_program::{bpf_verifier, BpfError, ThisInstructionMeter};
use solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*};
use solana_cli_output::{
CliProgram, CliProgramAccountType, CliProgramAuthority, CliProgramBuffer, CliProgramId,
CliUpgradeableBuffer, CliUpgradeableBuffers, CliUpgradeableProgram,
CliUpgradeableProgramClosed, CliUpgradeablePrograms,
};
use solana_client::{
client_error::ClientErrorKind,
rpc_client::RpcClient,
rpc_config::RpcSendTransactionConfig,
rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig},
rpc_filter::{Memcmp, MemcmpEncodedBytes, RpcFilterType},
tpu_client::{TpuClient, TpuClientConfig},
};
use solana_rbpf::vm::{Config, Executable};
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
account::Account,
account_utils::StateMut,
bpf_loader, bpf_loader_deprecated,
bpf_loader_upgradeable::{self, UpgradeableLoaderState},
instruction::Instruction,
instruction::InstructionError,
loader_instruction,
message::Message,
native_token::Sol,
packet::PACKET_DATA_SIZE,
pubkey::Pubkey,
signature::{keypair_from_seed, read_keypair_file, Keypair, Signature, Signer},
system_instruction::{self, SystemError},
system_program,
transaction::Transaction,
transaction::TransactionError,
};
use std::{
fs::File,
io::{Read, Write},
mem::size_of,
path::PathBuf,
str::FromStr,
sync::Arc,
}; };
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
@@ -2192,14 +2191,16 @@ fn report_ephemeral_mnemonic(words: usize, mnemonic: bip39::Mnemonic) {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{ super::*,
clap_app::get_clap_app, crate::{
cli::{parse_command, process_command}, clap_app::get_clap_app,
cli::{parse_command, process_command},
},
serde_json::Value,
solana_cli_output::OutputFormat,
solana_sdk::signature::write_keypair_file,
}; };
use serde_json::Value;
use solana_cli_output::OutputFormat;
use solana_sdk::signature::write_keypair_file;
fn make_tmp_path(name: &str) -> String { fn make_tmp_path(name: &str) -> String {
let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string()); let out_dir = std::env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());

22
cli/src/spend_utils.rs
View File

@@ -1,13 +1,15 @@
use crate::{ use {
checks::{calculate_fee, check_account_for_balance_with_commitment}, crate::{
cli::CliError, checks::{calculate_fee, check_account_for_balance_with_commitment},
}; cli::CliError,
use clap::ArgMatches; },
use solana_clap_utils::{input_parsers::lamports_of_sol, offline::SIGN_ONLY_ARG}; clap::ArgMatches,
use solana_client::rpc_client::RpcClient; solana_clap_utils::{input_parsers::lamports_of_sol, offline::SIGN_ONLY_ARG},
use solana_sdk::{ solana_client::rpc_client::RpcClient,
commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message, solana_sdk::{
native_token::lamports_to_sol, pubkey::Pubkey, commitment_config::CommitmentConfig, fee_calculator::FeeCalculator, message::Message,
native_token::lamports_to_sol, pubkey::Pubkey,
},
}; };
#[derive(Debug, PartialEq, Clone, Copy)] #[derive(Debug, PartialEq, Clone, Copy)]

114
cli/src/stake.rs
View File

@@ -1,53 +1,55 @@
use crate::{ use {
checks::{check_account_for_fee_with_commitment, check_unique_pubkeys}, crate::{
cli::{ checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, cli::{
ProcessResult, log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
ProcessResult,
},
memo::WithMemo,
nonce::check_nonce_account,
spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
}, },
memo::WithMemo, clap::{value_t, App, Arg, ArgGroup, ArgMatches, SubCommand},
nonce::check_nonce_account, solana_clap_utils::{
spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount}, fee_payer::{fee_payer_arg, FEE_PAYER_ARG},
}; input_parsers::*,
use clap::{value_t, App, Arg, ArgGroup, ArgMatches, SubCommand}; input_validators::*,
use solana_clap_utils::{ keypair::{DefaultSigner, SignerIndex},
fee_payer::{fee_payer_arg, FEE_PAYER_ARG}, memo::{memo_arg, MEMO_ARG},
input_parsers::*, nonce::*,
input_validators::*, offline::*,
keypair::{DefaultSigner, SignerIndex}, ArgConstant,
memo::{memo_arg, MEMO_ARG},
nonce::*,
offline::*,
ArgConstant,
};
use solana_cli_output::{
return_signers_with_config, CliEpochReward, CliStakeHistory, CliStakeHistoryEntry,
CliStakeState, CliStakeType, OutputFormat, ReturnSignersConfig,
};
use solana_client::{
blockhash_query::BlockhashQuery, nonce_utils, rpc_client::RpcClient,
rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE, rpc_response::RpcInflationReward,
};
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
account::from_account,
account_utils::StateMut,
clock::{Clock, UnixTimestamp, SECONDS_PER_DAY},
commitment_config::CommitmentConfig,
epoch_schedule::EpochSchedule,
message::Message,
pubkey::Pubkey,
stake::{
self,
instruction::{self as stake_instruction, LockupArgs, StakeError},
state::{Authorized, Lockup, Meta, StakeActivationStatus, StakeAuthorize, StakeState},
}, },
stake_history::StakeHistory, solana_cli_output::{
system_instruction::SystemError, return_signers_with_config, CliEpochReward, CliStakeHistory, CliStakeHistoryEntry,
sysvar::{clock, stake_history}, CliStakeState, CliStakeType, OutputFormat, ReturnSignersConfig,
transaction::Transaction, },
solana_client::{
blockhash_query::BlockhashQuery, nonce_utils, rpc_client::RpcClient,
rpc_request::DELINQUENT_VALIDATOR_SLOT_DISTANCE, rpc_response::RpcInflationReward,
},
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{
account::from_account,
account_utils::StateMut,
clock::{Clock, UnixTimestamp, SECONDS_PER_DAY},
commitment_config::CommitmentConfig,
epoch_schedule::EpochSchedule,
message::Message,
pubkey::Pubkey,
stake::{
self,
instruction::{self as stake_instruction, LockupArgs, StakeError},
state::{Authorized, Lockup, Meta, StakeActivationStatus, StakeAuthorize, StakeState},
},
stake_history::StakeHistory,
system_instruction::SystemError,
sysvar::{clock, stake_history},
transaction::Transaction,
},
solana_vote_program::vote_state::VoteState,
std::{ops::Deref, sync::Arc},
}; };
use solana_vote_program::vote_state::VoteState;
use std::{ops::Deref, sync::Arc};
pub const STAKE_AUTHORITY_ARG: ArgConstant<'static> = ArgConstant { pub const STAKE_AUTHORITY_ARG: ArgConstant<'static> = ArgConstant {
name: "stake_authority", name: "stake_authority",
@@ -2438,16 +2440,18 @@ pub fn process_delegate_stake(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{clap_app::get_clap_app, cli::parse_command}; super::*,
use solana_client::blockhash_query; crate::{clap_app::get_clap_app, cli::parse_command},
use solana_sdk::{ solana_client::blockhash_query,
hash::Hash, solana_sdk::{
signature::{ hash::Hash,
keypair_from_seed, read_keypair_file, write_keypair, Keypair, Presigner, Signer, signature::{
keypair_from_seed, read_keypair_file, write_keypair, Keypair, Presigner, Signer,
},
}, },
tempfile::NamedTempFile,
}; };
use tempfile::NamedTempFile;
fn make_tmp_file() -> (String, NamedTempFile) { fn make_tmp_file() -> (String, NamedTempFile) {
let tmp_file = NamedTempFile::new().unwrap(); let tmp_file = NamedTempFile::new().unwrap();

8
cli/src/test_utils.rs
View File

@@ -1,6 +1,8 @@
use solana_client::rpc_client::RpcClient; use {
use solana_sdk::{clock::DEFAULT_MS_PER_SLOT, commitment_config::CommitmentConfig, pubkey::Pubkey}; solana_client::rpc_client::RpcClient,
use std::{thread::sleep, time::Duration}; solana_sdk::{clock::DEFAULT_MS_PER_SLOT, commitment_config::CommitmentConfig, pubkey::Pubkey},
std::{thread::sleep, time::Duration},
};
pub fn check_recent_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) { pub fn check_recent_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
(0..5).for_each(|tries| { (0..5).for_each(|tries| {

66
cli/src/validator_info.rs
View File

@@ -1,31 +1,33 @@
use crate::{ use {
cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult}, crate::{
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount}, cli::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult},
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
},
bincode::deserialize,
clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
reqwest::blocking::Client,
serde_json::{Map, Value},
solana_account_decoder::validator_info::{
self, ValidatorInfo, MAX_LONG_FIELD_LENGTH, MAX_SHORT_FIELD_LENGTH,
},
solana_clap_utils::{
input_parsers::pubkey_of,
input_validators::{is_pubkey, is_url},
keypair::DefaultSigner,
},
solana_cli_output::{CliValidatorInfo, CliValidatorInfoVec},
solana_client::rpc_client::RpcClient,
solana_config_program::{config_instruction, get_config_data, ConfigKeys, ConfigState},
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{
account::Account,
message::Message,
pubkey::Pubkey,
signature::{Keypair, Signer},
transaction::Transaction,
},
std::{error, sync::Arc},
}; };
use bincode::deserialize;
use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
use reqwest::blocking::Client;
use serde_json::{Map, Value};
use solana_account_decoder::validator_info::{
self, ValidatorInfo, MAX_LONG_FIELD_LENGTH, MAX_SHORT_FIELD_LENGTH,
};
use solana_clap_utils::{
input_parsers::pubkey_of,
input_validators::{is_pubkey, is_url},
keypair::DefaultSigner,
};
use solana_cli_output::{CliValidatorInfo, CliValidatorInfoVec};
use solana_client::rpc_client::RpcClient;
use solana_config_program::{config_instruction, get_config_data, ConfigKeys, ConfigState};
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
account::Account,
message::Message,
pubkey::Pubkey,
signature::{Keypair, Signer},
transaction::Transaction,
};
use std::{error, sync::Arc};
// Return an error if a validator details are longer than the max length. // Return an error if a validator details are longer than the max length.
pub fn check_details_length(string: String) -> Result<(), String> { pub fn check_details_length(string: String) -> Result<(), String> {
@@ -407,10 +409,12 @@ pub fn process_get_validator_info(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::clap_app::get_clap_app; super::*,
use bincode::{serialize, serialized_size}; crate::clap_app::get_clap_app,
use serde_json::json; bincode::{serialize, serialized_size},
serde_json::json,
};
#[test] #[test]
fn test_check_url() { fn test_check_url() {

68
cli/src/vote.rs
View File

@@ -1,33 +1,35 @@
use crate::{ use {
checks::{check_account_for_fee_with_commitment, check_unique_pubkeys}, crate::{
cli::{ checks::{check_account_for_fee_with_commitment, check_unique_pubkeys},
log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, cli::{
ProcessResult, log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
ProcessResult,
},
memo::WithMemo,
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount},
stake::check_current_authority,
}, },
memo::WithMemo, clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand},
spend_utils::{resolve_spend_tx_and_check_account_balance, SpendAmount}, solana_clap_utils::{
stake::check_current_authority, input_parsers::*,
input_validators::*,
keypair::{DefaultSigner, SignerIndex},
memo::{memo_arg, MEMO_ARG},
},
solana_cli_output::{CliEpochVotingHistory, CliLockout, CliVoteAccount},
solana_client::rpc_client::RpcClient,
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{
account::Account, commitment_config::CommitmentConfig, message::Message,
native_token::lamports_to_sol, pubkey::Pubkey, system_instruction::SystemError,
transaction::Transaction,
},
solana_vote_program::{
vote_instruction::{self, withdraw, VoteError},
vote_state::{VoteAuthorize, VoteInit, VoteState},
},
std::sync::Arc,
}; };
use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
use solana_clap_utils::{
input_parsers::*,
input_validators::*,
keypair::{DefaultSigner, SignerIndex},
memo::{memo_arg, MEMO_ARG},
};
use solana_cli_output::{CliEpochVotingHistory, CliLockout, CliVoteAccount};
use solana_client::rpc_client::RpcClient;
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
account::Account, commitment_config::CommitmentConfig, message::Message,
native_token::lamports_to_sol, pubkey::Pubkey, system_instruction::SystemError,
transaction::Transaction,
};
use solana_vote_program::{
vote_instruction::{self, withdraw, VoteError},
vote_state::{VoteAuthorize, VoteInit, VoteState},
};
use std::sync::Arc;
pub trait VoteSubCommands { pub trait VoteSubCommands {
fn vote_subcommands(self) -> Self; fn vote_subcommands(self) -> Self;
@@ -937,10 +939,12 @@ pub fn process_withdraw_from_vote_account(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{clap_app::get_clap_app, cli::parse_command}; super::*,
use solana_sdk::signature::{read_keypair_file, write_keypair, Keypair, Signer}; crate::{clap_app::get_clap_app, cli::parse_command},
use tempfile::NamedTempFile; solana_sdk::signature::{read_keypair_file, write_keypair, Keypair, Signer},
tempfile::NamedTempFile,
};
fn make_tmp_file() -> (String, NamedTempFile) { fn make_tmp_file() -> (String, NamedTempFile) {
let tmp_file = NamedTempFile::new().unwrap(); let tmp_file = NamedTempFile::new().unwrap();

82
cli/src/wallet.rs
View File

@@ -1,45 +1,47 @@
use crate::{ use {
cli::{ crate::{
log_instruction_custom_error, request_and_confirm_airdrop, CliCommand, CliCommandInfo, cli::{
CliConfig, CliError, ProcessResult, log_instruction_custom_error, request_and_confirm_airdrop, CliCommand, CliCommandInfo,
CliConfig, CliError, ProcessResult,
},
memo::WithMemo,
nonce::check_nonce_account,
spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount},
}, },
memo::WithMemo, clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand},
nonce::check_nonce_account, solana_account_decoder::{UiAccount, UiAccountEncoding},
spend_utils::{resolve_spend_tx_and_check_account_balances, SpendAmount}, solana_clap_utils::{
fee_payer::*,
input_parsers::*,
input_validators::*,
keypair::{DefaultSigner, SignerIndex},
memo::*,
nonce::*,
offline::*,
},
solana_cli_output::{
display::build_balance_message, return_signers_with_config, CliAccount,
CliSignatureVerificationStatus, CliTransaction, CliTransactionConfirmation, OutputFormat,
ReturnSignersConfig,
},
solana_client::{
blockhash_query::BlockhashQuery, nonce_utils, rpc_client::RpcClient,
rpc_config::RpcTransactionConfig, rpc_response::RpcKeyedAccount,
},
solana_remote_wallet::remote_wallet::RemoteWalletManager,
solana_sdk::{
commitment_config::CommitmentConfig,
message::Message,
pubkey::Pubkey,
signature::Signature,
stake,
system_instruction::{self, SystemError},
system_program,
transaction::Transaction,
},
solana_transaction_status::{EncodedTransaction, UiTransactionEncoding},
std::{fmt::Write as FmtWrite, fs::File, io::Write, sync::Arc},
}; };
use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
use solana_account_decoder::{UiAccount, UiAccountEncoding};
use solana_clap_utils::{
fee_payer::*,
input_parsers::*,
input_validators::*,
keypair::{DefaultSigner, SignerIndex},
memo::*,
nonce::*,
offline::*,
};
use solana_cli_output::{
display::build_balance_message, return_signers_with_config, CliAccount,
CliSignatureVerificationStatus, CliTransaction, CliTransactionConfirmation, OutputFormat,
ReturnSignersConfig,
};
use solana_client::{
blockhash_query::BlockhashQuery, nonce_utils, rpc_client::RpcClient,
rpc_config::RpcTransactionConfig, rpc_response::RpcKeyedAccount,
};
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
commitment_config::CommitmentConfig,
message::Message,
pubkey::Pubkey,
signature::Signature,
stake,
system_instruction::{self, SystemError},
system_program,
transaction::Transaction,
};
use solana_transaction_status::{EncodedTransaction, UiTransactionEncoding};
use std::{fmt::Write as FmtWrite, fs::File, io::Write, sync::Arc};
pub trait WalletSubCommands { pub trait WalletSubCommands {
fn wallet_subcommands(self) -> Self; fn wallet_subcommands(self) -> Self;

42
cli/tests/nonce.rs
View File

@@ -1,24 +1,26 @@
use solana_cli::{ use {
cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig}, solana_cli::{
spend_utils::SpendAmount, cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
test_utils::{check_ready, check_recent_balance}, spend_utils::SpendAmount,
test_utils::{check_ready, check_recent_balance},
},
solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
solana_client::{
blockhash_query::{self, BlockhashQuery},
nonce_utils,
rpc_client::RpcClient,
},
solana_core::test_validator::TestValidator,
solana_faucet::faucet::run_local_faucet,
solana_sdk::{
commitment_config::CommitmentConfig,
hash::Hash,
pubkey::Pubkey,
signature::{keypair_from_seed, Keypair, Signer},
system_program,
},
solana_streamer::socket::SocketAddrSpace,
}; };
use solana_cli_output::{parse_sign_only_reply_string, OutputFormat};
use solana_client::{
blockhash_query::{self, BlockhashQuery},
nonce_utils,
rpc_client::RpcClient,
};
use solana_core::test_validator::TestValidator;
use solana_faucet::faucet::run_local_faucet;
use solana_sdk::{
commitment_config::CommitmentConfig,
hash::Hash,
pubkey::Pubkey,
signature::{keypair_from_seed, Keypair, Signer},
system_program,
};
use solana_streamer::socket::SocketAddrSpace;
#[test] #[test]
fn test_nonce() { fn test_nonce() {

38
cli/tests/program.rs
View File

@@ -1,22 +1,24 @@
use serde_json::Value; use {
use solana_cli::{ serde_json::Value,
cli::{process_command, CliCommand, CliConfig}, solana_cli::{
program::ProgramCliCommand, cli::{process_command, CliCommand, CliConfig},
program::ProgramCliCommand,
},
solana_cli_output::OutputFormat,
solana_client::rpc_client::RpcClient,
solana_core::test_validator::TestValidator,
solana_faucet::faucet::run_local_faucet,
solana_sdk::{
account_utils::StateMut,
bpf_loader,
bpf_loader_upgradeable::{self, UpgradeableLoaderState},
commitment_config::CommitmentConfig,
pubkey::Pubkey,
signature::{Keypair, Signer},
},
solana_streamer::socket::SocketAddrSpace,
std::{env, fs::File, io::Read, path::PathBuf, str::FromStr},
}; };
use solana_cli_output::OutputFormat;
use solana_client::rpc_client::RpcClient;
use solana_core::test_validator::TestValidator;
use solana_faucet::faucet::run_local_faucet;
use solana_sdk::{
account_utils::StateMut,
bpf_loader,
bpf_loader_upgradeable::{self, UpgradeableLoaderState},
commitment_config::CommitmentConfig,
pubkey::Pubkey,
signature::{Keypair, Signer},
};
use solana_streamer::socket::SocketAddrSpace;
use std::{env, fs::File, io::Read, path::PathBuf, str::FromStr};
#[test] #[test]
fn test_cli_program_deploy_non_upgradeable() { fn test_cli_program_deploy_non_upgradeable() {

18
cli/tests/request_airdrop.rs
View File

@@ -1,12 +1,14 @@
use solana_cli::cli::{process_command, CliCommand, CliConfig}; use {
use solana_client::rpc_client::RpcClient; solana_cli::cli::{process_command, CliCommand, CliConfig},
use solana_core::test_validator::TestValidator; solana_client::rpc_client::RpcClient,
use solana_faucet::faucet::run_local_faucet; solana_core::test_validator::TestValidator,
use solana_sdk::{ solana_faucet::faucet::run_local_faucet,
commitment_config::CommitmentConfig, solana_sdk::{
signature::{Keypair, Signer}, commitment_config::CommitmentConfig,
signature::{Keypair, Signer},
},
solana_streamer::socket::SocketAddrSpace,
}; };
use solana_streamer::socket::SocketAddrSpace;
#[test] #[test]
fn test_cli_request_airdrop() { fn test_cli_request_airdrop() {

52
cli/tests/stake.rs
View File

@@ -1,30 +1,32 @@
use solana_cli::{ use {
cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig}, solana_cli::{
spend_utils::SpendAmount, cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
stake::StakeAuthorizationIndexed, spend_utils::SpendAmount,
test_utils::{check_ready, check_recent_balance}, stake::StakeAuthorizationIndexed,
}; test_utils::{check_ready, check_recent_balance},
use solana_cli_output::{parse_sign_only_reply_string, OutputFormat};
use solana_client::{
blockhash_query::{self, BlockhashQuery},
nonce_utils,
rpc_client::RpcClient,
};
use solana_core::test_validator::TestValidator;
use solana_faucet::faucet::run_local_faucet;
use solana_sdk::{
account_utils::StateMut,
commitment_config::CommitmentConfig,
nonce::State as NonceState,
pubkey::Pubkey,
signature::{keypair_from_seed, Keypair, Signer},
stake::{
self,
instruction::LockupArgs,
state::{Lockup, StakeAuthorize, StakeState},
}, },
solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
solana_client::{
blockhash_query::{self, BlockhashQuery},
nonce_utils,
rpc_client::RpcClient,
},
solana_core::test_validator::TestValidator,
solana_faucet::faucet::run_local_faucet,
solana_sdk::{
account_utils::StateMut,
commitment_config::CommitmentConfig,
nonce::State as NonceState,
pubkey::Pubkey,
signature::{keypair_from_seed, Keypair, Signer},
stake::{
self,
instruction::LockupArgs,
state::{Lockup, StakeAuthorize, StakeState},
},
},
solana_streamer::socket::SocketAddrSpace,
}; };
use solana_streamer::socket::SocketAddrSpace;
#[test] #[test]
fn test_stake_delegation_force() { fn test_stake_delegation_force() {

42
cli/tests/transfer.rs
View File

@@ -1,24 +1,26 @@
use solana_cli::{ use {
cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig}, solana_cli::{
spend_utils::SpendAmount, cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
test_utils::{check_ready, check_recent_balance}, spend_utils::SpendAmount,
test_utils::{check_ready, check_recent_balance},
},
solana_cli_output::{parse_sign_only_reply_string, OutputFormat},
solana_client::{
blockhash_query::{self, BlockhashQuery},
nonce_utils,
rpc_client::RpcClient,
},
solana_core::test_validator::TestValidator,
solana_faucet::faucet::run_local_faucet,
solana_sdk::{
commitment_config::CommitmentConfig,
nonce::State as NonceState,
pubkey::Pubkey,
signature::{keypair_from_seed, Keypair, NullSigner, Signer},
stake,
},
solana_streamer::socket::SocketAddrSpace,
}; };
use solana_cli_output::{parse_sign_only_reply_string, OutputFormat};
use solana_client::{
blockhash_query::{self, BlockhashQuery},
nonce_utils,
rpc_client::RpcClient,
};
use solana_core::test_validator::TestValidator;
use solana_faucet::faucet::run_local_faucet;
use solana_sdk::{
commitment_config::CommitmentConfig,
nonce::State as NonceState,
pubkey::Pubkey,
signature::{keypair_from_seed, Keypair, NullSigner, Signer},
stake,
};
use solana_streamer::socket::SocketAddrSpace;
#[test] #[test]
fn test_transfer() { fn test_transfer() {

36
cli/tests/vote.rs
View File

@@ -1,21 +1,23 @@
use solana_cli::{ use {
cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig}, solana_cli::{
spend_utils::SpendAmount, cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
test_utils::check_recent_balance, spend_utils::SpendAmount,
test_utils::check_recent_balance,
},
solana_client::{
blockhash_query::{self, BlockhashQuery},
rpc_client::RpcClient,
},
solana_core::test_validator::TestValidator,
solana_faucet::faucet::run_local_faucet,
solana_sdk::{
account_utils::StateMut,
commitment_config::CommitmentConfig,
signature::{Keypair, Signer},
},
solana_streamer::socket::SocketAddrSpace,
solana_vote_program::vote_state::{VoteAuthorize, VoteState, VoteStateVersions},
}; };
use solana_client::{
blockhash_query::{self, BlockhashQuery},
rpc_client::RpcClient,
};
use solana_core::test_validator::TestValidator;
use solana_faucet::faucet::run_local_faucet;
use solana_sdk::{
account_utils::StateMut,
commitment_config::CommitmentConfig,
signature::{Keypair, Signer},
};
use solana_streamer::socket::SocketAddrSpace;
use solana_vote_program::vote_state::{VoteAuthorize, VoteState, VoteStateVersions};
#[test] #[test]
fn test_vote_authorize_and_withdraw() { fn test_vote_authorize_and_withdraw() {

22
client/src/blockhash_query.rs
View File

@@ -118,17 +118,19 @@ impl Default for BlockhashQuery {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{ super::*,
blockhash_query, crate::{
rpc_request::RpcRequest, blockhash_query,
rpc_response::{Response, RpcFeeCalculator, RpcFees, RpcResponseContext}, rpc_request::RpcRequest,
rpc_response::{Response, RpcFeeCalculator, RpcFees, RpcResponseContext},
},
clap::App,
serde_json::{self, json},
solana_account_decoder::{UiAccount, UiAccountEncoding},
solana_sdk::{account::Account, hash::hash, nonce, system_program},
std::collections::HashMap,
}; };
use clap::App;
use serde_json::{self, json};
use solana_account_decoder::{UiAccount, UiAccountEncoding};
use solana_sdk::{account::Account, hash::hash, nonce, system_program};
use std::collections::HashMap;
#[test] #[test]
fn test_blockhash_query_new_ok() { fn test_blockhash_query_new_ok() {

5
client/src/client_error.rs
View File

@@ -1,3 +1,4 @@
pub use reqwest;
use { use {
crate::{rpc_request, rpc_response}, crate::{rpc_request, rpc_response},
solana_faucet::faucet::FaucetError, solana_faucet::faucet::FaucetError,
@@ -6,9 +7,7 @@ use {
}, },
std::io, std::io,
thiserror::Error, thiserror::Error,
}; }; // export `reqwest` for clients
pub use reqwest; // export `reqwest` for clients
#[derive(Error, Debug)] #[derive(Error, Debug)]
pub enum ClientErrorKind { pub enum ClientErrorKind {

29
client/src/rpc_client.rs
View File

@@ -16,8 +16,7 @@ use {
client_error::{ClientError, ClientErrorKind, Result as ClientResult}, client_error::{ClientError, ClientErrorKind, Result as ClientResult},
http_sender::HttpSender, http_sender::HttpSender,
mock_sender::{MockSender, Mocks}, mock_sender::{MockSender, Mocks},
rpc_config::RpcAccountInfoConfig, rpc_config::{RpcAccountInfoConfig, *},
rpc_config::*,
rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter}, rpc_request::{RpcError, RpcRequest, RpcResponseErrorData, TokenAccountsFilter},
rpc_response::*, rpc_response::*,
rpc_sender::*, rpc_sender::*,
@@ -4784,19 +4783,21 @@ pub fn create_rpc_client_mocks() -> crate::mock_sender::Mocks {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{client_error::ClientErrorKind, mock_sender::PUBKEY}; super::*,
use assert_matches::assert_matches; crate::{client_error::ClientErrorKind, mock_sender::PUBKEY},
use jsonrpc_core::{futures::prelude::*, Error, IoHandler, Params}; assert_matches::assert_matches,
use jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation, ServerBuilder}; jsonrpc_core::{futures::prelude::*, Error, IoHandler, Params},
use serde_json::Number; jsonrpc_http_server::{AccessControlAllowOrigin, DomainsValidation, ServerBuilder},
use solana_sdk::{ serde_json::Number,
instruction::InstructionError, solana_sdk::{
signature::{Keypair, Signer}, instruction::InstructionError,
system_transaction, signature::{Keypair, Signer},
transaction::TransactionError, system_transaction,
transaction::TransactionError,
},
std::{io, sync::mpsc::channel, thread},
}; };
use std::{io, sync::mpsc::channel, thread};
#[test] #[test]
fn test_send() { fn test_send() {

2
client/src/rpc_custom_error.rs
View File

@@ -1,9 +1,9 @@
//! Implementation defined RPC server errors //! Implementation defined RPC server errors
use thiserror::Error;
use { use {
crate::rpc_response::RpcSimulateTransactionResult, crate::rpc_response::RpcSimulateTransactionResult,
jsonrpc_core::{Error, ErrorCode}, jsonrpc_core::{Error, ErrorCode},
solana_sdk::clock::Slot, solana_sdk::clock::Slot,
thiserror::Error,
}; };
pub const JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: i64 = -32001; pub const JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: i64 = -32001;

8
client/src/rpc_request.rs
View File

@@ -241,9 +241,11 @@ pub enum TokenAccountsFilter {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::rpc_config::RpcTokenAccountsFilter; super::*,
use solana_sdk::commitment_config::{CommitmentConfig, CommitmentLevel}; crate::rpc_config::RpcTokenAccountsFilter,
solana_sdk::commitment_config::{CommitmentConfig, CommitmentLevel},
};
#[test] #[test]
fn test_build_request_json() { fn test_build_request_json() {

3
client/src/thin_client.rs
View File

@@ -622,8 +622,7 @@ pub fn create_client_with_timeout(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {super::*, rayon::prelude::*};
use rayon::prelude::*;
#[test] #[test]
fn test_client_optimizer() { fn test_client_optimizer() {

60
client/src/tpu_client.rs
View File

@@ -1,34 +1,36 @@
use crate::{ use {
client_error::ClientError, crate::{
pubsub_client::{PubsubClient, PubsubClientError, PubsubClientSubscription}, client_error::ClientError,
rpc_client::RpcClient, pubsub_client::{PubsubClient, PubsubClientError, PubsubClientSubscription},
rpc_request::MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS, rpc_client::RpcClient,
rpc_response::{Fees, SlotUpdate}, rpc_request::MAX_GET_SIGNATURE_STATUSES_QUERY_ITEMS,
spinner, rpc_response::{Fees, SlotUpdate},
}; spinner,
use bincode::serialize;
use log::*;
use solana_sdk::{
clock::Slot,
commitment_config::CommitmentConfig,
message::Message,
pubkey::Pubkey,
signature::SignerError,
signers::Signers,
transaction::{Transaction, TransactionError},
};
use std::{
collections::{HashMap, HashSet, VecDeque},
net::{SocketAddr, UdpSocket},
str::FromStr,
sync::{
atomic::{AtomicBool, Ordering},
Arc, RwLock,
}, },
thread::{sleep, JoinHandle}, bincode::serialize,
time::{Duration, Instant}, log::*,
solana_sdk::{
clock::Slot,
commitment_config::CommitmentConfig,
message::Message,
pubkey::Pubkey,
signature::SignerError,
signers::Signers,
transaction::{Transaction, TransactionError},
},
std::{
collections::{HashMap, HashSet, VecDeque},
net::{SocketAddr, UdpSocket},
str::FromStr,
sync::{
atomic::{AtomicBool, Ordering},
Arc, RwLock,
},
thread::{sleep, JoinHandle},
time::{Duration, Instant},
},
thiserror::Error,
}; };
use thiserror::Error;
#[derive(Error, Debug)] #[derive(Error, Debug)]
pub enum TpuSenderError { pub enum TpuSenderError {

69
core/benches/banking_stage.rs
View File

@@ -3,40 +3,41 @@
extern crate test; extern crate test;
use crossbeam_channel::unbounded; use {
use log::*; crossbeam_channel::unbounded,
use rand::{thread_rng, Rng}; log::*,
use rayon::prelude::*; rand::{thread_rng, Rng},
use solana_core::banking_stage::{BankingStage, BankingStageStats}; rayon::prelude::*,
use solana_gossip::cluster_info::ClusterInfo; solana_core::banking_stage::{BankingStage, BankingStageStats},
use solana_gossip::cluster_info::Node; solana_gossip::cluster_info::{ClusterInfo, Node},
use solana_ledger::blockstore_processor::process_entries; solana_ledger::{
use solana_ledger::entry::{next_hash, Entry}; blockstore::Blockstore,
use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo}; blockstore_processor::process_entries,
use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path}; entry::{next_hash, Entry},
use solana_perf::packet::to_packets_chunked; genesis_utils::{create_genesis_config, GenesisConfigInfo},
use solana_perf::test_tx::test_tx; get_tmp_ledger_path,
use solana_poh::poh_recorder::{create_test_recorder, WorkingBankEntry}; },
use solana_runtime::bank::Bank; solana_perf::{packet::to_packets_chunked, test_tx::test_tx},
use solana_runtime::cost_model::CostModel; solana_poh::poh_recorder::{create_test_recorder, WorkingBankEntry},
use solana_sdk::genesis_config::GenesisConfig; solana_runtime::{bank::Bank, cost_model::CostModel},
use solana_sdk::hash::Hash; solana_sdk::{
use solana_sdk::message::Message; genesis_config::GenesisConfig,
use solana_sdk::pubkey; hash::Hash,
use solana_sdk::signature::Keypair; message::Message,
use solana_sdk::signature::Signature; pubkey,
use solana_sdk::signature::Signer; signature::{Keypair, Signature, Signer},
use solana_sdk::system_instruction; system_instruction, system_transaction,
use solana_sdk::system_transaction; timing::{duration_as_us, timestamp},
use solana_sdk::timing::{duration_as_us, timestamp}; transaction::Transaction,
use solana_sdk::transaction::Transaction; },
use solana_streamer::socket::SocketAddrSpace; solana_streamer::socket::SocketAddrSpace,
use std::collections::VecDeque; std::{
use std::sync::atomic::Ordering; collections::VecDeque,
use std::sync::mpsc::Receiver; sync::{atomic::Ordering, mpsc::Receiver, Arc, RwLock},
use std::sync::{Arc, RwLock}; time::{Duration, Instant},
use std::time::{Duration, Instant}; },
use test::Bencher; test::Bencher,
};
fn check_txs(receiver: &Arc<Receiver<WorkingBankEntry>>, ref_tx_count: usize) { fn check_txs(receiver: &Arc<Receiver<WorkingBankEntry>>, ref_tx_count: usize) {
let mut total = 0; let mut total = 0;

18
core/benches/blockstore.rs
View File

@@ -3,15 +3,17 @@
extern crate solana_ledger; extern crate solana_ledger;
extern crate test; extern crate test;
use rand::Rng; use {
use solana_ledger::{ rand::Rng,
blockstore::{entries_to_test_shreds, Blockstore}, solana_ledger::{
entry::{create_ticks, Entry}, blockstore::{entries_to_test_shreds, Blockstore},
get_tmp_ledger_path, entry::{create_ticks, Entry},
get_tmp_ledger_path,
},
solana_sdk::{clock::Slot, hash::Hash},
std::path::Path,
test::Bencher,
}; };
use solana_sdk::{clock::Slot, hash::Hash};
use std::path::Path;
use test::Bencher;
// Given some shreds and a ledger at ledger_path, benchmark writing the shreds to the ledger // Given some shreds and a ledger at ledger_path, benchmark writing the shreds to the ledger
fn bench_write_shreds(bench: &mut Bencher, entries: Vec<Entry>, ledger_path: &Path) { fn bench_write_shreds(bench: &mut Bencher, entries: Vec<Entry>, ledger_path: &Path) {

19
core/benches/consensus.rs
View File

@@ -3,16 +3,17 @@
extern crate solana_core; extern crate solana_core;
extern crate test; extern crate test;
use solana_core::consensus::Tower; use {
use solana_runtime::bank::Bank; solana_core::consensus::Tower,
use solana_runtime::bank_forks::BankForks; solana_runtime::{bank::Bank, bank_forks::BankForks},
use solana_sdk::{ solana_sdk::{
pubkey::Pubkey, pubkey::Pubkey,
signature::{Keypair, Signer}, signature::{Keypair, Signer},
},
std::sync::Arc,
tempfile::TempDir,
test::Bencher,
}; };
use std::sync::Arc;
use tempfile::TempDir;
use test::Bencher;
#[bench] #[bench]
fn bench_save_tower(bench: &mut Bencher) { fn bench_save_tower(bench: &mut Bencher) {

3
core/benches/gen_keys.rs
View File

@@ -2,8 +2,7 @@
extern crate test; extern crate test;
use solana_core::gen_keys::GenKeys; use {solana_core::gen_keys::GenKeys, test::Bencher};
use test::Bencher;
#[bench] #[bench]
fn bench_gen_keys(b: &mut Bencher) { fn bench_gen_keys(b: &mut Bencher) {

27
core/benches/shredder.rs
View File

@@ -3,19 +3,22 @@
extern crate test; extern crate test;
use rand::seq::SliceRandom; use {
use raptorq::{Decoder, Encoder}; rand::seq::SliceRandom,
use solana_ledger::entry::{create_ticks, Entry}; raptorq::{Decoder, Encoder},
use solana_ledger::shred::{ solana_ledger::{
max_entries_per_n_shred, max_ticks_per_n_shreds, ProcessShredsStats, Shred, Shredder, entry::{create_ticks, Entry},
MAX_DATA_SHREDS_PER_FEC_BLOCK, SHRED_PAYLOAD_SIZE, SIZE_OF_CODING_SHRED_HEADERS, shred::{
SIZE_OF_DATA_SHRED_PAYLOAD, max_entries_per_n_shred, max_ticks_per_n_shreds, ProcessShredsStats, Shred, Shredder,
MAX_DATA_SHREDS_PER_FEC_BLOCK, SHRED_PAYLOAD_SIZE, SIZE_OF_CODING_SHRED_HEADERS,
SIZE_OF_DATA_SHRED_PAYLOAD,
},
},
solana_perf::test_tx,
solana_sdk::{hash::Hash, signature::Keypair},
std::sync::Arc,
test::Bencher,
}; };
use solana_perf::test_tx;
use solana_sdk::hash::Hash;
use solana_sdk::signature::Keypair;
use std::sync::Arc;
use test::Bencher;
fn make_test_entry(txs_per_entry: u64) -> Entry { fn make_test_entry(txs_per_entry: u64) -> Entry {
Entry { Entry {

32
core/benches/sigverify_stage.rs
View File

@@ -3,20 +3,24 @@
extern crate solana_core; extern crate solana_core;
extern crate test; extern crate test;
use crossbeam_channel::unbounded; use {
use log::*; crossbeam_channel::unbounded,
use rand::{thread_rng, Rng}; log::*,
use solana_core::sigverify::TransactionSigVerifier; rand::{thread_rng, Rng},
use solana_core::sigverify_stage::SigVerifyStage; solana_core::{sigverify::TransactionSigVerifier, sigverify_stage::SigVerifyStage},
use solana_perf::packet::to_packets_chunked; solana_perf::{packet::to_packets_chunked, test_tx::test_tx},
use solana_perf::test_tx::test_tx; solana_sdk::{
use solana_sdk::hash::Hash; hash::Hash,
use solana_sdk::signature::{Keypair, Signer}; signature::{Keypair, Signer},
use solana_sdk::system_transaction; system_transaction,
use solana_sdk::timing::duration_as_ms; timing::duration_as_ms,
use std::sync::mpsc::channel; },
use std::time::{Duration, Instant}; std::{
use test::Bencher; sync::mpsc::channel,
time::{Duration, Instant},
},
test::Bencher,
};
#[bench] #[bench]
fn bench_packet_discard(bencher: &mut Bencher) { fn bench_packet_discard(bencher: &mut Bencher) {

60
core/src/accounts_hash_verifier.rs
View File

@@ -4,23 +4,25 @@
// hash on gossip. Monitor gossip for messages from validators in the `--known-validator`s // hash on gossip. Monitor gossip for messages from validators in the `--known-validator`s
// set and halt the node if a mismatch is detected. // set and halt the node if a mismatch is detected.
use crate::snapshot_packager_service::PendingSnapshotPackage; use {
use rayon::ThreadPool; crate::snapshot_packager_service::PendingSnapshotPackage,
use solana_gossip::cluster_info::{ClusterInfo, MAX_SNAPSHOT_HASHES}; rayon::ThreadPool,
use solana_runtime::{ solana_gossip::cluster_info::{ClusterInfo, MAX_SNAPSHOT_HASHES},
accounts_db, solana_runtime::{
snapshot_package::{AccountsPackage, AccountsPackagePre, AccountsPackageReceiver}, accounts_db,
}; snapshot_package::{AccountsPackage, AccountsPackagePre, AccountsPackageReceiver},
use solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey}; },
use std::collections::{HashMap, HashSet}; solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey},
use std::{ std::{
sync::{ collections::{HashMap, HashSet},
atomic::{AtomicBool, Ordering}, sync::{
mpsc::RecvTimeoutError, atomic::{AtomicBool, Ordering},
Arc, mpsc::RecvTimeoutError,
Arc,
},
thread::{self, Builder, JoinHandle},
time::Duration,
}, },
thread::{self, Builder, JoinHandle},
time::Duration,
}; };
pub struct AccountsHashVerifier { pub struct AccountsHashVerifier {
@@ -129,8 +131,10 @@ impl AccountsHashVerifier {
&& accounts_package.slot % fault_injection_rate_slots == 0 && accounts_package.slot % fault_injection_rate_slots == 0
{ {
// For testing, publish an invalid hash to gossip. // For testing, publish an invalid hash to gossip.
use rand::{thread_rng, Rng}; use {
use solana_sdk::hash::extend_and_hash; rand::{thread_rng, Rng},
solana_sdk::hash::extend_and_hash,
};
warn!("inserting fault at slot: {}", accounts_package.slot); warn!("inserting fault at slot: {}", accounts_package.slot);
let rand = thread_rng().gen_range(0, 10); let rand = thread_rng().gen_range(0, 10);
let hash = extend_and_hash(&hash, &[rand]); let hash = extend_and_hash(&hash, &[rand]);
@@ -215,15 +219,16 @@ impl AccountsHashVerifier {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_gossip::{cluster_info::make_accounts_hashes_message, contact_info::ContactInfo}; super::*,
use solana_runtime::bank_forks::ArchiveFormat; solana_gossip::{cluster_info::make_accounts_hashes_message, contact_info::ContactInfo},
use solana_runtime::snapshot_utils::SnapshotVersion; solana_runtime::{bank_forks::ArchiveFormat, snapshot_utils::SnapshotVersion},
use solana_sdk::{ solana_sdk::{
hash::hash, hash::hash,
signature::{Keypair, Signer}, signature::{Keypair, Signer},
},
solana_streamer::socket::SocketAddrSpace,
}; };
use solana_streamer::socket::SocketAddrSpace;
fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo { fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo {
ClusterInfo::new( ClusterInfo::new(
@@ -269,8 +274,7 @@ mod tests {
#[test] #[test]
fn test_max_hashes() { fn test_max_hashes() {
solana_logger::setup(); solana_logger::setup();
use std::path::PathBuf; use {std::path::PathBuf, tempfile::TempDir};
use tempfile::TempDir;
let keypair = Keypair::new(); let keypair = Keypair::new();
let contact_info = ContactInfo::new_localhost(&keypair.pubkey(), 0); let contact_info = ContactInfo::new_localhost(&keypair.pubkey(), 0);

191
core/src/banking_stage.rs
View File

@@ -1,64 +1,67 @@
//! The `banking_stage` processes Transaction messages. It is intended to be used //! The `banking_stage` processes Transaction messages. It is intended to be used
//! to contruct a software pipeline. The stage uses all available CPU cores and //! to contruct a software pipeline. The stage uses all available CPU cores and
//! can do its processing in parallel with signature verification on the GPU. //! can do its processing in parallel with signature verification on the GPU.
use crate::packet_hasher::PacketHasher; use {
use crossbeam_channel::{Receiver as CrossbeamReceiver, RecvTimeoutError}; crate::packet_hasher::PacketHasher,
use itertools::Itertools; crossbeam_channel::{Receiver as CrossbeamReceiver, RecvTimeoutError},
use lru::LruCache; itertools::Itertools,
use retain_mut::RetainMut; lru::LruCache,
use solana_gossip::{cluster_info::ClusterInfo, contact_info::ContactInfo}; retain_mut::RetainMut,
use solana_ledger::{blockstore_processor::TransactionStatusSender, entry::hash_transactions}; solana_gossip::{cluster_info::ClusterInfo, contact_info::ContactInfo},
use solana_measure::measure::Measure; solana_ledger::{blockstore_processor::TransactionStatusSender, entry::hash_transactions},
use solana_metrics::{inc_new_counter_debug, inc_new_counter_info}; solana_measure::measure::Measure,
use solana_perf::{ solana_metrics::{inc_new_counter_debug, inc_new_counter_info},
cuda_runtime::PinnedVec, solana_perf::{
data_budget::DataBudget, cuda_runtime::PinnedVec,
packet::{limited_deserialize, Packet, Packets, PACKETS_PER_BATCH}, data_budget::DataBudget,
perf_libs, packet::{limited_deserialize, Packet, Packets, PACKETS_PER_BATCH},
}; perf_libs,
use solana_poh::poh_recorder::{PohRecorder, PohRecorderError, TransactionRecorder};
use solana_runtime::{
accounts_db::ErrorCounters,
bank::{
Bank, ExecuteTimings, TransactionBalancesSet, TransactionCheckResult,
TransactionExecutionResult,
}, },
bank_utils, solana_poh::poh_recorder::{PohRecorder, PohRecorderError, TransactionRecorder},
cost_model::CostModel, solana_runtime::{
cost_tracker::CostTracker, accounts_db::ErrorCounters,
hashed_transaction::HashedTransaction, bank::{
transaction_batch::TransactionBatch, Bank, ExecuteTimings, TransactionBalancesSet, TransactionCheckResult,
vote_sender_types::ReplayVoteSender, TransactionExecutionResult,
}; },
use solana_sdk::{ bank_utils,
clock::{ cost_model::CostModel,
Slot, DEFAULT_TICKS_PER_SLOT, MAX_PROCESSING_AGE, MAX_TRANSACTION_FORWARDING_DELAY, cost_tracker::CostTracker,
MAX_TRANSACTION_FORWARDING_DELAY_GPU, hashed_transaction::HashedTransaction,
transaction_batch::TransactionBatch,
vote_sender_types::ReplayVoteSender,
},
solana_sdk::{
clock::{
Slot, DEFAULT_TICKS_PER_SLOT, MAX_PROCESSING_AGE, MAX_TRANSACTION_FORWARDING_DELAY,
MAX_TRANSACTION_FORWARDING_DELAY_GPU,
},
feature_set,
message::Message,
pubkey::Pubkey,
short_vec::decode_shortu16_len,
signature::Signature,
timing::{duration_as_ms, timestamp, AtomicInterval},
transaction::{self, Transaction, TransactionError},
},
solana_transaction_status::token_balances::{
collect_token_balances, TransactionTokenBalancesSet,
},
std::{
borrow::Cow,
cmp,
collections::{HashMap, VecDeque},
env,
mem::size_of,
net::{SocketAddr, UdpSocket},
ops::DerefMut,
sync::{
atomic::{AtomicU64, AtomicUsize, Ordering},
Arc, Mutex, RwLock, RwLockReadGuard,
},
thread::{self, Builder, JoinHandle},
time::{Duration, Instant},
}, },
feature_set,
message::Message,
pubkey::Pubkey,
short_vec::decode_shortu16_len,
signature::Signature,
timing::{duration_as_ms, timestamp, AtomicInterval},
transaction::{self, Transaction, TransactionError},
};
use solana_transaction_status::token_balances::{
collect_token_balances, TransactionTokenBalancesSet,
};
use std::{
borrow::Cow,
cmp,
collections::{HashMap, VecDeque},
env,
mem::size_of,
net::{SocketAddr, UdpSocket},
ops::DerefMut,
sync::atomic::{AtomicU64, AtomicUsize, Ordering},
sync::{Arc, Mutex, RwLock, RwLockReadGuard},
thread::{self, Builder, JoinHandle},
time::Duration,
time::Instant,
}; };
/// (packets, valid_indexes, forwarded) /// (packets, valid_indexes, forwarded)
@@ -1660,44 +1663,46 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crossbeam_channel::unbounded; super::*,
use itertools::Itertools; crossbeam_channel::unbounded,
use solana_gossip::{cluster_info::Node, contact_info::ContactInfo}; itertools::Itertools,
use solana_ledger::{ solana_gossip::{cluster_info::Node, contact_info::ContactInfo},
blockstore::{entries_to_test_shreds, Blockstore}, solana_ledger::{
entry::{next_entry, Entry, EntrySlice}, blockstore::{entries_to_test_shreds, Blockstore},
genesis_utils::{create_genesis_config, GenesisConfigInfo}, entry::{next_entry, Entry, EntrySlice},
get_tmp_ledger_path, genesis_utils::{create_genesis_config, GenesisConfigInfo},
leader_schedule_cache::LeaderScheduleCache, get_tmp_ledger_path,
}; leader_schedule_cache::LeaderScheduleCache,
use solana_perf::packet::to_packets_chunked; },
use solana_poh::{ solana_perf::packet::to_packets_chunked,
poh_recorder::{create_test_recorder, Record, WorkingBank, WorkingBankEntry}, solana_poh::{
poh_service::PohService, poh_recorder::{create_test_recorder, Record, WorkingBank, WorkingBankEntry},
}; poh_service::PohService,
use solana_rpc::transaction_status_service::TransactionStatusService; },
use solana_runtime::cost_model::CostModel; solana_rpc::transaction_status_service::TransactionStatusService,
use solana_sdk::{ solana_runtime::cost_model::CostModel,
hash::Hash, solana_sdk::{
instruction::InstructionError, hash::Hash,
poh_config::PohConfig, instruction::InstructionError,
signature::{Keypair, Signer}, poh_config::PohConfig,
system_instruction::SystemError, signature::{Keypair, Signer},
system_transaction, system_instruction::SystemError,
transaction::TransactionError, system_transaction,
}; transaction::TransactionError,
use solana_streamer::socket::SocketAddrSpace; },
use solana_transaction_status::TransactionWithStatusMeta; solana_streamer::socket::SocketAddrSpace,
use solana_vote_program::vote_transaction; solana_transaction_status::TransactionWithStatusMeta,
use std::{ solana_vote_program::vote_transaction,
net::SocketAddr, std::{
path::Path, net::SocketAddr,
sync::{ path::Path,
atomic::{AtomicBool, Ordering}, sync::{
mpsc::Receiver, atomic::{AtomicBool, Ordering},
mpsc::Receiver,
},
thread::sleep,
}, },
thread::sleep,
}; };
fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo { fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo {

43
core/src/broadcast_stage.rs
View File

@@ -23,8 +23,9 @@ use {
solana_poh::poh_recorder::WorkingBankEntry, solana_poh::poh_recorder::WorkingBankEntry,
solana_runtime::{bank::Bank, bank_forks::BankForks}, solana_runtime::{bank::Bank, bank_forks::BankForks},
solana_sdk::{ solana_sdk::{
clock::Slot,
pubkey::Pubkey,
timing::{timestamp, AtomicInterval}, timing::{timestamp, AtomicInterval},
{clock::Slot, pubkey::Pubkey},
}, },
solana_streamer::{ solana_streamer::{
sendmmsg::{batch_send, SendPktsError}, sendmmsg::{batch_send, SendPktsError},
@@ -449,24 +450,28 @@ pub fn broadcast_shreds(
#[cfg(test)] #[cfg(test)]
pub mod test { pub mod test {
use super::*; use {
use crossbeam_channel::unbounded; super::*,
use solana_gossip::cluster_info::{ClusterInfo, Node}; crossbeam_channel::unbounded,
use solana_ledger::{ solana_gossip::cluster_info::{ClusterInfo, Node},
blockstore::{make_slot_entries, Blockstore}, solana_ledger::{
entry::create_ticks, blockstore::{make_slot_entries, Blockstore},
genesis_utils::{create_genesis_config, GenesisConfigInfo}, entry::create_ticks,
get_tmp_ledger_path, genesis_utils::{create_genesis_config, GenesisConfigInfo},
shred::{max_ticks_per_n_shreds, ProcessShredsStats, Shredder}, get_tmp_ledger_path,
}; shred::{max_ticks_per_n_shreds, ProcessShredsStats, Shredder},
use solana_runtime::bank::Bank; },
use solana_sdk::{ solana_runtime::bank::Bank,
hash::Hash, solana_sdk::{
pubkey::Pubkey, hash::Hash,
signature::{Keypair, Signer}, pubkey::Pubkey,
}; signature::{Keypair, Signer},
use std::{ },
path::Path, sync::atomic::AtomicBool, sync::mpsc::channel, sync::Arc, thread::sleep, std::{
path::Path,
sync::{atomic::AtomicBool, mpsc::channel, Arc},
thread::sleep,
},
}; };
#[allow(clippy::implicit_hasher)] #[allow(clippy::implicit_hasher)]

20
core/src/broadcast_stage/broadcast_fake_shreds_run.rs
View File

@@ -1,8 +1,8 @@
use super::*; use {
use solana_ledger::entry::Entry; super::*,
use solana_ledger::shred::Shredder; solana_ledger::{entry::Entry, shred::Shredder},
use solana_sdk::hash::Hash; solana_sdk::{hash::Hash, signature::Keypair},
use solana_sdk::signature::Keypair; };
#[derive(Clone)] #[derive(Clone)]
pub(super) struct BroadcastFakeShredsRun { pub(super) struct BroadcastFakeShredsRun {
@@ -139,10 +139,12 @@ impl BroadcastRun for BroadcastFakeShredsRun {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_gossip::contact_info::ContactInfo; super::*,
use solana_streamer::socket::SocketAddrSpace; solana_gossip::contact_info::ContactInfo,
use std::net::{IpAddr, Ipv4Addr, SocketAddr}; solana_streamer::socket::SocketAddrSpace,
std::net::{IpAddr, Ipv4Addr, SocketAddr},
};
#[test] #[test]
fn test_tvu_peers_ordering() { fn test_tvu_peers_ordering() {

35
core/src/broadcast_stage/broadcast_utils.rs
View File

@@ -1,12 +1,13 @@
use crate::result::Result; use {
use solana_ledger::{entry::Entry, shred::Shred}; crate::result::Result,
use solana_poh::poh_recorder::WorkingBankEntry; solana_ledger::{entry::Entry, shred::Shred},
use solana_runtime::bank::Bank; solana_poh::poh_recorder::WorkingBankEntry,
use solana_sdk::clock::Slot; solana_runtime::bank::Bank,
use std::{ solana_sdk::clock::Slot,
sync::mpsc::Receiver, std::{
sync::Arc, sync::{mpsc::Receiver, Arc},
time::{Duration, Instant}, time::{Duration, Instant},
},
}; };
pub(super) struct ReceiveResults { pub(super) struct ReceiveResults {
@@ -79,13 +80,15 @@ pub(super) fn recv_slot_entries(receiver: &Receiver<WorkingBankEntry>) -> Result
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo}; super::*,
use solana_sdk::genesis_config::GenesisConfig; solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo},
use solana_sdk::pubkey::Pubkey; solana_sdk::{
use solana_sdk::system_transaction; genesis_config::GenesisConfig, pubkey::Pubkey, system_transaction,
use solana_sdk::transaction::Transaction; transaction::Transaction,
use std::sync::mpsc::channel; },
std::sync::mpsc::channel,
};
fn setup_test() -> (GenesisConfig, Arc<Bank>, Transaction) { fn setup_test() -> (GenesisConfig, Arc<Bank>, Transaction) {
let GenesisConfigInfo { let GenesisConfigInfo {

28
core/src/broadcast_stage/standard_broadcast_run.rs
View File

@@ -511,21 +511,21 @@ impl BroadcastRun for StandardBroadcastRun {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_gossip::cluster_info::{ClusterInfo, Node}; super::*,
use solana_ledger::genesis_utils::create_genesis_config; solana_gossip::cluster_info::{ClusterInfo, Node},
use solana_ledger::{ solana_ledger::{
blockstore::Blockstore, entry::create_ticks, get_tmp_ledger_path, blockstore::Blockstore, entry::create_ticks, genesis_utils::create_genesis_config,
shred::max_ticks_per_n_shreds, get_tmp_ledger_path, shred::max_ticks_per_n_shreds,
},
solana_runtime::bank::Bank,
solana_sdk::{
genesis_config::GenesisConfig,
signature::{Keypair, Signer},
},
solana_streamer::socket::SocketAddrSpace,
std::{sync::Arc, time::Duration},
}; };
use solana_runtime::bank::Bank;
use solana_sdk::{
genesis_config::GenesisConfig,
signature::{Keypair, Signer},
};
use solana_streamer::socket::SocketAddrSpace;
use std::sync::Arc;
use std::time::Duration;
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
fn setup( fn setup(

131
core/src/cluster_info_vote_listener.rs
View File

@@ -1,53 +1,56 @@
use crate::{ use {
optimistic_confirmation_verifier::OptimisticConfirmationVerifier, crate::{
replay_stage::DUPLICATE_THRESHOLD, optimistic_confirmation_verifier::OptimisticConfirmationVerifier,
result::{Error, Result}, replay_stage::DUPLICATE_THRESHOLD,
sigverify, result::{Error, Result},
verified_vote_packets::VerifiedVotePackets, sigverify,
vote_stake_tracker::VoteStakeTracker, verified_vote_packets::VerifiedVotePackets,
}; vote_stake_tracker::VoteStakeTracker,
use crossbeam_channel::{ },
unbounded, Receiver as CrossbeamReceiver, RecvTimeoutError, Select, Sender as CrossbeamSender, crossbeam_channel::{
}; unbounded, Receiver as CrossbeamReceiver, RecvTimeoutError, Select,
use itertools::izip; Sender as CrossbeamSender,
use log::*; },
use solana_gossip::{ itertools::izip,
cluster_info::{ClusterInfo, GOSSIP_SLEEP_MILLIS}, log::*,
crds::Cursor, solana_gossip::{
crds_value::CrdsValueLabel, cluster_info::{ClusterInfo, GOSSIP_SLEEP_MILLIS},
}; crds::Cursor,
use solana_ledger::blockstore::Blockstore; crds_value::CrdsValueLabel,
use solana_metrics::inc_new_counter_debug; },
use solana_perf::packet::{self, Packets}; solana_ledger::blockstore::Blockstore,
use solana_poh::poh_recorder::PohRecorder; solana_metrics::inc_new_counter_debug,
use solana_rpc::{ solana_perf::packet::{self, Packets},
optimistically_confirmed_bank_tracker::{BankNotification, BankNotificationSender}, solana_poh::poh_recorder::PohRecorder,
rpc_subscriptions::RpcSubscriptions, solana_rpc::{
}; optimistically_confirmed_bank_tracker::{BankNotification, BankNotificationSender},
use solana_runtime::{ rpc_subscriptions::RpcSubscriptions,
bank::Bank, },
bank_forks::BankForks, solana_runtime::{
commitment::VOTE_THRESHOLD_SIZE, bank::Bank,
epoch_stakes::{EpochAuthorizedVoters, EpochStakes}, bank_forks::BankForks,
stakes::Stakes, commitment::VOTE_THRESHOLD_SIZE,
vote_sender_types::{ReplayVoteReceiver, ReplayedVote}, epoch_stakes::{EpochAuthorizedVoters, EpochStakes},
}; stakes::Stakes,
use solana_sdk::{ vote_sender_types::{ReplayVoteReceiver, ReplayedVote},
clock::{Epoch, Slot, DEFAULT_MS_PER_SLOT, DEFAULT_TICKS_PER_SLOT}, },
epoch_schedule::EpochSchedule, solana_sdk::{
hash::Hash, clock::{Epoch, Slot, DEFAULT_MS_PER_SLOT, DEFAULT_TICKS_PER_SLOT},
pubkey::Pubkey, epoch_schedule::EpochSchedule,
transaction::Transaction, hash::Hash,
}; pubkey::Pubkey,
use solana_vote_program::{self, vote_state::Vote, vote_transaction}; transaction::Transaction,
use std::{ },
collections::HashMap, solana_vote_program::{self, vote_state::Vote, vote_transaction},
sync::{ std::{
atomic::{AtomicBool, Ordering}, collections::HashMap,
{Arc, Mutex, RwLock}, sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex, RwLock,
},
thread::{self, sleep, Builder, JoinHandle},
time::{Duration, Instant},
}, },
thread::{self, sleep, Builder, JoinHandle},
time::{Duration, Instant},
}; };
// Map from a vote account to the authorized voter for an epoch // Map from a vote account to the authorized voter for an epoch
@@ -835,21 +838,23 @@ impl ClusterInfoVoteListener {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_perf::packet; super::*,
use solana_rpc::optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank; solana_perf::packet,
use solana_runtime::{ solana_rpc::optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank,
bank::Bank, solana_runtime::{
commitment::BlockCommitmentCache, bank::Bank,
genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs}, commitment::BlockCommitmentCache,
vote_sender_types::ReplayVoteSender, genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
vote_sender_types::ReplayVoteSender,
},
solana_sdk::{
hash::Hash,
signature::{Keypair, Signature, Signer},
},
solana_vote_program::vote_state::Vote,
std::collections::BTreeSet,
}; };
use solana_sdk::{
hash::Hash,
signature::{Keypair, Signature, Signer},
};
use solana_vote_program::vote_state::Vote;
use std::collections::BTreeSet;
#[test] #[test]
fn test_max_vote_tx_fits() { fn test_max_vote_tx_fits() {

28
core/src/cluster_slot_state_verifier.rs
View File

@@ -1,9 +1,11 @@
use crate::{ use {
fork_choice::ForkChoice, heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, crate::{
progress_map::ProgressMap, fork_choice::ForkChoice, heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice,
progress_map::ProgressMap,
},
solana_sdk::{clock::Slot, hash::Hash},
std::collections::{BTreeMap, BTreeSet},
}; };
use solana_sdk::{clock::Slot, hash::Hash};
use std::collections::{BTreeMap, BTreeSet};
pub(crate) type DuplicateSlotsTracker = BTreeSet<Slot>; pub(crate) type DuplicateSlotsTracker = BTreeSet<Slot>;
pub(crate) type GossipDuplicateConfirmedSlots = BTreeMap<Slot, Hash>; pub(crate) type GossipDuplicateConfirmedSlots = BTreeMap<Slot, Hash>;
@@ -305,14 +307,16 @@ pub(crate) fn check_slot_agrees_with_cluster(
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use crate::consensus::test::VoteSimulator; super::*,
use solana_runtime::bank_forks::BankForks; crate::consensus::test::VoteSimulator,
use std::{ solana_runtime::bank_forks::BankForks,
collections::{HashMap, HashSet}, std::{
sync::RwLock, collections::{HashMap, HashSet},
sync::RwLock,
},
trees::tr,
}; };
use trees::tr;
struct InitialState { struct InitialState {
heaviest_subtree_fork_choice: HeaviestSubtreeForkChoice, heaviest_subtree_fork_choice: HeaviestSubtreeForkChoice,

3
core/src/cluster_slots.rs
View File

@@ -186,8 +186,7 @@ impl ClusterSlots {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {super::*, solana_runtime::epoch_stakes::NodeVoteAccounts};
use solana_runtime::epoch_stakes::NodeVoteAccounts;
#[test] #[test]
fn test_default() { fn test_default() {

28
core/src/cluster_slots_service.rs
View File

@@ -1,17 +1,19 @@
use crate::cluster_slots::ClusterSlots; use {
use crossbeam_channel::{Receiver, RecvTimeoutError, Sender}; crate::cluster_slots::ClusterSlots,
use solana_gossip::cluster_info::ClusterInfo; crossbeam_channel::{Receiver, RecvTimeoutError, Sender},
use solana_ledger::blockstore::Blockstore; solana_gossip::cluster_info::ClusterInfo,
use solana_measure::measure::Measure; solana_ledger::blockstore::Blockstore,
use solana_runtime::bank_forks::BankForks; solana_measure::measure::Measure,
use solana_sdk::clock::Slot; solana_runtime::bank_forks::BankForks,
use std::{ solana_sdk::clock::Slot,
sync::{ std::{
atomic::{AtomicBool, Ordering}, sync::{
{Arc, RwLock}, atomic::{AtomicBool, Ordering},
Arc, RwLock,
},
thread::{self, Builder, JoinHandle},
time::{Duration, Instant},
}, },
thread::{self, Builder, JoinHandle},
time::{Duration, Instant},
}; };
pub type ClusterSlotsUpdateReceiver = Receiver<Vec<Slot>>; pub type ClusterSlotsUpdateReceiver = Receiver<Vec<Slot>>;

66
core/src/commitment_service.rs
View File

@@ -1,21 +1,25 @@
use crate::consensus::Stake; use {
use solana_measure::measure::Measure; crate::consensus::Stake,
use solana_metrics::datapoint_info; solana_measure::measure::Measure,
use solana_rpc::rpc_subscriptions::RpcSubscriptions; solana_metrics::datapoint_info,
use solana_runtime::{ solana_rpc::rpc_subscriptions::RpcSubscriptions,
bank::Bank, solana_runtime::{
commitment::{BlockCommitment, BlockCommitmentCache, CommitmentSlots, VOTE_THRESHOLD_SIZE}, bank::Bank,
}; commitment::{BlockCommitment, BlockCommitmentCache, CommitmentSlots, VOTE_THRESHOLD_SIZE},
use solana_sdk::clock::Slot; },
use solana_vote_program::vote_state::VoteState; solana_sdk::clock::Slot,
use std::{ solana_vote_program::vote_state::VoteState,
cmp::max, std::{
collections::HashMap, cmp::max,
sync::atomic::{AtomicBool, Ordering}, collections::HashMap,
sync::mpsc::{channel, Receiver, RecvTimeoutError, Sender}, sync::{
sync::{Arc, RwLock}, atomic::{AtomicBool, Ordering},
thread::{self, Builder, JoinHandle}, mpsc::{channel, Receiver, RecvTimeoutError, Sender},
time::Duration, Arc, RwLock,
},
thread::{self, Builder, JoinHandle},
time::Duration,
},
}; };
pub struct CommitmentAggregationData { pub struct CommitmentAggregationData {
@@ -247,18 +251,20 @@ impl AggregateCommitmentService {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo}; super::*,
use solana_runtime::{ solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo},
accounts_background_service::AbsRequestSender, solana_runtime::{
bank_forks::BankForks, accounts_background_service::AbsRequestSender,
genesis_utils::{create_genesis_config_with_vote_accounts, ValidatorVoteKeypairs}, bank_forks::BankForks,
}; genesis_utils::{create_genesis_config_with_vote_accounts, ValidatorVoteKeypairs},
use solana_sdk::{account::Account, pubkey::Pubkey, signature::Signer}; },
use solana_stake_program::stake_state; solana_sdk::{account::Account, pubkey::Pubkey, signature::Signer},
use solana_vote_program::{ solana_stake_program::stake_state,
vote_state::{self, VoteStateVersions}, solana_vote_program::{
vote_transaction, vote_state::{self, VoteStateVersions},
vote_transaction,
},
}; };
#[test] #[test]

38
core/src/completed_data_sets_service.rs
View File

@@ -1,15 +1,19 @@
use crossbeam_channel::{Receiver, RecvTimeoutError, Sender}; use {
use solana_ledger::blockstore::{Blockstore, CompletedDataSetInfo}; crossbeam_channel::{Receiver, RecvTimeoutError, Sender},
use solana_ledger::entry::Entry; solana_ledger::{
use solana_rpc::{max_slots::MaxSlots, rpc_subscriptions::RpcSubscriptions}; blockstore::{Blockstore, CompletedDataSetInfo},
use solana_sdk::signature::Signature; entry::Entry,
use std::{ },
sync::{ solana_rpc::{max_slots::MaxSlots, rpc_subscriptions::RpcSubscriptions},
atomic::{AtomicBool, Ordering}, solana_sdk::signature::Signature,
Arc, std::{
sync::{
atomic::{AtomicBool, Ordering},
Arc,
},
thread::{self, Builder, JoinHandle},
time::Duration,
}, },
thread::{self, Builder, JoinHandle},
time::Duration,
}; };
pub type CompletedDataSetsReceiver = Receiver<Vec<CompletedDataSetInfo>>; pub type CompletedDataSetsReceiver = Receiver<Vec<CompletedDataSetInfo>>;
@@ -100,10 +104,14 @@ impl CompletedDataSetsService {
#[cfg(test)] #[cfg(test)]
pub mod test { pub mod test {
use super::*; use {
use solana_sdk::hash::Hash; super::*,
use solana_sdk::signature::{Keypair, Signer}; solana_sdk::{
use solana_sdk::transaction::Transaction; hash::Hash,
signature::{Keypair, Signer},
transaction::Transaction,
},
};
#[test] #[test]
fn test_zero_signatures() { fn test_zero_signatures() {

150
core/src/consensus.rs
View File

@@ -1,40 +1,42 @@
use crate::{ use {
heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, crate::{
latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks, heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice,
progress_map::{LockoutIntervals, ProgressMap}, latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
}; progress_map::{LockoutIntervals, ProgressMap},
use chrono::prelude::*;
use solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore, blockstore_db};
use solana_measure::measure::Measure;
use solana_runtime::{
bank::Bank, bank_forks::BankForks, commitment::VOTE_THRESHOLD_SIZE,
vote_account::ArcVoteAccount,
};
use solana_sdk::{
clock::{Slot, UnixTimestamp},
hash::Hash,
instruction::Instruction,
pubkey::Pubkey,
signature::{Keypair, Signature, Signer},
slot_history::{Check, SlotHistory},
};
use solana_vote_program::{
vote_instruction,
vote_state::{BlockTimestamp, Lockout, Vote, VoteState, MAX_LOCKOUT_HISTORY},
};
use std::{
cmp::Ordering,
collections::{HashMap, HashSet},
fs::{self, File},
io::BufReader,
ops::{
Bound::{Included, Unbounded},
Deref,
}, },
path::{Path, PathBuf}, chrono::prelude::*,
sync::Arc, solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore, blockstore_db},
solana_measure::measure::Measure,
solana_runtime::{
bank::Bank, bank_forks::BankForks, commitment::VOTE_THRESHOLD_SIZE,
vote_account::ArcVoteAccount,
},
solana_sdk::{
clock::{Slot, UnixTimestamp},
hash::Hash,
instruction::Instruction,
pubkey::Pubkey,
signature::{Keypair, Signature, Signer},
slot_history::{Check, SlotHistory},
},
solana_vote_program::{
vote_instruction,
vote_state::{BlockTimestamp, Lockout, Vote, VoteState, MAX_LOCKOUT_HISTORY},
},
std::{
cmp::Ordering,
collections::{HashMap, HashSet},
fs::{self, File},
io::BufReader,
ops::{
Bound::{Included, Unbounded},
Deref,
},
path::{Path, PathBuf},
sync::Arc,
},
thiserror::Error,
}; };
use thiserror::Error;
#[derive(PartialEq, Clone, Debug, AbiExample)] #[derive(PartialEq, Clone, Debug, AbiExample)]
pub enum SwitchForkDecision { pub enum SwitchForkDecision {
@@ -1355,46 +1357,48 @@ pub fn reconcile_blockstore_roots_with_tower(
#[cfg(test)] #[cfg(test)]
pub mod test { pub mod test {
use super::*; use {
use crate::{ super::*,
cluster_info_vote_listener::VoteTracker, crate::{
cluster_slot_state_verifier::{DuplicateSlotsTracker, GossipDuplicateConfirmedSlots}, cluster_info_vote_listener::VoteTracker,
cluster_slots::ClusterSlots, cluster_slot_state_verifier::{DuplicateSlotsTracker, GossipDuplicateConfirmedSlots},
fork_choice::{ForkChoice, SelectVoteAndResetForkResult}, cluster_slots::ClusterSlots,
heaviest_subtree_fork_choice::SlotHashKey, fork_choice::{ForkChoice, SelectVoteAndResetForkResult},
progress_map::ForkProgress, heaviest_subtree_fork_choice::SlotHashKey,
replay_stage::{HeaviestForkFailures, ReplayStage}, progress_map::ForkProgress,
unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes, replay_stage::{HeaviestForkFailures, ReplayStage},
}; unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes,
use solana_ledger::{blockstore::make_slot_entries, get_tmp_ledger_path};
use solana_runtime::{
accounts_background_service::AbsRequestSender,
bank::Bank,
bank_forks::BankForks,
genesis_utils::{
create_genesis_config_with_vote_accounts, GenesisConfigInfo, ValidatorVoteKeypairs,
}, },
solana_ledger::{blockstore::make_slot_entries, get_tmp_ledger_path},
solana_runtime::{
accounts_background_service::AbsRequestSender,
bank::Bank,
bank_forks::BankForks,
genesis_utils::{
create_genesis_config_with_vote_accounts, GenesisConfigInfo, ValidatorVoteKeypairs,
},
},
solana_sdk::{
account::{Account, AccountSharedData, ReadableAccount, WritableAccount},
clock::Slot,
hash::Hash,
pubkey::Pubkey,
signature::Signer,
slot_history::SlotHistory,
},
solana_vote_program::{
vote_state::{Vote, VoteStateVersions, MAX_LOCKOUT_HISTORY},
vote_transaction,
},
std::{
collections::HashMap,
fs::{remove_file, OpenOptions},
io::{Read, Seek, SeekFrom, Write},
sync::RwLock,
},
tempfile::TempDir,
trees::{tr, Tree, TreeWalk},
}; };
use solana_sdk::{
account::{Account, AccountSharedData, ReadableAccount, WritableAccount},
clock::Slot,
hash::Hash,
pubkey::Pubkey,
signature::Signer,
slot_history::SlotHistory,
};
use solana_vote_program::{
vote_state::{Vote, VoteStateVersions, MAX_LOCKOUT_HISTORY},
vote_transaction,
};
use std::{
collections::HashMap,
fs::{remove_file, OpenOptions},
io::{Read, Seek, SeekFrom, Write},
sync::RwLock,
};
use tempfile::TempDir;
use trees::{tr, Tree, TreeWalk};
pub(crate) struct VoteSimulator { pub(crate) struct VoteSimulator {
pub validator_keypairs: HashMap<Pubkey, ValidatorVoteKeypairs>, pub validator_keypairs: HashMap<Pubkey, ValidatorVoteKeypairs>,

31
core/src/cost_update_service.rs
View File

@@ -3,18 +3,23 @@
//! packing transactions into block; it also triggers persisting cost //! packing transactions into block; it also triggers persisting cost
//! table to blockstore. //! table to blockstore.
use solana_ledger::blockstore::Blockstore; use {
use solana_measure::measure::Measure; solana_ledger::blockstore::Blockstore,
use solana_runtime::{bank::Bank, bank::ExecuteTimings, cost_model::CostModel}; solana_measure::measure::Measure,
use solana_sdk::timing::timestamp; solana_runtime::{
use std::{ bank::{Bank, ExecuteTimings},
sync::{ cost_model::CostModel,
atomic::{AtomicBool, Ordering}, },
mpsc::Receiver, solana_sdk::timing::timestamp,
Arc, RwLock, std::{
sync::{
atomic::{AtomicBool, Ordering},
mpsc::Receiver,
Arc, RwLock,
},
thread::{self, Builder, JoinHandle},
time::Duration,
}, },
thread::{self, Builder, JoinHandle},
time::Duration,
}; };
#[derive(Default)] #[derive(Default)]
@@ -203,9 +208,7 @@ impl CostUpdateService {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {super::*, solana_runtime::message_processor::ProgramTiming, solana_sdk::pubkey::Pubkey};
use solana_runtime::message_processor::ProgramTiming;
use solana_sdk::pubkey::Pubkey;
#[test] #[test]
fn test_update_cost_model_with_empty_execute_timings() { fn test_update_cost_model_with_empty_execute_timings() {

12
core/src/drop_bank_service.rs
View File

@@ -1,8 +1,10 @@
use solana_measure::measure::Measure; use {
use solana_runtime::bank::Bank; solana_measure::measure::Measure,
use std::{ solana_runtime::bank::Bank,
sync::{mpsc::Receiver, Arc}, std::{
thread::{self, Builder, JoinHandle}, sync::{mpsc::Receiver, Arc},
thread::{self, Builder, JoinHandle},
},
}; };
pub struct DropBankService { pub struct DropBankService {

33
core/src/fetch_stage.rs
View File

@@ -1,18 +1,25 @@
//! The `fetch_stage` batches input from a UDP socket and sends it to a channel. //! The `fetch_stage` batches input from a UDP socket and sends it to a channel.
use crate::banking_stage::HOLD_TRANSACTIONS_SLOT_OFFSET; use {
use crate::result::{Error, Result}; crate::{
use solana_metrics::{inc_new_counter_debug, inc_new_counter_info}; banking_stage::HOLD_TRANSACTIONS_SLOT_OFFSET,
use solana_perf::packet::PacketsRecycler; result::{Error, Result},
use solana_perf::recycler::Recycler; },
use solana_poh::poh_recorder::PohRecorder; solana_metrics::{inc_new_counter_debug, inc_new_counter_info},
use solana_sdk::clock::DEFAULT_TICKS_PER_SLOT; solana_perf::{packet::PacketsRecycler, recycler::Recycler},
use solana_streamer::streamer::{self, PacketReceiver, PacketSender}; solana_poh::poh_recorder::PohRecorder,
use std::net::UdpSocket; solana_sdk::clock::DEFAULT_TICKS_PER_SLOT,
use std::sync::atomic::AtomicBool; solana_streamer::streamer::{self, PacketReceiver, PacketSender},
use std::sync::mpsc::{channel, RecvTimeoutError}; std::{
use std::sync::{Arc, Mutex}; net::UdpSocket,
use std::thread::{self, Builder, JoinHandle}; sync::{
atomic::AtomicBool,
mpsc::{channel, RecvTimeoutError},
Arc, Mutex,
},
thread::{self, Builder, JoinHandle},
},
};
pub struct FetchStage { pub struct FetchStage {
thread_hdls: Vec<JoinHandle<()>>, thread_hdls: Vec<JoinHandle<()>>,

22
core/src/fork_choice.rs
View File

@@ -1,13 +1,15 @@
use crate::{ use {
consensus::{SwitchForkDecision, Tower}, crate::{
latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks, consensus::{SwitchForkDecision, Tower},
progress_map::ProgressMap, latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
replay_stage::HeaviestForkFailures, progress_map::ProgressMap,
}; replay_stage::HeaviestForkFailures,
use solana_runtime::{bank::Bank, bank_forks::BankForks}; },
use std::{ solana_runtime::{bank::Bank, bank_forks::BankForks},
collections::{HashMap, HashSet}, std::{
sync::{Arc, RwLock}, collections::{HashMap, HashSet},
sync::{Arc, RwLock},
},
}; };
pub(crate) struct SelectVoteAndResetForkResult { pub(crate) struct SelectVoteAndResetForkResult {

14
core/src/gen_keys.rs
View File

@@ -1,9 +1,11 @@
//! The `gen_keys` module makes lots of keypairs //! The `gen_keys` module makes lots of keypairs
use rand::{Rng, SeedableRng}; use {
use rand_chacha::ChaChaRng; rand::{Rng, SeedableRng},
use rayon::prelude::*; rand_chacha::ChaChaRng,
use solana_sdk::signature::Keypair; rayon::prelude::*,
solana_sdk::signature::Keypair,
};
pub struct GenKeys { pub struct GenKeys {
generator: ChaChaRng, generator: ChaChaRng,
@@ -39,10 +41,8 @@ impl GenKeys {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*;
pub use solana_sdk::pubkey::Pubkey; pub use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::Signer; use {super::*, solana_sdk::signature::Signer, std::collections::HashSet};
use std::collections::HashSet;
#[test] #[test]
fn test_new_key_is_deterministic() { fn test_new_key_is_deterministic() {

54
core/src/heaviest_subtree_fork_choice.rs
View File

@@ -1,24 +1,26 @@
use crate::{
consensus::Tower, fork_choice::ForkChoice,
latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
progress_map::ProgressMap, tree_diff::TreeDiff,
};
use solana_measure::measure::Measure;
use solana_runtime::{bank::Bank, bank_forks::BankForks, epoch_stakes::EpochStakes};
use solana_sdk::{
clock::{Epoch, Slot},
epoch_schedule::EpochSchedule,
hash::Hash,
pubkey::Pubkey,
};
use std::{
borrow::Borrow,
collections::{hash_map::Entry, BTreeMap, HashMap, HashSet, VecDeque},
sync::{Arc, RwLock},
time::Instant,
};
#[cfg(test)] #[cfg(test)]
use trees::{Tree, TreeWalk}; use trees::{Tree, TreeWalk};
use {
crate::{
consensus::Tower, fork_choice::ForkChoice,
latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
progress_map::ProgressMap, tree_diff::TreeDiff,
},
solana_measure::measure::Measure,
solana_runtime::{bank::Bank, bank_forks::BankForks, epoch_stakes::EpochStakes},
solana_sdk::{
clock::{Epoch, Slot},
epoch_schedule::EpochSchedule,
hash::Hash,
pubkey::Pubkey,
},
std::{
borrow::Borrow,
collections::{hash_map::Entry, BTreeMap, HashMap, HashSet, VecDeque},
sync::{Arc, RwLock},
time::Instant,
},
};
pub type ForkWeight = u64; pub type ForkWeight = u64;
pub type SlotHashKey = (Slot, Hash); pub type SlotHashKey = (Slot, Hash);
@@ -1044,12 +1046,14 @@ impl<'a> Iterator for AncestorIterator<'a> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use crate::consensus::test::VoteSimulator; super::*,
use solana_runtime::{bank::Bank, bank_utils}; crate::consensus::test::VoteSimulator,
use solana_sdk::{hash::Hash, slot_history::SlotHistory}; solana_runtime::{bank::Bank, bank_utils},
use std::{collections::HashSet, ops::Range}; solana_sdk::{hash::Hash, slot_history::SlotHistory},
use trees::tr; std::{collections::HashSet, ops::Range},
trees::tr,
};
#[test] #[test]
fn test_max_by_weight() { fn test_max_by_weight() {

8
core/src/latest_validator_votes_for_frozen_banks.rs
View File

@@ -1,6 +1,8 @@
use crate::heaviest_subtree_fork_choice::SlotHashKey; use {
use solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey}; crate::heaviest_subtree_fork_choice::SlotHashKey,
use std::collections::{hash_map::Entry, HashMap}; solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey},
std::collections::{hash_map::Entry, HashMap},
};
#[derive(Default)] #[derive(Default)]
pub(crate) struct LatestValidatorVotesForFrozenBanks { pub(crate) struct LatestValidatorVotesForFrozenBanks {

40
core/src/ledger_cleanup_service.rs
View File

@@ -1,17 +1,24 @@
//! The `ledger_cleanup_service` drops older ledger data to limit disk space usage //! The `ledger_cleanup_service` drops older ledger data to limit disk space usage
use rand::{thread_rng, Rng}; use {
use solana_ledger::blockstore::{Blockstore, PurgeType}; rand::{thread_rng, Rng},
use solana_ledger::blockstore_db::Result as BlockstoreResult; solana_ledger::{
use solana_measure::measure::Measure; blockstore::{Blockstore, PurgeType},
use solana_sdk::clock::{Slot, DEFAULT_TICKS_PER_SLOT, TICKS_PER_DAY}; blockstore_db::Result as BlockstoreResult,
use std::string::ToString; },
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; solana_measure::measure::Measure,
use std::sync::mpsc::{Receiver, RecvTimeoutError}; solana_sdk::clock::{Slot, DEFAULT_TICKS_PER_SLOT, TICKS_PER_DAY},
use std::sync::Arc; std::{
use std::thread; string::ToString,
use std::thread::{sleep, Builder, JoinHandle}; sync::{
use std::time::Duration; atomic::{AtomicBool, AtomicU64, Ordering},
mpsc::{Receiver, RecvTimeoutError},
Arc,
},
thread::{self, sleep, Builder, JoinHandle},
time::Duration,
},
};
// - To try and keep the RocksDB size under 400GB: // - To try and keep the RocksDB size under 400GB:
// Seeing about 1600b/shred, using 2000b/shred for margin, so 200m shreds can be stored in 400gb. // Seeing about 1600b/shred, using 2000b/shred for margin, so 200m shreds can be stored in 400gb.
@@ -306,10 +313,11 @@ impl LedgerCleanupService {
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use solana_ledger::blockstore::make_many_slot_entries; super::*,
use solana_ledger::get_tmp_ledger_path; solana_ledger::{blockstore::make_many_slot_entries, get_tmp_ledger_path},
use std::sync::mpsc::channel; std::sync::mpsc::channel,
};
#[test] #[test]
fn test_cleanup1() { fn test_cleanup1() {

24
core/src/optimistic_confirmation_verifier.rs
View File

@@ -1,8 +1,10 @@
use crate::cluster_info_vote_listener::VoteTracker; use {
use solana_ledger::blockstore::Blockstore; crate::cluster_info_vote_listener::VoteTracker,
use solana_runtime::bank::Bank; solana_ledger::blockstore::Blockstore,
use solana_sdk::{clock::Slot, hash::Hash}; solana_runtime::bank::Bank,
use std::{collections::BTreeSet, time::Instant}; solana_sdk::{clock::Slot, hash::Hash},
std::{collections::BTreeSet, time::Instant},
};
pub struct OptimisticConfirmationVerifier { pub struct OptimisticConfirmationVerifier {
snapshot_start_slot: Slot, snapshot_start_slot: Slot,
@@ -139,13 +141,11 @@ impl OptimisticConfirmationVerifier {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use crate::consensus::test::VoteSimulator; super::*, crate::consensus::test::VoteSimulator, solana_ledger::get_tmp_ledger_path,
use solana_ledger::get_tmp_ledger_path; solana_runtime::bank::Bank, solana_sdk::pubkey::Pubkey, std::collections::HashMap,
use solana_runtime::bank::Bank; trees::tr,
use solana_sdk::pubkey::Pubkey; };
use std::collections::HashMap;
use trees::tr;
#[test] #[test]
fn test_add_new_optimistic_confirmed_slots() { fn test_add_new_optimistic_confirmed_slots() {

18
core/src/outstanding_requests.rs
View File

@@ -1,7 +1,9 @@
use crate::request_response::RequestResponse; use {
use lru::LruCache; crate::request_response::RequestResponse,
use rand::{thread_rng, Rng}; lru::LruCache,
use solana_ledger::shred::Nonce; rand::{thread_rng, Rng},
solana_ledger::shred::Nonce,
};
pub const DEFAULT_REQUEST_EXPIRATION_MS: u64 = 60_000; pub const DEFAULT_REQUEST_EXPIRATION_MS: u64 = 60_000;
@@ -72,10 +74,10 @@ pub struct RequestStatus<T> {
#[cfg(test)] #[cfg(test)]
pub(crate) mod tests { pub(crate) mod tests {
use super::*; use {
use crate::serve_repair::RepairType; super::*, crate::serve_repair::RepairType, solana_ledger::shred::Shred,
use solana_ledger::shred::Shred; solana_sdk::timing::timestamp,
use solana_sdk::timing::timestamp; };
#[test] #[test]
fn test_add_request() { fn test_add_request() {

26
core/src/progress_map.rs
View File

@@ -1,15 +1,17 @@
use crate::{ use {
cluster_info_vote_listener::SlotVoteTracker, crate::{
cluster_slots::SlotPubkeys, cluster_info_vote_listener::SlotVoteTracker,
replay_stage::SUPERMINORITY_THRESHOLD, cluster_slots::SlotPubkeys,
{consensus::Stake, consensus::VotedStakes}, consensus::{Stake, VotedStakes},
}; replay_stage::SUPERMINORITY_THRESHOLD,
use solana_ledger::blockstore_processor::{ConfirmationProgress, ConfirmationTiming}; },
use solana_runtime::{bank::Bank, bank_forks::BankForks, vote_account::ArcVoteAccount}; solana_ledger::blockstore_processor::{ConfirmationProgress, ConfirmationTiming},
use solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey}; solana_runtime::{bank::Bank, bank_forks::BankForks, vote_account::ArcVoteAccount},
use std::{ solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey},
collections::{BTreeMap, HashMap, HashSet}, std::{
sync::{Arc, RwLock}, collections::{BTreeMap, HashMap, HashSet},
sync::{Arc, RwLock},
},
}; };
type VotedSlot = Slot; type VotedSlot = Slot;

34
core/src/repair_response.rs
View File

@@ -1,10 +1,12 @@
use solana_ledger::{ use {
blockstore::Blockstore, solana_ledger::{
shred::{Nonce, SIZE_OF_NONCE}, blockstore::Blockstore,
shred::{Nonce, SIZE_OF_NONCE},
},
solana_perf::packet::limited_deserialize,
solana_sdk::{clock::Slot, packet::Packet},
std::{io, net::SocketAddr},
}; };
use solana_perf::packet::limited_deserialize;
use solana_sdk::{clock::Slot, packet::Packet};
use std::{io, net::SocketAddr};
pub fn repair_response_packet( pub fn repair_response_packet(
blockstore: &Blockstore, blockstore: &Blockstore,
@@ -48,15 +50,17 @@ pub fn nonce(buf: &[u8]) -> Option<Nonce> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_ledger::{ super::*,
shred::{Shred, Shredder}, solana_ledger::{
sigverify_shreds::verify_shred_cpu, shred::{Shred, Shredder},
}; sigverify_shreds::verify_shred_cpu,
use solana_sdk::signature::{Keypair, Signer}; },
use std::{ solana_sdk::signature::{Keypair, Signer},
collections::HashMap, std::{
net::{IpAddr, Ipv4Addr}, collections::HashMap,
net::{IpAddr, Ipv4Addr},
},
}; };
fn run_test_sigverify_shred_cpu_repair(slot: Slot) { fn run_test_sigverify_shred_cpu_repair(slot: Slot) {

101
core/src/repair_service.rs
View File

@@ -1,40 +1,42 @@
//! The `repair_service` module implements the tools necessary to generate a thread which //! The `repair_service` module implements the tools necessary to generate a thread which
//! regularly finds missing shreds in the ledger and sends repair requests for those shreds //! regularly finds missing shreds in the ledger and sends repair requests for those shreds
use crate::{ use {
cluster_info_vote_listener::VerifiedVoteReceiver, crate::{
cluster_slots::ClusterSlots, cluster_info_vote_listener::VerifiedVoteReceiver,
outstanding_requests::OutstandingRequests, cluster_slots::ClusterSlots,
repair_weight::RepairWeight, outstanding_requests::OutstandingRequests,
replay_stage::DUPLICATE_THRESHOLD, repair_weight::RepairWeight,
result::Result, replay_stage::DUPLICATE_THRESHOLD,
serve_repair::{RepairType, ServeRepair, REPAIR_PEERS_CACHE_CAPACITY}, result::Result,
}; serve_repair::{RepairType, ServeRepair, REPAIR_PEERS_CACHE_CAPACITY},
use crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender}; },
use lru::LruCache; crossbeam_channel::{Receiver as CrossbeamReceiver, Sender as CrossbeamSender},
use solana_gossip::cluster_info::ClusterInfo; lru::LruCache,
use solana_ledger::{ solana_gossip::cluster_info::ClusterInfo,
blockstore::{Blockstore, SlotMeta}, solana_ledger::{
shred::Nonce, blockstore::{Blockstore, SlotMeta},
}; shred::Nonce,
use solana_measure::measure::Measure; },
use solana_runtime::{bank::Bank, bank_forks::BankForks, contains::Contains}; solana_measure::measure::Measure,
use solana_sdk::{ solana_runtime::{bank::Bank, bank_forks::BankForks, contains::Contains},
clock::{BankId, Slot}, solana_sdk::{
epoch_schedule::EpochSchedule, clock::{BankId, Slot},
pubkey::Pubkey, epoch_schedule::EpochSchedule,
timing::timestamp, pubkey::Pubkey,
}; timing::timestamp,
use solana_streamer::sendmmsg::{batch_send, SendPktsError}; },
use std::{ solana_streamer::sendmmsg::{batch_send, SendPktsError},
collections::{HashMap, HashSet}, std::{
iter::Iterator, collections::{HashMap, HashSet},
net::SocketAddr, iter::Iterator,
net::UdpSocket, net::{SocketAddr, UdpSocket},
sync::atomic::{AtomicBool, Ordering}, sync::{
sync::{Arc, RwLock}, atomic::{AtomicBool, Ordering},
thread::sleep, Arc, RwLock,
thread::{self, Builder, JoinHandle}, },
time::{Duration, Instant}, thread::{self, sleep, Builder, JoinHandle},
time::{Duration, Instant},
},
}; };
pub type DuplicateSlotsResetSender = CrossbeamSender<Slot>; pub type DuplicateSlotsResetSender = CrossbeamSender<Slot>;
@@ -711,20 +713,23 @@ impl RepairService {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use crossbeam_channel::unbounded; super::*,
use solana_gossip::{cluster_info::Node, contact_info::ContactInfo}; crossbeam_channel::unbounded,
use solana_ledger::blockstore::{ solana_gossip::{cluster_info::Node, contact_info::ContactInfo},
make_chaining_slot_entries, make_many_slot_entries, make_slot_entries, solana_ledger::{
blockstore::{
make_chaining_slot_entries, make_many_slot_entries, make_slot_entries, Blockstore,
},
get_tmp_ledger_path,
shred::max_ticks_per_n_shreds,
},
solana_runtime::genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
solana_sdk::signature::{Keypair, Signer},
solana_streamer::socket::SocketAddrSpace,
solana_vote_program::vote_transaction,
std::collections::HashSet,
}; };
use solana_ledger::shred::max_ticks_per_n_shreds;
use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
use solana_runtime::genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs};
use solana_sdk::signature::Keypair;
use solana_sdk::signature::Signer;
use solana_streamer::socket::SocketAddrSpace;
use solana_vote_program::vote_transaction;
use std::collections::HashSet;
fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo { fn new_test_cluster_info(contact_info: ContactInfo) -> ClusterInfo {
ClusterInfo::new( ClusterInfo::new(

40
core/src/repair_weight.rs
View File

@@ -1,17 +1,19 @@
use crate::{ use {
heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, repair_service::RepairTiming, crate::{
repair_weighted_traversal, serve_repair::RepairType, tree_diff::TreeDiff, heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, repair_service::RepairTiming,
repair_weighted_traversal, serve_repair::RepairType, tree_diff::TreeDiff,
},
solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore},
solana_measure::measure::Measure,
solana_runtime::{contains::Contains, epoch_stakes::EpochStakes},
solana_sdk::{
clock::Slot,
epoch_schedule::{Epoch, EpochSchedule},
hash::Hash,
pubkey::Pubkey,
},
std::collections::{BTreeSet, HashMap, HashSet, VecDeque},
}; };
use solana_ledger::{ancestor_iterator::AncestorIterator, blockstore::Blockstore};
use solana_measure::measure::Measure;
use solana_runtime::{contains::Contains, epoch_stakes::EpochStakes};
use solana_sdk::{
clock::Slot,
epoch_schedule::{Epoch, EpochSchedule},
hash::Hash,
pubkey::Pubkey,
};
use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
pub struct RepairWeight { pub struct RepairWeight {
// Map from root -> a subtree rooted at that `root` // Map from root -> a subtree rooted at that `root`
@@ -531,11 +533,13 @@ impl RepairWeight {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use {
use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path}; super::*,
use solana_runtime::{bank::Bank, bank_utils}; solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path},
use solana_sdk::hash::Hash; solana_runtime::{bank::Bank, bank_utils},
use trees::tr; solana_sdk::hash::Hash,
trees::tr,
};
#[test] #[test]
fn test_sort_by_stake_weight_slot() { fn test_sort_by_stake_weight_slot() {

28
core/src/repair_weighted_traversal.rs
View File

@@ -1,11 +1,13 @@
use crate::{ use {
heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, repair_service::RepairService, crate::{
serve_repair::RepairType, tree_diff::TreeDiff, heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, repair_service::RepairService,
serve_repair::RepairType, tree_diff::TreeDiff,
},
solana_ledger::blockstore::Blockstore,
solana_runtime::contains::Contains,
solana_sdk::{clock::Slot, hash::Hash},
std::collections::{HashMap, HashSet},
}; };
use solana_ledger::blockstore::Blockstore;
use solana_runtime::contains::Contains;
use solana_sdk::{clock::Slot, hash::Hash};
use std::collections::{HashMap, HashSet};
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
enum Visit { enum Visit {
@@ -136,11 +138,13 @@ pub fn get_best_repair_shreds<'a>(
#[cfg(test)] #[cfg(test)]
pub mod test { pub mod test {
use super::*; use {
use solana_ledger::{get_tmp_ledger_path, shred::Shred}; super::*,
use solana_runtime::bank_utils; solana_ledger::{get_tmp_ledger_path, shred::Shred},
use solana_sdk::hash::Hash; solana_runtime::bank_utils,
use trees::tr; solana_sdk::hash::Hash,
trees::tr,
};
#[test] #[test]
fn test_weighted_repair_traversal_single() { fn test_weighted_repair_traversal_single() {

237
core/src/replay_stage.rs
View File

@@ -1,73 +1,74 @@
//! The `replay_stage` replays transactions broadcast by the leader. //! The `replay_stage` replays transactions broadcast by the leader.
use crate::{ use {
broadcast_stage::RetransmitSlotsSender, crate::{
cache_block_meta_service::CacheBlockMetaSender, broadcast_stage::RetransmitSlotsSender,
cluster_info_vote_listener::{ cache_block_meta_service::CacheBlockMetaSender,
GossipDuplicateConfirmedSlotsReceiver, GossipVerifiedVoteHashReceiver, VoteTracker, cluster_info_vote_listener::{
GossipDuplicateConfirmedSlotsReceiver, GossipVerifiedVoteHashReceiver, VoteTracker,
},
cluster_slot_state_verifier::*,
cluster_slots::ClusterSlots,
cluster_slots_service::ClusterSlotsUpdateSender,
commitment_service::{AggregateCommitmentService, CommitmentAggregationData},
consensus::{
ComputedBankState, Stake, SwitchForkDecision, Tower, VotedStakes, SWITCH_FORK_THRESHOLD,
},
cost_update_service::CostUpdate,
fork_choice::{ForkChoice, SelectVoteAndResetForkResult},
heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice,
latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks,
progress_map::{ForkProgress, ProgressMap, PropagatedStats},
repair_service::DuplicateSlotsResetReceiver,
rewards_recorder_service::RewardsRecorderSender,
unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes,
voting_service::VoteOp,
window_service::DuplicateSlotReceiver,
}, },
cluster_slot_state_verifier::*, solana_client::rpc_response::SlotUpdate,
cluster_slots::ClusterSlots, solana_gossip::cluster_info::ClusterInfo,
cluster_slots_service::ClusterSlotsUpdateSender, solana_ledger::{
commitment_service::{AggregateCommitmentService, CommitmentAggregationData}, block_error::BlockError,
consensus::{ blockstore::Blockstore,
ComputedBankState, Stake, SwitchForkDecision, Tower, VotedStakes, SWITCH_FORK_THRESHOLD, blockstore_processor::{self, BlockstoreProcessorError, TransactionStatusSender},
entry::VerifyRecyclers,
leader_schedule_cache::LeaderScheduleCache,
}, },
cost_update_service::CostUpdate, solana_measure::measure::Measure,
fork_choice::{ForkChoice, SelectVoteAndResetForkResult}, solana_metrics::inc_new_counter_info,
heaviest_subtree_fork_choice::HeaviestSubtreeForkChoice, solana_poh::poh_recorder::{PohRecorder, GRACE_TICKS_FACTOR, MAX_GRACE_SLOTS},
latest_validator_votes_for_frozen_banks::LatestValidatorVotesForFrozenBanks, solana_rpc::{
progress_map::{ForkProgress, ProgressMap, PropagatedStats}, optimistically_confirmed_bank_tracker::{BankNotification, BankNotificationSender},
repair_service::DuplicateSlotsResetReceiver, rpc_subscriptions::RpcSubscriptions,
rewards_recorder_service::RewardsRecorderSender, },
unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes, solana_runtime::{
voting_service::VoteOp, accounts_background_service::AbsRequestSender,
window_service::DuplicateSlotReceiver, bank::{Bank, ExecuteTimings, NewBankOptions},
}; bank_forks::BankForks,
use solana_client::rpc_response::SlotUpdate; commitment::BlockCommitmentCache,
use solana_gossip::cluster_info::ClusterInfo; vote_sender_types::ReplayVoteSender,
use solana_ledger::{ },
block_error::BlockError, solana_sdk::{
blockstore::Blockstore, clock::{Slot, MAX_PROCESSING_AGE, NUM_CONSECUTIVE_LEADER_SLOTS},
blockstore_processor::{self, BlockstoreProcessorError, TransactionStatusSender}, genesis_config::ClusterType,
entry::VerifyRecyclers, hash::Hash,
leader_schedule_cache::LeaderScheduleCache, pubkey::Pubkey,
}; signature::{Keypair, Signature, Signer},
use solana_measure::measure::Measure; timing::timestamp,
use solana_metrics::inc_new_counter_info; transaction::Transaction,
use solana_poh::poh_recorder::{PohRecorder, GRACE_TICKS_FACTOR, MAX_GRACE_SLOTS}; },
use solana_rpc::{ solana_vote_program::vote_state::Vote,
optimistically_confirmed_bank_tracker::{BankNotification, BankNotificationSender}, std::{
rpc_subscriptions::RpcSubscriptions, collections::{BTreeMap, HashMap, HashSet},
}; result,
use solana_runtime::{ sync::{
accounts_background_service::AbsRequestSender, atomic::{AtomicBool, Ordering},
bank::{Bank, ExecuteTimings, NewBankOptions}, mpsc::{Receiver, RecvTimeoutError, Sender},
bank_forks::BankForks, Arc, Mutex, RwLock,
commitment::BlockCommitmentCache, },
vote_sender_types::ReplayVoteSender, thread::{self, Builder, JoinHandle},
}; time::{Duration, Instant},
use solana_sdk::{
clock::{Slot, MAX_PROCESSING_AGE, NUM_CONSECUTIVE_LEADER_SLOTS},
genesis_config::ClusterType,
hash::Hash,
pubkey::Pubkey,
signature::Signature,
signature::{Keypair, Signer},
timing::timestamp,
transaction::Transaction,
};
use solana_vote_program::vote_state::Vote;
use std::{
collections::{BTreeMap, HashMap, HashSet},
result,
sync::{
atomic::{AtomicBool, Ordering},
mpsc::{Receiver, RecvTimeoutError, Sender},
Arc, Mutex, RwLock,
}, },
thread::{self, Builder, JoinHandle},
time::{Duration, Instant},
}; };
pub const MAX_ENTRY_RECV_PER_ITER: usize = 512; pub const MAX_ENTRY_RECV_PER_ITER: usize = 512;
@@ -2561,60 +2562,62 @@ impl ReplayStage {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use {
use crate::{ super::*,
consensus::test::{initialize_state, VoteSimulator}, crate::{
consensus::Tower, consensus::{
progress_map::ValidatorStakeInfo, test::{initialize_state, VoteSimulator},
replay_stage::ReplayStage, Tower,
}; },
use crossbeam_channel::unbounded; progress_map::ValidatorStakeInfo,
use solana_gossip::{cluster_info::Node, crds::Cursor}; replay_stage::ReplayStage,
use solana_ledger::{
blockstore::make_slot_entries,
blockstore::{entries_to_test_shreds, BlockstoreError},
create_new_tmp_ledger,
entry::{self, Entry},
genesis_utils::{create_genesis_config, create_genesis_config_with_leader},
get_tmp_ledger_path,
shred::{
CodingShredHeader, DataShredHeader, Shred, ShredCommonHeader, DATA_COMPLETE_SHRED,
SIZE_OF_COMMON_SHRED_HEADER, SIZE_OF_DATA_SHRED_HEADER, SIZE_OF_DATA_SHRED_PAYLOAD,
}, },
crossbeam_channel::unbounded,
solana_gossip::{cluster_info::Node, crds::Cursor},
solana_ledger::{
blockstore::{entries_to_test_shreds, make_slot_entries, BlockstoreError},
create_new_tmp_ledger,
entry::{self, Entry},
genesis_utils::{create_genesis_config, create_genesis_config_with_leader},
get_tmp_ledger_path,
shred::{
CodingShredHeader, DataShredHeader, Shred, ShredCommonHeader, DATA_COMPLETE_SHRED,
SIZE_OF_COMMON_SHRED_HEADER, SIZE_OF_DATA_SHRED_HEADER, SIZE_OF_DATA_SHRED_PAYLOAD,
},
},
solana_rpc::{
optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank,
rpc::create_test_transactions_and_populate_blockstore,
},
solana_runtime::{
accounts_background_service::AbsRequestSender,
commitment::BlockCommitment,
genesis_utils::{GenesisConfigInfo, ValidatorVoteKeypairs},
},
solana_sdk::{
clock::NUM_CONSECUTIVE_LEADER_SLOTS,
genesis_config,
hash::{hash, Hash},
instruction::InstructionError,
packet::PACKET_DATA_SIZE,
poh_config::PohConfig,
signature::{Keypair, Signer},
system_transaction,
transaction::TransactionError,
},
solana_streamer::socket::SocketAddrSpace,
solana_transaction_status::TransactionWithStatusMeta,
solana_vote_program::{
vote_state::{VoteState, VoteStateVersions},
vote_transaction,
},
std::{
fs::remove_dir_all,
iter,
sync::{atomic::AtomicU64, mpsc::channel, Arc, RwLock},
},
trees::{tr, Tree},
}; };
use solana_rpc::{
optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank,
rpc::create_test_transactions_and_populate_blockstore,
};
use solana_runtime::{
accounts_background_service::AbsRequestSender,
commitment::BlockCommitment,
genesis_utils::{GenesisConfigInfo, ValidatorVoteKeypairs},
};
use solana_sdk::{
clock::NUM_CONSECUTIVE_LEADER_SLOTS,
genesis_config,
hash::{hash, Hash},
instruction::InstructionError,
packet::PACKET_DATA_SIZE,
poh_config::PohConfig,
signature::{Keypair, Signer},
system_transaction,
transaction::TransactionError,
};
use solana_streamer::socket::SocketAddrSpace;
use solana_transaction_status::TransactionWithStatusMeta;
use solana_vote_program::{
vote_state::{VoteState, VoteStateVersions},
vote_transaction,
};
use std::sync::mpsc::channel;
use std::{
fs::remove_dir_all,
iter,
sync::{atomic::AtomicU64, Arc, RwLock},
};
use trees::{tr, Tree};
#[test] #[test]
fn test_is_partition_detected() { fn test_is_partition_detected() {

23
core/src/result.rs
View File

@@ -1,7 +1,9 @@
//! The `result` module exposes a Result type that propagates one of many different Error types. //! The `result` module exposes a Result type that propagates one of many different Error types.
use solana_gossip::{cluster_info, gossip_error::GossipError}; use {
use solana_ledger::blockstore; solana_gossip::{cluster_info, gossip_error::GossipError},
solana_ledger::blockstore,
};
#[derive(Debug)] #[derive(Debug)]
pub enum Error { pub enum Error {
@@ -98,14 +100,15 @@ impl std::convert::From<GossipError> for Error {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::result::Error; use {
use crate::result::Result; crate::result::{Error, Result},
use std::io; std::{
use std::io::Write; io,
use std::panic; io::Write,
use std::sync::mpsc::channel; panic,
use std::sync::mpsc::RecvError; sync::mpsc::{channel, RecvError, RecvTimeoutError},
use std::sync::mpsc::RecvTimeoutError; },
};
fn send_error() -> Result<()> { fn send_error() -> Result<()> {
let (s, r) = channel(); let (s, r) = channel();

Some files were not shown because too many files have changed in this diff Show More