test randomize with error (#5916)
* test randomize with error * update magic numbers * fixup * fixup * fixup * no more blobs * fixup
This commit is contained in:
Rob Walker
GitHub
@ -1,218 +0,0 @@
|
||||
#[macro_use]
|
||||
extern crate solana_core;
|
||||
|
||||
use log::*;
|
||||
use solana_core::banking_stage::create_test_recorder;
|
||||
use solana_core::blocktree::{create_new_tmp_ledger, Blocktree};
|
||||
use solana_core::cluster_info::{ClusterInfo, Node};
|
||||
use solana_core::confidence::ForkConfidenceCache;
|
||||
use solana_core::entry::next_entry_mut;
|
||||
use solana_core::entry::EntrySlice;
|
||||
use solana_core::genesis_utils::{create_genesis_block_with_leader, GenesisBlockInfo};
|
||||
use solana_core::gossip_service::GossipService;
|
||||
use solana_core::packet::index_blobs;
|
||||
use solana_core::rpc_subscriptions::RpcSubscriptions;
|
||||
use solana_core::service::Service;
|
||||
use solana_core::storage_stage::StorageState;
|
||||
use solana_core::streamer;
|
||||
use solana_core::tvu::{Sockets, Tvu};
|
||||
use solana_core::validator;
|
||||
use solana_runtime::epoch_schedule::MINIMUM_SLOTS_PER_EPOCH;
|
||||
use solana_sdk::signature::Signable;
|
||||
use solana_sdk::signature::{Keypair, KeypairUtil};
|
||||
use solana_sdk::system_transaction;
|
||||
use std::fs::remove_dir_all;
|
||||
use std::net::UdpSocket;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::channel;
|
||||
use std::sync::{Arc, RwLock};
|
||||
use std::time::Duration;
|
||||
|
||||
fn new_gossip(
|
||||
cluster_info: Arc<RwLock<ClusterInfo>>,
|
||||
gossip: UdpSocket,
|
||||
exit: &Arc<AtomicBool>,
|
||||
) -> GossipService {
|
||||
GossipService::new(&cluster_info, None, None, gossip, exit)
|
||||
}
|
||||
|
||||
/// Test that message sent from leader to target1 and replayed to target2
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn test_replay() {
|
||||
solana_logger::setup();
|
||||
let leader_keypair = Keypair::new();
|
||||
let leader = Node::new_localhost_with_pubkey(&leader_keypair.pubkey());
|
||||
|
||||
let target1_keypair = Keypair::new();
|
||||
let target1 = Node::new_localhost_with_pubkey(&target1_keypair.pubkey());
|
||||
|
||||
let target2 = Node::new_localhost();
|
||||
let exit = Arc::new(AtomicBool::new(false));
|
||||
|
||||
// start cluster_info_l
|
||||
let cluster_info_l = ClusterInfo::new_with_invalid_keypair(leader.info.clone());
|
||||
|
||||
let cref_l = Arc::new(RwLock::new(cluster_info_l));
|
||||
let dr_l = new_gossip(cref_l, leader.sockets.gossip, &exit);
|
||||
|
||||
// start cluster_info2
|
||||
let mut cluster_info2 = ClusterInfo::new_with_invalid_keypair(target2.info.clone());
|
||||
cluster_info2.insert_info(leader.info.clone());
|
||||
let cref2 = Arc::new(RwLock::new(cluster_info2));
|
||||
let dr_2 = new_gossip(cref2, target2.sockets.gossip, &exit);
|
||||
|
||||
// setup some blob services to send blobs into the socket
|
||||
// to simulate the source peer and get blobs out of the socket to
|
||||
// simulate target peer
|
||||
let (s_reader, r_reader) = channel();
|
||||
let blob_sockets: Vec<Arc<UdpSocket>> = target2.sockets.tvu.into_iter().map(Arc::new).collect();
|
||||
|
||||
let t_receiver = streamer::blob_receiver(blob_sockets[0].clone(), &exit, s_reader);
|
||||
|
||||
// simulate leader sending messages
|
||||
let (s_responder, r_responder) = channel();
|
||||
let t_responder = streamer::responder(
|
||||
"test_replay",
|
||||
Arc::new(leader.sockets.retransmit),
|
||||
r_responder,
|
||||
);
|
||||
|
||||
let mint_balance = 10_000;
|
||||
let leader_balance = 100;
|
||||
let GenesisBlockInfo {
|
||||
mut genesis_block,
|
||||
mint_keypair,
|
||||
..
|
||||
} = create_genesis_block_with_leader(mint_balance, &leader.info.id, leader_balance);
|
||||
genesis_block.ticks_per_slot = 160;
|
||||
genesis_block.slots_per_epoch = MINIMUM_SLOTS_PER_EPOCH as u64;
|
||||
let (blocktree_path, blockhash) = create_new_tmp_ledger!(&genesis_block);
|
||||
|
||||
let tvu_addr = target1.info.tvu;
|
||||
|
||||
let (
|
||||
_genesis_blockhash,
|
||||
bank_forks,
|
||||
_bank_forks_info,
|
||||
blocktree,
|
||||
ledger_signal_receiver,
|
||||
completed_slots_receiver,
|
||||
leader_schedule_cache,
|
||||
_,
|
||||
) = validator::new_banks_from_blocktree(None, &blocktree_path, None, None, true, None);
|
||||
let working_bank = bank_forks.working_bank();
|
||||
assert_eq!(
|
||||
working_bank.get_balance(&mint_keypair.pubkey()),
|
||||
mint_balance
|
||||
);
|
||||
|
||||
let leader_schedule_cache = Arc::new(leader_schedule_cache);
|
||||
// start cluster_info1
|
||||
let bank_forks = Arc::new(RwLock::new(bank_forks));
|
||||
let mut cluster_info1 = ClusterInfo::new_with_invalid_keypair(target1.info.clone());
|
||||
cluster_info1.insert_info(leader.info.clone());
|
||||
let cref1 = Arc::new(RwLock::new(cluster_info1));
|
||||
let dr_1 = new_gossip(cref1.clone(), target1.sockets.gossip, &exit);
|
||||
|
||||
let voting_keypair = Keypair::new();
|
||||
let storage_keypair = Arc::new(Keypair::new());
|
||||
let blocktree = Arc::new(blocktree);
|
||||
{
|
||||
let (poh_service_exit, poh_recorder, poh_service, _entry_receiver) =
|
||||
create_test_recorder(&working_bank, &blocktree);
|
||||
let fork_confidence_cache = Arc::new(RwLock::new(ForkConfidenceCache::default()));
|
||||
let tvu = Tvu::new(
|
||||
&voting_keypair.pubkey(),
|
||||
Some(&Arc::new(voting_keypair)),
|
||||
&storage_keypair,
|
||||
&bank_forks,
|
||||
&cref1,
|
||||
{
|
||||
Sockets {
|
||||
repair: target1.sockets.repair,
|
||||
retransmit: target1.sockets.retransmit,
|
||||
fetch: target1.sockets.tvu,
|
||||
forwards: target1.sockets.tvu_forwards,
|
||||
}
|
||||
},
|
||||
blocktree,
|
||||
&StorageState::default(),
|
||||
None,
|
||||
None,
|
||||
ledger_signal_receiver,
|
||||
&Arc::new(RpcSubscriptions::default()),
|
||||
&poh_recorder,
|
||||
&leader_schedule_cache,
|
||||
&exit,
|
||||
completed_slots_receiver,
|
||||
fork_confidence_cache,
|
||||
);
|
||||
|
||||
let mut mint_ref_balance = mint_balance;
|
||||
let mut msgs = Vec::new();
|
||||
let mut blob_idx = 0;
|
||||
let num_transfers = 10;
|
||||
let mut transfer_amount = 501;
|
||||
let bob_keypair = Keypair::new();
|
||||
let mut cur_hash = blockhash;
|
||||
for i in 0..num_transfers {
|
||||
let entry0 = next_entry_mut(&mut cur_hash, i, vec![]);
|
||||
let entry_tick0 = next_entry_mut(&mut cur_hash, i + 1, vec![]);
|
||||
|
||||
let tx0 = system_transaction::create_user_account(
|
||||
&mint_keypair,
|
||||
&bob_keypair.pubkey(),
|
||||
transfer_amount,
|
||||
blockhash,
|
||||
);
|
||||
let entry_tick1 = next_entry_mut(&mut cur_hash, i + 1, vec![]);
|
||||
let entry1 = next_entry_mut(&mut cur_hash, i + num_transfers, vec![tx0]);
|
||||
let entry_tick2 = next_entry_mut(&mut cur_hash, i + 1, vec![]);
|
||||
|
||||
mint_ref_balance -= transfer_amount;
|
||||
transfer_amount -= 1; // Sneaky: change transfer_amount slightly to avoid DuplicateSignature errors
|
||||
|
||||
let entries = vec![entry0, entry_tick0, entry_tick1, entry1, entry_tick2];
|
||||
let blobs = entries.to_shared_blobs();
|
||||
index_blobs(&blobs, &leader.info.id, blob_idx, 1, 0);
|
||||
blob_idx += blobs.len() as u64;
|
||||
blobs.iter().for_each(|b| {
|
||||
let mut b_w = b.write().unwrap();
|
||||
b_w.set_id(&leader_keypair.pubkey());
|
||||
b_w.meta.set_addr(&tvu_addr);
|
||||
b_w.sign(&leader_keypair);
|
||||
});
|
||||
msgs.extend(blobs.into_iter());
|
||||
}
|
||||
|
||||
// send the blobs into the socket
|
||||
s_responder.send(msgs).expect("send");
|
||||
drop(s_responder);
|
||||
|
||||
// receive retransmitted messages
|
||||
let timer = Duration::new(1, 0);
|
||||
while let Ok(_msg) = r_reader.recv_timeout(timer) {
|
||||
info!("got msg");
|
||||
}
|
||||
|
||||
let working_bank = bank_forks.read().unwrap().working_bank();
|
||||
let final_mint_balance = working_bank.get_balance(&mint_keypair.pubkey());
|
||||
assert_eq!(final_mint_balance, mint_ref_balance);
|
||||
|
||||
let bob_balance = working_bank.get_balance(&bob_keypair.pubkey());
|
||||
assert_eq!(bob_balance, mint_balance - mint_ref_balance);
|
||||
|
||||
exit.store(true, Ordering::Relaxed);
|
||||
poh_service_exit.store(true, Ordering::Relaxed);
|
||||
poh_service.join().unwrap();
|
||||
tvu.join().unwrap();
|
||||
dr_l.join().unwrap();
|
||||
dr_2.join().unwrap();
|
||||
dr_1.join().unwrap();
|
||||
t_receiver.join().unwrap();
|
||||
t_responder.join().unwrap();
|
||||
}
|
||||
Blocktree::destroy(&blocktree_path).expect("Expected successful database destruction");
|
||||
let _ignored = remove_dir_all(&blocktree_path);
|
||||
}
|
||||
Reference in New Issue
Block a user