2019-11-08 15:43:18 -08:00
|
|
|
//! The `tvu` module implements the Transaction Validation Unit, a multi-stage transaction
|
|
|
|
//! validation pipeline in software.
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2019-11-20 15:43:10 -08:00
|
|
|
use crate::{
|
|
|
|
blockstream_service::BlockstreamService,
|
|
|
|
cluster_info::ClusterInfo,
|
|
|
|
commitment::BlockCommitmentCache,
|
|
|
|
ledger_cleanup_service::LedgerCleanupService,
|
|
|
|
poh_recorder::PohRecorder,
|
2019-12-04 10:17:17 -08:00
|
|
|
replay_stage::{ReplayStage, ReplayStageConfig},
|
2019-11-20 15:43:10 -08:00
|
|
|
retransmit_stage::RetransmitStage,
|
2020-02-04 18:50:24 -08:00
|
|
|
rewards_recorder_service::RewardsRecorderSender,
|
2019-11-20 15:43:10 -08:00
|
|
|
rpc_subscriptions::RpcSubscriptions,
|
|
|
|
shred_fetch_stage::ShredFetchStage,
|
|
|
|
sigverify_shreds::ShredSigVerifier,
|
|
|
|
sigverify_stage::{DisabledSigVerifier, SigVerifyStage},
|
|
|
|
snapshot_packager_service::SnapshotPackagerService,
|
|
|
|
storage_stage::{StorageStage, StorageState},
|
|
|
|
};
|
2019-10-28 16:07:51 -07:00
|
|
|
use crossbeam_channel::unbounded;
|
2019-10-18 09:28:51 -07:00
|
|
|
use solana_ledger::leader_schedule_cache::LeaderScheduleCache;
|
2019-11-20 15:43:10 -08:00
|
|
|
use solana_ledger::{
|
|
|
|
bank_forks::BankForks,
|
2020-01-13 13:13:52 -08:00
|
|
|
blockstore::{Blockstore, CompletedSlotsReceiver},
|
|
|
|
blockstore_processor::TransactionStatusSender,
|
2019-11-20 15:43:10 -08:00
|
|
|
};
|
|
|
|
use solana_sdk::{
|
|
|
|
pubkey::Pubkey,
|
|
|
|
signature::{Keypair, KeypairUtil},
|
|
|
|
};
|
|
|
|
use std::{
|
|
|
|
net::UdpSocket,
|
|
|
|
path::PathBuf,
|
|
|
|
sync::{
|
|
|
|
atomic::AtomicBool,
|
|
|
|
mpsc::{channel, Receiver},
|
|
|
|
Arc, Mutex, RwLock,
|
|
|
|
},
|
|
|
|
thread,
|
|
|
|
};
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
pub struct Tvu {
|
2019-10-07 11:08:01 -07:00
|
|
|
fetch_stage: ShredFetchStage,
|
2019-10-28 16:07:51 -07:00
|
|
|
sigverify_stage: SigVerifyStage,
|
2018-08-09 12:03:34 -07:00
|
|
|
retransmit_stage: RetransmitStage,
|
2018-12-07 14:09:29 -08:00
|
|
|
replay_stage: ReplayStage,
|
2019-02-21 15:16:09 -08:00
|
|
|
blockstream_service: Option<BlockstreamService>,
|
2019-07-20 13:13:55 -07:00
|
|
|
ledger_cleanup_service: Option<LedgerCleanupService>,
|
2018-10-08 13:12:33 -07:00
|
|
|
storage_stage: StorageStage,
|
2019-07-31 17:58:10 -07:00
|
|
|
snapshot_packager_service: Option<SnapshotPackagerService>,
|
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,
|
2019-10-10 13:24:03 -07:00
|
|
|
pub retransmit: Vec<UdpSocket>,
|
2019-08-20 17:16:06 -07:00
|
|
|
pub forwards: Vec<UdpSocket>,
|
2018-12-12 18:57:48 -08:00
|
|
|
}
|
|
|
|
|
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-10-08 19:55:54 -07:00
|
|
|
/// * `cluster_info` - The cluster_info state.
|
2019-02-21 11:37:48 -08:00
|
|
|
/// * `sockets` - fetch, repair, and retransmit sockets
|
2020-01-13 13:13:52 -08:00
|
|
|
/// * `blockstore` - the ledger itself
|
2019-01-31 13:43:22 -08:00
|
|
|
#[allow(clippy::new_ret_no_self, clippy::too_many_arguments)]
|
2019-12-04 10:17:17 -08:00
|
|
|
pub fn new(
|
2019-03-09 19:28:43 -08:00
|
|
|
vote_account: &Pubkey,
|
2019-12-04 10:17:17 -08:00
|
|
|
voting_keypair: Option<Arc<Keypair>>,
|
2019-05-15 15:19:29 -07:00
|
|
|
storage_keypair: &Arc<Keypair>,
|
2019-02-21 11:19:45 -08:00
|
|
|
bank_forks: &Arc<RwLock<BankForks>>,
|
2018-12-10 11:38:29 -08:00
|
|
|
cluster_info: &Arc<RwLock<ClusterInfo>>,
|
2018-12-12 18:57:48 -08:00
|
|
|
sockets: Sockets,
|
2020-01-13 13:13:52 -08:00
|
|
|
blockstore: Arc<Blockstore>,
|
2019-01-28 14:53:50 -08:00
|
|
|
storage_state: &StorageState,
|
2019-07-30 19:47:24 -07:00
|
|
|
blockstream_unix_socket: Option<&PathBuf>,
|
2019-07-20 13:13:55 -07:00
|
|
|
max_ledger_slots: Option<u64>,
|
2019-02-04 15:33:43 -08:00
|
|
|
ledger_signal_receiver: Receiver<bool>,
|
2019-02-18 18:08:54 -08:00
|
|
|
subscriptions: &Arc<RpcSubscriptions>,
|
2019-03-03 16:44:06 -08:00
|
|
|
poh_recorder: &Arc<Mutex<PohRecorder>>,
|
2019-04-19 02:39:44 -07:00
|
|
|
leader_schedule_cache: &Arc<LeaderScheduleCache>,
|
2019-03-04 16:33:14 -08:00
|
|
|
exit: &Arc<AtomicBool>,
|
2019-05-09 14:10:04 -07:00
|
|
|
completed_slots_receiver: CompletedSlotsReceiver,
|
2019-11-04 15:44:27 -08:00
|
|
|
block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
|
2019-10-28 16:07:51 -07:00
|
|
|
sigverify_disabled: bool,
|
2020-01-27 16:49:25 -08:00
|
|
|
cfg: Option<Arc<AtomicBool>>,
|
2019-11-18 18:05:02 -08:00
|
|
|
shred_version: u16,
|
2019-11-20 15:43:10 -08:00
|
|
|
transaction_status_sender: Option<TransactionStatusSender>,
|
2020-02-11 17:01:49 -08:00
|
|
|
rewards_recorder_sender: Option<RewardsRecorderSender>,
|
2019-12-04 10:17:17 -08:00
|
|
|
) -> Self {
|
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,
|
2019-10-10 13:24:03 -07:00
|
|
|
retransmit: retransmit_sockets,
|
2019-08-20 17:16:06 -07:00
|
|
|
forwards: tvu_forward_sockets,
|
2018-12-12 18:57:48 -08:00
|
|
|
} = sockets;
|
2018-09-25 15:41:29 -07:00
|
|
|
|
2019-08-20 17:16:06 -07:00
|
|
|
let (fetch_sender, fetch_receiver) = channel();
|
2019-01-31 13:43:22 -08:00
|
|
|
|
2018-08-30 12:07:54 -07:00
|
|
|
let repair_socket = Arc::new(repair_socket);
|
2019-10-09 13:11:19 -07:00
|
|
|
let fetch_sockets: Vec<Arc<UdpSocket>> = fetch_sockets.into_iter().map(Arc::new).collect();
|
2019-10-09 10:36:05 -07:00
|
|
|
let forward_sockets: Vec<Arc<UdpSocket>> =
|
2019-08-20 17:16:06 -07:00
|
|
|
tvu_forward_sockets.into_iter().map(Arc::new).collect();
|
2019-10-09 13:11:19 -07:00
|
|
|
let fetch_stage = ShredFetchStage::new(
|
|
|
|
fetch_sockets,
|
|
|
|
forward_sockets,
|
|
|
|
repair_socket.clone(),
|
|
|
|
&fetch_sender,
|
|
|
|
&exit,
|
|
|
|
);
|
2018-11-24 19:32:33 -08:00
|
|
|
|
2019-10-28 16:07:51 -07:00
|
|
|
let (verified_sender, verified_receiver) = unbounded();
|
|
|
|
let sigverify_stage = if !sigverify_disabled {
|
|
|
|
SigVerifyStage::new(
|
|
|
|
fetch_receiver,
|
2019-12-19 23:27:54 -08:00
|
|
|
verified_sender,
|
2019-10-28 16:07:51 -07:00
|
|
|
ShredSigVerifier::new(bank_forks.clone(), leader_schedule_cache.clone()),
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
SigVerifyStage::new(
|
|
|
|
fetch_receiver,
|
2019-12-19 23:27:54 -08:00
|
|
|
verified_sender,
|
2019-10-28 16:07:51 -07:00
|
|
|
DisabledSigVerifier::default(),
|
|
|
|
)
|
|
|
|
};
|
|
|
|
|
2019-02-04 15:33:43 -08:00
|
|
|
let retransmit_stage = RetransmitStage::new(
|
2019-04-22 15:21:10 -07:00
|
|
|
bank_forks.clone(),
|
2019-04-22 18:41:01 -07:00
|
|
|
leader_schedule_cache,
|
2020-01-13 13:13:52 -08:00
|
|
|
blockstore.clone(),
|
2018-10-08 19:55:54 -07:00
|
|
|
&cluster_info,
|
2019-10-10 13:24:03 -07:00
|
|
|
Arc::new(retransmit_sockets),
|
2018-08-30 12:07:54 -07:00
|
|
|
repair_socket,
|
2019-10-28 16:07:51 -07:00
|
|
|
verified_receiver,
|
2019-03-04 20:50:02 -08:00
|
|
|
&exit,
|
2019-05-09 14:10:04 -07:00
|
|
|
completed_slots_receiver,
|
2019-05-13 15:37:50 -07:00
|
|
|
*bank_forks.read().unwrap().working_bank().epoch_schedule(),
|
2019-11-15 08:36:33 -08:00
|
|
|
cfg,
|
2019-11-18 18:05:02 -08:00
|
|
|
shred_version,
|
2018-05-22 15:17:59 -07:00
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2019-07-20 13:13:55 -07:00
|
|
|
let (blockstream_slot_sender, blockstream_slot_receiver) = channel();
|
|
|
|
let (ledger_cleanup_slot_sender, ledger_cleanup_slot_receiver) = channel();
|
2019-07-31 17:58:10 -07:00
|
|
|
let (snapshot_packager_service, snapshot_package_sender) = {
|
|
|
|
let snapshot_config = { bank_forks.read().unwrap().snapshot_config().clone() };
|
|
|
|
if snapshot_config.is_some() {
|
|
|
|
// Start a snapshot packaging service
|
|
|
|
let (sender, receiver) = channel();
|
|
|
|
let snapshot_packager_service = SnapshotPackagerService::new(receiver, exit);
|
|
|
|
(Some(snapshot_packager_service), Some(sender))
|
|
|
|
} else {
|
|
|
|
(None, None)
|
|
|
|
}
|
|
|
|
};
|
2019-07-20 13:13:55 -07:00
|
|
|
|
2019-12-04 10:17:17 -08:00
|
|
|
let replay_stage_config = ReplayStageConfig {
|
|
|
|
my_pubkey: keypair.pubkey(),
|
|
|
|
vote_account: *vote_account,
|
2019-01-31 20:12:51 -08:00
|
|
|
voting_keypair,
|
2019-12-04 10:17:17 -08:00
|
|
|
exit: exit.clone(),
|
|
|
|
subscriptions: subscriptions.clone(),
|
|
|
|
leader_schedule_cache: leader_schedule_cache.clone(),
|
2019-12-18 11:50:09 -08:00
|
|
|
slot_full_senders: vec![blockstream_slot_sender],
|
|
|
|
latest_root_senders: vec![ledger_cleanup_slot_sender],
|
2019-07-31 17:58:10 -07:00
|
|
|
snapshot_package_sender,
|
2019-11-04 15:44:27 -08:00
|
|
|
block_commitment_cache,
|
2019-11-20 15:43:10 -08:00
|
|
|
transaction_status_sender,
|
2020-02-11 17:01:49 -08:00
|
|
|
rewards_recorder_sender,
|
2019-12-04 10:17:17 -08:00
|
|
|
};
|
|
|
|
|
2019-12-06 14:39:35 -08:00
|
|
|
let (replay_stage, root_bank_receiver) = ReplayStage::new(
|
|
|
|
replay_stage_config,
|
2020-01-13 13:13:52 -08:00
|
|
|
blockstore.clone(),
|
2019-12-06 14:39:35 -08:00
|
|
|
bank_forks.clone(),
|
|
|
|
cluster_info.clone(),
|
|
|
|
ledger_signal_receiver,
|
|
|
|
poh_recorder.clone(),
|
|
|
|
);
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2019-10-02 18:33:01 -07:00
|
|
|
let blockstream_service = if let Some(blockstream_unix_socket) = blockstream_unix_socket {
|
2019-02-28 01:14:37 -08:00
|
|
|
let blockstream_service = BlockstreamService::new(
|
2019-07-20 13:13:55 -07:00
|
|
|
blockstream_slot_receiver,
|
2020-01-13 13:13:52 -08:00
|
|
|
blockstore.clone(),
|
2019-10-02 18:33:01 -07:00
|
|
|
blockstream_unix_socket,
|
2019-03-04 20:50:02 -08:00
|
|
|
&exit,
|
2019-02-11 13:51:14 -08:00
|
|
|
);
|
2019-02-21 15:16:09 -08:00
|
|
|
Some(blockstream_service)
|
2019-02-11 13:51:14 -08:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
2019-02-11 10:36:59 -08:00
|
|
|
|
2019-07-20 13:13:55 -07:00
|
|
|
let ledger_cleanup_service = max_ledger_slots.map(|max_ledger_slots| {
|
|
|
|
LedgerCleanupService::new(
|
|
|
|
ledger_cleanup_slot_receiver,
|
2020-01-13 13:13:52 -08:00
|
|
|
blockstore.clone(),
|
2019-07-20 13:13:55 -07:00
|
|
|
max_ledger_slots,
|
|
|
|
&exit,
|
|
|
|
)
|
|
|
|
});
|
|
|
|
|
2018-11-07 18:25:36 -08:00
|
|
|
let storage_stage = StorageStage::new(
|
2019-01-28 14:53:50 -08:00
|
|
|
storage_state,
|
2019-06-11 18:27:47 -07:00
|
|
|
root_bank_receiver,
|
2020-01-13 13:13:52 -08:00
|
|
|
Some(blockstore),
|
2019-01-17 14:41:48 -08:00
|
|
|
&keypair,
|
2019-05-15 15:19:29 -07:00
|
|
|
storage_keypair,
|
2019-03-04 20:50:02 -08:00
|
|
|
&exit,
|
2019-04-24 22:34:10 -07:00
|
|
|
&bank_forks,
|
2019-01-17 14:41:48 -08:00
|
|
|
&cluster_info,
|
2018-10-08 13:12:33 -07:00
|
|
|
);
|
2018-10-23 14:42:48 -07:00
|
|
|
|
2019-02-11 17:56:52 -08:00
|
|
|
Tvu {
|
|
|
|
fetch_stage,
|
2019-10-28 16:07:51 -07:00
|
|
|
sigverify_stage,
|
2019-02-11 17:56:52 -08:00
|
|
|
retransmit_stage,
|
|
|
|
replay_stage,
|
2019-02-21 15:16:09 -08:00
|
|
|
blockstream_service,
|
2019-07-20 13:13:55 -07:00
|
|
|
ledger_cleanup_service,
|
2019-02-11 17:56:52 -08:00
|
|
|
storage_stage,
|
2019-07-31 17:58:10 -07:00
|
|
|
snapshot_packager_service,
|
2019-02-11 17:56:52 -08:00
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
2018-07-03 21:14:08 -07:00
|
|
|
|
2019-11-13 10:12:09 -08:00
|
|
|
pub fn join(self) -> thread::Result<()> {
|
2018-10-10 16:49:41 -07:00
|
|
|
self.retransmit_stage.join()?;
|
2018-09-13 14:00:17 -07:00
|
|
|
self.fetch_stage.join()?;
|
2019-10-28 16:07:51 -07:00
|
|
|
self.sigverify_stage.join()?;
|
2018-10-08 13:12:33 -07:00
|
|
|
self.storage_stage.join()?;
|
2019-02-21 15:16:09 -08:00
|
|
|
if self.blockstream_service.is_some() {
|
|
|
|
self.blockstream_service.unwrap().join()?;
|
2019-02-11 13:51:14 -08:00
|
|
|
}
|
2019-07-20 13:13:55 -07:00
|
|
|
if self.ledger_cleanup_service.is_some() {
|
|
|
|
self.ledger_cleanup_service.unwrap().join()?;
|
|
|
|
}
|
2019-02-08 08:06:27 -08:00
|
|
|
self.replay_stage.join()?;
|
2019-07-31 17:58:10 -07:00
|
|
|
if let Some(s) = self.snapshot_packager_service {
|
|
|
|
s.join()?;
|
|
|
|
}
|
2019-02-08 08:06:27 -08:00
|
|
|
Ok(())
|
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 {
|
2019-02-08 08:10:28 -08:00
|
|
|
use super::*;
|
2019-03-03 16:44:06 -08:00
|
|
|
use crate::banking_stage::create_test_recorder;
|
2018-12-07 19:16:27 -08:00
|
|
|
use crate::cluster_info::{ClusterInfo, Node};
|
2019-11-08 20:56:57 -08:00
|
|
|
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
|
2019-11-13 07:14:09 -08:00
|
|
|
use solana_ledger::create_new_tmp_ledger;
|
2019-02-21 11:19:45 -08:00
|
|
|
use solana_runtime::bank::Bank;
|
2019-03-04 19:02:03 -08:00
|
|
|
use std::sync::atomic::Ordering;
|
2018-08-03 11:06:06 -07:00
|
|
|
|
2019-02-04 15:33:43 -08:00
|
|
|
#[test]
|
|
|
|
fn test_tvu_exit() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let leader = Node::new_localhost();
|
|
|
|
let target1_keypair = Keypair::new();
|
2019-03-09 19:28:43 -08:00
|
|
|
let target1 = Node::new_localhost_with_pubkey(&target1_keypair.pubkey());
|
2019-02-04 15:33:43 -08:00
|
|
|
|
|
|
|
let starting_balance = 10_000;
|
2019-11-08 20:56:57 -08:00
|
|
|
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(starting_balance);
|
2019-02-21 11:19:45 -08:00
|
|
|
|
2019-11-08 20:56:57 -08:00
|
|
|
let bank_forks = BankForks::new(0, Bank::new(&genesis_config));
|
2019-02-04 15:33:43 -08:00
|
|
|
|
|
|
|
//start cluster_info1
|
2019-03-06 13:47:18 -08:00
|
|
|
let mut cluster_info1 = ClusterInfo::new_with_invalid_keypair(target1.info.clone());
|
2019-02-04 15:33:43 -08:00
|
|
|
cluster_info1.insert_info(leader.info.clone());
|
|
|
|
let cref1 = Arc::new(RwLock::new(cluster_info1));
|
|
|
|
|
2020-01-13 13:13:52 -08:00
|
|
|
let (blockstore_path, _) = create_new_tmp_ledger!(&genesis_config);
|
|
|
|
let (blockstore, l_receiver, completed_slots_receiver) =
|
|
|
|
Blockstore::open_with_signal(&blockstore_path)
|
2019-05-09 14:10:04 -07:00
|
|
|
.expect("Expected to successfully open ledger");
|
2020-01-13 13:13:52 -08:00
|
|
|
let blockstore = Arc::new(blockstore);
|
2019-03-03 16:44:06 -08:00
|
|
|
let bank = bank_forks.working_bank();
|
2019-03-29 20:00:36 -07:00
|
|
|
let (exit, poh_recorder, poh_service, _entry_receiver) =
|
2020-01-13 13:13:52 -08:00
|
|
|
create_test_recorder(&bank, &blockstore, None);
|
2019-03-08 18:29:08 -08:00
|
|
|
let voting_keypair = Keypair::new();
|
2019-05-15 15:19:29 -07:00
|
|
|
let storage_keypair = Arc::new(Keypair::new());
|
2019-04-19 02:39:44 -07:00
|
|
|
let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
|
2019-11-04 15:44:27 -08:00
|
|
|
let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
|
2019-02-11 17:56:52 -08:00
|
|
|
let tvu = Tvu::new(
|
2019-03-09 19:28:43 -08:00
|
|
|
&voting_keypair.pubkey(),
|
2019-12-04 10:17:17 -08:00
|
|
|
Some(Arc::new(voting_keypair)),
|
2019-05-15 15:19:29 -07:00
|
|
|
&storage_keypair,
|
2019-02-21 11:19:45 -08:00
|
|
|
&Arc::new(RwLock::new(bank_forks)),
|
2019-02-04 15:33:43 -08:00
|
|
|
&cref1,
|
|
|
|
{
|
|
|
|
Sockets {
|
|
|
|
repair: target1.sockets.repair,
|
2019-10-10 13:24:03 -07:00
|
|
|
retransmit: target1.sockets.retransmit_sockets,
|
2019-02-04 15:33:43 -08:00
|
|
|
fetch: target1.sockets.tvu,
|
2019-08-20 17:16:06 -07:00
|
|
|
forwards: target1.sockets.tvu_forwards,
|
2019-02-04 15:33:43 -08:00
|
|
|
}
|
|
|
|
},
|
2020-01-13 13:13:52 -08:00
|
|
|
blockstore,
|
2019-02-04 15:33:43 -08:00
|
|
|
&StorageState::default(),
|
|
|
|
None,
|
2019-07-20 13:13:55 -07:00
|
|
|
None,
|
2019-02-04 15:33:43 -08:00
|
|
|
l_receiver,
|
2020-01-20 13:08:29 -08:00
|
|
|
&Arc::new(RpcSubscriptions::new(&exit)),
|
2019-03-03 16:44:06 -08:00
|
|
|
&poh_recorder,
|
2019-04-19 02:39:44 -07:00
|
|
|
&leader_schedule_cache,
|
2019-03-04 16:33:14 -08:00
|
|
|
&exit,
|
2019-05-09 14:10:04 -07:00
|
|
|
completed_slots_receiver,
|
2019-11-04 15:44:27 -08:00
|
|
|
block_commitment_cache,
|
2019-10-28 16:07:51 -07:00
|
|
|
false,
|
2019-11-15 08:36:33 -08:00
|
|
|
None,
|
2019-11-18 18:05:02 -08:00
|
|
|
0,
|
2019-11-20 15:43:10 -08:00
|
|
|
None,
|
2020-02-04 18:50:24 -08:00
|
|
|
None,
|
2019-02-04 15:33:43 -08:00
|
|
|
);
|
2019-03-04 19:02:03 -08:00
|
|
|
exit.store(true, Ordering::Relaxed);
|
|
|
|
tvu.join().unwrap();
|
2019-03-04 20:50:02 -08:00
|
|
|
poh_service.join().unwrap();
|
2019-02-04 15:33:43 -08:00
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|