2018-05-11 23:31:32 -07:00
|
|
|
//! The `tvu` module implements the Transaction Validation Unit, a
|
2019-01-08 08:21:39 -08:00
|
|
|
//! multi-stage transaction validation pipeline in software.
|
2018-06-14 17:05:12 -07:00
|
|
|
//!
|
2018-12-07 14:09:29 -08:00
|
|
|
//! 1. BlobFetchStage
|
|
|
|
//! - Incoming blobs are picked up from the TVU sockets and repair socket.
|
|
|
|
//! 2. RetransmitStage
|
2018-06-15 14:49:22 -07:00
|
|
|
//! - Blobs are windowed until a contiguous chunk is available. This stage also repairs and
|
|
|
|
//! retransmits blobs that are in the queue.
|
2018-12-07 14:09:29 -08:00
|
|
|
//! 3. ReplayStage
|
2018-06-15 14:49:22 -07:00
|
|
|
//! - Transactions in blobs are processed and applied to the bank.
|
|
|
|
//! - TODO We need to verify the signatures in the blobs.
|
2019-01-03 21:29:21 -08:00
|
|
|
//! 4. StorageStage
|
2018-12-07 14:09:29 -08:00
|
|
|
//! - Generating the keys used to encrypt the ledger and sample it for storage mining.
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::bank::Bank;
|
|
|
|
use crate::blob_fetch_stage::BlobFetchStage;
|
|
|
|
use crate::cluster_info::ClusterInfo;
|
|
|
|
use crate::db_ledger::DbLedger;
|
2018-12-07 14:09:29 -08:00
|
|
|
use crate::replay_stage::{ReplayStage, ReplayStageReturnType};
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::retransmit_stage::RetransmitStage;
|
|
|
|
use crate::service::Service;
|
|
|
|
use crate::storage_stage::StorageStage;
|
2019-01-11 12:58:31 -08:00
|
|
|
use crate::vote_signer_proxy::VoteSignerProxy;
|
2018-11-16 08:04:46 -08:00
|
|
|
use solana_sdk::hash::Hash;
|
2018-12-03 10:26:28 -08:00
|
|
|
use solana_sdk::signature::Keypair;
|
2019-01-11 12:58:31 -08:00
|
|
|
use std::net::UdpSocket;
|
2018-09-25 15:41:29 -07:00
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
2018-05-11 23:31:32 -07:00
|
|
|
use std::sync::{Arc, RwLock};
|
2018-09-13 14:00:17 -07:00
|
|
|
use std::thread;
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-09-25 15:41:29 -07:00
|
|
|
#[derive(Debug, PartialEq, Eq, Clone)]
|
|
|
|
pub enum TvuReturnType {
|
2018-10-18 22:57:48 -07:00
|
|
|
LeaderRotation(u64, u64, Hash),
|
2018-09-25 15:41:29 -07:00
|
|
|
}
|
|
|
|
|
2018-05-11 23:31:32 -07:00
|
|
|
pub struct Tvu {
|
2018-07-03 21:14:08 -07:00
|
|
|
fetch_stage: BlobFetchStage,
|
2018-08-09 12:03:34 -07:00
|
|
|
retransmit_stage: RetransmitStage,
|
2018-12-07 14:09:29 -08:00
|
|
|
replay_stage: ReplayStage,
|
2018-10-08 13:12:33 -07:00
|
|
|
storage_stage: StorageStage,
|
2018-09-25 15:41:29 -07:00
|
|
|
exit: Arc<AtomicBool>,
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
|
2018-12-12 18:57:48 -08:00
|
|
|
pub struct Sockets {
|
|
|
|
pub fetch: Vec<UdpSocket>,
|
|
|
|
pub repair: UdpSocket,
|
|
|
|
pub retransmit: UdpSocket,
|
|
|
|
}
|
|
|
|
|
2018-05-11 23:31:32 -07:00
|
|
|
impl Tvu {
|
|
|
|
/// This service receives messages from a leader in the network and processes the transactions
|
2018-05-14 14:33:11 -07:00
|
|
|
/// on the bank state.
|
2018-05-11 23:31:32 -07:00
|
|
|
/// # Arguments
|
2018-12-12 18:57:48 -08:00
|
|
|
/// * `bank` - The bank state.
|
2018-10-08 13:12:33 -07:00
|
|
|
/// * `entry_height` - Initial ledger height
|
2018-12-12 18:57:48 -08:00
|
|
|
/// * `last_entry_id` - Hash of the last entry
|
2018-10-08 19:55:54 -07:00
|
|
|
/// * `cluster_info` - The cluster_info state.
|
2018-12-12 18:57:48 -08:00
|
|
|
/// * `sockets` - My fetch, repair, and restransmit sockets
|
|
|
|
/// * `db_ledger` - the ledger itself
|
2018-05-23 07:11:11 -07:00
|
|
|
pub fn new(
|
2019-01-11 12:58:31 -08:00
|
|
|
vote_signer: &Arc<VoteSignerProxy>,
|
2018-07-13 12:32:20 -07:00
|
|
|
bank: &Arc<Bank>,
|
2018-06-27 12:35:58 -07:00
|
|
|
entry_height: u64,
|
2018-11-12 12:41:19 -08:00
|
|
|
last_entry_id: Hash,
|
2018-12-10 11:38:29 -08:00
|
|
|
cluster_info: &Arc<RwLock<ClusterInfo>>,
|
2018-12-12 18:57:48 -08:00
|
|
|
sockets: Sockets,
|
2018-12-18 15:18:57 -08:00
|
|
|
db_ledger: Arc<DbLedger>,
|
2018-05-23 07:11:11 -07:00
|
|
|
) -> Self {
|
2018-09-25 15:41:29 -07:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
2018-12-12 18:57:48 -08:00
|
|
|
let keypair: Arc<Keypair> = cluster_info
|
|
|
|
.read()
|
|
|
|
.expect("Unable to read from cluster_info during Tvu creation")
|
|
|
|
.keypair
|
|
|
|
.clone();
|
|
|
|
|
|
|
|
let Sockets {
|
|
|
|
repair: repair_socket,
|
|
|
|
fetch: fetch_sockets,
|
|
|
|
retransmit: retransmit_socket,
|
|
|
|
} = sockets;
|
2018-09-25 15:41:29 -07:00
|
|
|
|
2018-08-30 12:07:54 -07:00
|
|
|
let repair_socket = Arc::new(repair_socket);
|
2018-09-14 16:56:06 -07:00
|
|
|
let mut blob_sockets: Vec<Arc<UdpSocket>> =
|
2018-12-07 14:09:29 -08:00
|
|
|
fetch_sockets.into_iter().map(Arc::new).collect();
|
2018-09-14 16:56:06 -07:00
|
|
|
blob_sockets.push(repair_socket.clone());
|
|
|
|
let (fetch_stage, blob_fetch_receiver) =
|
2018-09-18 08:02:57 -07:00
|
|
|
BlobFetchStage::new_multi_socket(blob_sockets, exit.clone());
|
2018-11-24 19:32:33 -08:00
|
|
|
|
2018-05-11 23:31:32 -07:00
|
|
|
//TODO
|
|
|
|
//the packets coming out of blob_receiver need to be sent to the GPU and verified
|
|
|
|
//then sent to the window, which does the erasure coding reconstruction
|
2018-08-09 12:03:34 -07:00
|
|
|
let (retransmit_stage, blob_window_receiver) = RetransmitStage::new(
|
2019-01-02 00:46:15 -08:00
|
|
|
bank,
|
2019-01-03 21:29:21 -08:00
|
|
|
db_ledger.clone(),
|
2018-10-08 19:55:54 -07:00
|
|
|
&cluster_info,
|
2018-11-05 09:47:41 -08:00
|
|
|
bank.tick_height(),
|
2018-06-27 12:35:58 -07:00
|
|
|
entry_height,
|
2018-08-28 16:32:40 -07:00
|
|
|
Arc::new(retransmit_socket),
|
2018-08-30 12:07:54 -07:00
|
|
|
repair_socket,
|
2018-07-05 12:01:40 -07:00
|
|
|
blob_fetch_receiver,
|
2018-10-25 16:58:40 -07:00
|
|
|
bank.leader_scheduler.clone(),
|
2018-05-22 15:17:59 -07:00
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-12-07 14:09:29 -08:00
|
|
|
let (replay_stage, ledger_entry_receiver) = ReplayStage::new(
|
2018-11-07 18:25:36 -08:00
|
|
|
keypair.clone(),
|
2019-01-11 12:58:31 -08:00
|
|
|
vote_signer.clone(),
|
2018-07-13 12:32:20 -07:00
|
|
|
bank.clone(),
|
2018-12-10 11:38:29 -08:00
|
|
|
cluster_info.clone(),
|
2018-07-13 12:32:20 -07:00
|
|
|
blob_window_receiver,
|
2018-09-25 15:41:29 -07:00
|
|
|
exit.clone(),
|
2018-10-10 16:49:41 -07:00
|
|
|
entry_height,
|
2018-11-12 12:41:19 -08:00
|
|
|
last_entry_id,
|
2018-07-13 12:32:20 -07:00
|
|
|
);
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2018-11-07 18:25:36 -08:00
|
|
|
let storage_stage = StorageStage::new(
|
2018-11-02 08:40:29 -07:00
|
|
|
&bank.storage_state,
|
2019-01-03 21:29:21 -08:00
|
|
|
ledger_entry_receiver,
|
|
|
|
Some(db_ledger),
|
2018-11-07 18:25:36 -08:00
|
|
|
keypair,
|
|
|
|
exit.clone(),
|
|
|
|
entry_height,
|
2018-10-08 13:12:33 -07:00
|
|
|
);
|
2018-10-23 14:42:48 -07:00
|
|
|
|
2018-05-23 10:54:48 -07:00
|
|
|
Tvu {
|
2018-07-03 21:14:08 -07:00
|
|
|
fetch_stage,
|
2018-08-09 12:03:34 -07:00
|
|
|
retransmit_stage,
|
2018-12-07 14:09:29 -08:00
|
|
|
replay_stage,
|
2018-10-08 13:12:33 -07:00
|
|
|
storage_stage,
|
2018-09-25 15:41:29 -07:00
|
|
|
exit,
|
2018-05-23 10:54:48 -07:00
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
2018-07-09 13:53:18 -07:00
|
|
|
|
2018-10-10 16:49:41 -07:00
|
|
|
pub fn is_exited(&self) -> bool {
|
|
|
|
self.exit.load(Ordering::Relaxed)
|
|
|
|
}
|
|
|
|
|
2018-10-25 16:58:40 -07:00
|
|
|
pub fn exit(&self) {
|
2018-09-25 15:41:29 -07:00
|
|
|
self.exit.store(true, Ordering::Relaxed);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn close(self) -> thread::Result<Option<TvuReturnType>> {
|
2018-07-09 13:53:18 -07:00
|
|
|
self.fetch_stage.close();
|
|
|
|
self.join()
|
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
|
2018-07-03 21:14:08 -07:00
|
|
|
impl Service for Tvu {
|
2018-09-25 15:41:29 -07:00
|
|
|
type JoinReturnType = Option<TvuReturnType>;
|
2018-07-03 21:14:08 -07:00
|
|
|
|
2018-09-25 15:41:29 -07:00
|
|
|
fn join(self) -> thread::Result<Option<TvuReturnType>> {
|
2018-10-10 16:49:41 -07:00
|
|
|
self.retransmit_stage.join()?;
|
2018-09-13 14:00:17 -07:00
|
|
|
self.fetch_stage.join()?;
|
2018-10-08 13:12:33 -07:00
|
|
|
self.storage_stage.join()?;
|
2018-12-07 14:09:29 -08:00
|
|
|
match self.replay_stage.join()? {
|
|
|
|
Some(ReplayStageReturnType::LeaderRotation(
|
2018-10-18 22:57:48 -07:00
|
|
|
tick_height,
|
|
|
|
entry_height,
|
|
|
|
last_entry_id,
|
|
|
|
)) => Ok(Some(TvuReturnType::LeaderRotation(
|
|
|
|
tick_height,
|
|
|
|
entry_height,
|
|
|
|
last_entry_id,
|
|
|
|
))),
|
2018-09-25 15:41:29 -07:00
|
|
|
_ => Ok(None),
|
|
|
|
}
|
2018-07-03 21:14:08 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-11 23:31:32 -07:00
|
|
|
#[cfg(test)]
|
2018-05-23 10:49:48 -07:00
|
|
|
pub mod tests {
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::bank::Bank;
|
|
|
|
use crate::cluster_info::{ClusterInfo, Node};
|
2019-01-09 14:33:44 -08:00
|
|
|
use crate::db_ledger::get_tmp_ledger_path;
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::db_ledger::DbLedger;
|
|
|
|
use crate::entry::Entry;
|
|
|
|
use crate::gossip_service::GossipService;
|
|
|
|
use crate::leader_scheduler::LeaderScheduler;
|
2018-12-14 12:36:50 -08:00
|
|
|
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::mint::Mint;
|
|
|
|
use crate::packet::SharedBlob;
|
|
|
|
use crate::service::Service;
|
|
|
|
use crate::streamer;
|
2018-12-12 18:57:48 -08:00
|
|
|
use crate::tvu::{Sockets, Tvu};
|
2019-01-11 12:58:31 -08:00
|
|
|
use crate::vote_signer_proxy::VoteSignerProxy;
|
2018-05-11 23:31:32 -07:00
|
|
|
use bincode::serialize;
|
2018-11-16 08:04:46 -08:00
|
|
|
use solana_sdk::hash::Hash;
|
2018-12-03 10:26:28 -08:00
|
|
|
use solana_sdk::signature::{Keypair, KeypairUtil};
|
2018-12-04 20:19:48 -08:00
|
|
|
use solana_sdk::system_transaction::SystemTransaction;
|
2018-11-29 16:18:47 -08:00
|
|
|
use solana_sdk::transaction::Transaction;
|
2019-01-11 12:58:31 -08:00
|
|
|
use solana_vote_signer::rpc::LocalVoteSigner;
|
2018-11-24 19:32:33 -08:00
|
|
|
use std::fs::remove_dir_all;
|
2018-05-27 18:21:39 -07:00
|
|
|
use std::net::UdpSocket;
|
2018-09-25 15:41:29 -07:00
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
2018-05-11 23:31:32 -07:00
|
|
|
use std::sync::mpsc::channel;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
use std::time::Duration;
|
|
|
|
|
2019-01-08 13:50:29 -08:00
|
|
|
fn new_gossip(
|
2018-10-08 19:55:54 -07:00
|
|
|
cluster_info: Arc<RwLock<ClusterInfo>>,
|
2018-08-28 16:32:40 -07:00
|
|
|
gossip: UdpSocket,
|
2018-05-27 18:21:39 -07:00
|
|
|
exit: Arc<AtomicBool>,
|
2019-01-08 13:50:29 -08:00
|
|
|
) -> GossipService {
|
|
|
|
GossipService::new(&cluster_info, None, gossip, exit)
|
2018-05-27 18:21:39 -07:00
|
|
|
}
|
2018-08-03 11:06:06 -07:00
|
|
|
|
2018-12-07 14:09:29 -08:00
|
|
|
/// Test that message sent from leader to target1 and replayed to target2
|
2018-05-11 23:31:32 -07:00
|
|
|
#[test]
|
2018-11-13 17:13:25 -08:00
|
|
|
#[ignore]
|
2018-12-07 14:09:29 -08:00
|
|
|
fn test_replay() {
|
2018-12-14 12:36:50 -08:00
|
|
|
solana_logger::setup();
|
2018-08-28 16:32:40 -07:00
|
|
|
let leader = Node::new_localhost();
|
2018-08-09 07:56:04 -07:00
|
|
|
let target1_keypair = Keypair::new();
|
2018-08-28 16:32:40 -07:00
|
|
|
let target1 = Node::new_localhost_with_pubkey(target1_keypair.pubkey());
|
|
|
|
let target2 = Node::new_localhost();
|
2018-05-11 23:31:32 -07:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
|
|
|
|
2018-10-08 19:55:54 -07:00
|
|
|
//start cluster_info_l
|
2018-11-19 11:25:14 -08:00
|
|
|
let mut cluster_info_l = ClusterInfo::new(leader.info.clone());
|
2018-10-08 19:55:54 -07:00
|
|
|
cluster_info_l.set_leader(leader.info.id);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-10-08 19:55:54 -07:00
|
|
|
let cref_l = Arc::new(RwLock::new(cluster_info_l));
|
2019-01-08 13:50:29 -08:00
|
|
|
let dr_l = new_gossip(cref_l, leader.sockets.gossip, exit.clone());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-10-08 19:55:54 -07:00
|
|
|
//start cluster_info2
|
2018-11-19 11:25:14 -08:00
|
|
|
let mut cluster_info2 = ClusterInfo::new(target2.info.clone());
|
2018-11-15 13:23:26 -08:00
|
|
|
cluster_info2.insert_info(leader.info.clone());
|
2018-10-08 19:55:54 -07:00
|
|
|
cluster_info2.set_leader(leader.info.id);
|
2018-08-31 00:10:39 -07:00
|
|
|
let leader_id = leader.info.id;
|
2018-10-08 19:55:54 -07:00
|
|
|
let cref2 = Arc::new(RwLock::new(cluster_info2));
|
2019-01-08 13:50:29 -08:00
|
|
|
let dr_2 = new_gossip(cref2, target2.sockets.gossip, exit.clone());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
// 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();
|
2018-12-07 14:09:29 -08:00
|
|
|
let blob_sockets: Vec<Arc<UdpSocket>> =
|
|
|
|
target2.sockets.tvu.into_iter().map(Arc::new).collect();
|
2018-09-14 16:56:06 -07:00
|
|
|
|
2018-09-18 08:02:57 -07:00
|
|
|
let t_receiver = streamer::blob_receiver(blob_sockets[0].clone(), exit.clone(), s_reader);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
// simulate leader sending messages
|
|
|
|
let (s_responder, r_responder) = channel();
|
2018-07-11 07:38:57 -07:00
|
|
|
let t_responder = streamer::responder(
|
2018-12-07 14:09:29 -08:00
|
|
|
"test_replay",
|
2018-11-05 09:50:58 -08:00
|
|
|
Arc::new(leader.sockets.retransmit),
|
2018-07-11 07:38:57 -07:00
|
|
|
r_responder,
|
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
let starting_balance = 10_000;
|
2018-05-14 14:39:34 -07:00
|
|
|
let mint = Mint::new(starting_balance);
|
2018-12-07 14:09:29 -08:00
|
|
|
let tvu_addr = target1.info.tvu;
|
2018-10-25 16:58:40 -07:00
|
|
|
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::from_bootstrap_leader(
|
|
|
|
leader_id,
|
|
|
|
)));
|
|
|
|
let mut bank = Bank::new(&mint);
|
|
|
|
bank.leader_scheduler = leader_scheduler;
|
|
|
|
let bank = Arc::new(bank);
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2018-10-08 19:55:54 -07:00
|
|
|
//start cluster_info1
|
2018-11-19 11:25:14 -08:00
|
|
|
let mut cluster_info1 = ClusterInfo::new(target1.info.clone());
|
2018-11-15 13:23:26 -08:00
|
|
|
cluster_info1.insert_info(leader.info.clone());
|
2018-10-08 19:55:54 -07:00
|
|
|
cluster_info1.set_leader(leader.info.id);
|
|
|
|
let cref1 = Arc::new(RwLock::new(cluster_info1));
|
2019-01-08 13:50:29 -08:00
|
|
|
let dr_1 = new_gossip(cref1.clone(), target1.sockets.gossip, exit.clone());
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2018-11-12 12:41:19 -08:00
|
|
|
let mut cur_hash = Hash::default();
|
2018-12-07 14:09:29 -08:00
|
|
|
let db_ledger_path = get_tmp_ledger_path("test_replay");
|
2018-11-24 19:32:33 -08:00
|
|
|
let db_ledger =
|
|
|
|
DbLedger::open(&db_ledger_path).expect("Expected to successfully open ledger");
|
2019-01-11 12:58:31 -08:00
|
|
|
let vote_account_keypair = Arc::new(Keypair::new());
|
|
|
|
let vote_signer =
|
|
|
|
VoteSignerProxy::new(&vote_account_keypair, Box::new(LocalVoteSigner::default()));
|
2018-05-23 08:29:24 -07:00
|
|
|
let tvu = Tvu::new(
|
2019-01-11 12:58:31 -08:00
|
|
|
&Arc::new(vote_signer),
|
2018-07-13 12:32:20 -07:00
|
|
|
&bank,
|
2018-06-27 12:35:58 -07:00
|
|
|
0,
|
2018-11-12 12:41:19 -08:00
|
|
|
cur_hash,
|
2018-12-10 11:38:29 -08:00
|
|
|
&cref1,
|
2018-12-12 18:57:48 -08:00
|
|
|
{
|
|
|
|
Sockets {
|
|
|
|
repair: target1.sockets.repair,
|
|
|
|
retransmit: target1.sockets.retransmit,
|
|
|
|
fetch: target1.sockets.tvu,
|
|
|
|
}
|
|
|
|
},
|
2018-12-18 15:18:57 -08:00
|
|
|
Arc::new(db_ledger),
|
2018-05-23 08:29:24 -07:00
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
let mut alice_ref_balance = starting_balance;
|
2018-09-03 03:22:47 -07:00
|
|
|
let mut msgs = Vec::new();
|
2018-11-07 13:18:14 -08:00
|
|
|
let mut blob_idx = 0;
|
2018-06-20 11:40:41 -07:00
|
|
|
let num_transfers = 10;
|
2018-05-11 23:31:32 -07:00
|
|
|
let transfer_amount = 501;
|
2018-08-09 07:56:04 -07:00
|
|
|
let bob_keypair = Keypair::new();
|
2018-06-20 11:40:41 -07:00
|
|
|
for i in 0..num_transfers {
|
2018-12-10 20:03:04 -08:00
|
|
|
let entry0 = Entry::new(&cur_hash, 0, i, vec![]);
|
2018-11-12 12:41:19 -08:00
|
|
|
cur_hash = entry0.id;
|
2018-11-05 09:47:41 -08:00
|
|
|
bank.register_tick(&cur_hash);
|
2018-12-10 20:03:04 -08:00
|
|
|
let entry_tick0 = Entry::new(&cur_hash, 0, i + 1, vec![]);
|
2018-11-12 12:41:19 -08:00
|
|
|
cur_hash = entry_tick0.id;
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-09-17 13:36:31 -07:00
|
|
|
let tx0 = Transaction::system_new(
|
2018-05-14 14:39:34 -07:00
|
|
|
&mint.keypair(),
|
2018-05-11 23:31:32 -07:00
|
|
|
bob_keypair.pubkey(),
|
|
|
|
transfer_amount,
|
|
|
|
cur_hash,
|
|
|
|
);
|
2018-11-05 09:47:41 -08:00
|
|
|
bank.register_tick(&cur_hash);
|
2018-12-10 20:03:04 -08:00
|
|
|
let entry_tick1 = Entry::new(&cur_hash, 0, i + 1, vec![]);
|
2018-11-12 12:41:19 -08:00
|
|
|
cur_hash = entry_tick1.id;
|
2018-12-10 20:03:04 -08:00
|
|
|
let entry1 = Entry::new(&cur_hash, 0, i + num_transfers, vec![tx0]);
|
2018-11-12 12:41:19 -08:00
|
|
|
bank.register_tick(&entry1.id);
|
2018-12-10 20:03:04 -08:00
|
|
|
let entry_tick2 = Entry::new(&entry1.id, 0, i + 1, vec![]);
|
2018-11-12 12:41:19 -08:00
|
|
|
cur_hash = entry_tick2.id;
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
alice_ref_balance -= transfer_amount;
|
|
|
|
|
2018-11-12 12:41:19 -08:00
|
|
|
for entry in vec![entry0, entry_tick0, entry_tick1, entry1, entry_tick2] {
|
2018-12-08 21:44:20 -08:00
|
|
|
let b = SharedBlob::default();
|
2018-06-25 17:16:32 -07:00
|
|
|
{
|
2018-09-26 09:50:12 -07:00
|
|
|
let mut w = b.write().unwrap();
|
2018-11-07 13:18:14 -08:00
|
|
|
w.set_index(blob_idx).unwrap();
|
|
|
|
blob_idx += 1;
|
|
|
|
w.set_id(&leader_id).unwrap();
|
2018-06-25 17:16:32 -07:00
|
|
|
|
|
|
|
let serialized_entry = serialize(&entry).unwrap();
|
|
|
|
|
|
|
|
w.data_mut()[..serialized_entry.len()].copy_from_slice(&serialized_entry);
|
|
|
|
w.set_size(serialized_entry.len());
|
2018-12-07 14:09:29 -08:00
|
|
|
w.meta.set_addr(&tvu_addr);
|
2018-06-25 17:16:32 -07:00
|
|
|
}
|
2018-09-03 03:22:47 -07:00
|
|
|
msgs.push(b);
|
2018-06-20 11:40:41 -07:00
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// send the blobs into the socket
|
|
|
|
s_responder.send(msgs).expect("send");
|
2018-07-05 15:41:03 -07:00
|
|
|
drop(s_responder);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
// receive retransmitted messages
|
|
|
|
let timer = Duration::new(1, 0);
|
2018-09-18 08:02:57 -07:00
|
|
|
while let Ok(_msg) = r_reader.recv_timeout(timer) {
|
|
|
|
trace!("got msg");
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
|
2018-07-02 16:31:10 -07:00
|
|
|
let alice_balance = bank.get_balance(&mint.keypair().pubkey());
|
2018-05-11 23:31:32 -07:00
|
|
|
assert_eq!(alice_balance, alice_ref_balance);
|
|
|
|
|
2018-07-02 16:31:10 -07:00
|
|
|
let bob_balance = bank.get_balance(&bob_keypair.pubkey());
|
2018-05-11 23:31:32 -07:00
|
|
|
assert_eq!(bob_balance, starting_balance - alice_ref_balance);
|
|
|
|
|
2018-07-09 13:53:18 -07:00
|
|
|
tvu.close().expect("close");
|
2018-09-25 15:41:29 -07:00
|
|
|
exit.store(true, Ordering::Relaxed);
|
2019-01-08 13:50:29 -08:00
|
|
|
dr_l.join().expect("join");
|
|
|
|
dr_2.join().expect("join");
|
|
|
|
dr_1.join().expect("join");
|
2018-05-11 23:31:32 -07:00
|
|
|
t_receiver.join().expect("join");
|
|
|
|
t_responder.join().expect("join");
|
2018-12-20 09:45:49 -08:00
|
|
|
DbLedger::destroy(&db_ledger_path).expect("Expected successful database destruction");
|
2018-11-24 19:32:33 -08:00
|
|
|
let _ignored = remove_dir_all(&db_ledger_path);
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
}
|