zecfoundation
/
zebra
mirror of https://github.com/ZcashFoundation/zebra.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

git ls-tree --full-tree -r --name-only HEAD | xargs sed -i -e 's/router_verifier/block_verifier_router/g' (#6998) 

cargo fmt --all
This commit is contained in:
teor 2023-06-20 17:11:04 +10:00 committed by GitHub
parent 795d40a003
commit 56a76385f0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 142 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
book/src/dev/diagrams/service-dependencies.svg
View File

@ -74,15 +74,15 @@
<path fill="none" stroke="#000000" d="M261.2822,-293.6228C291.5824,-281.7662 337.5245,-263.7888 371.0388,-250.6745"/>
<polygon fill="#000000" stroke="#000000" points="372.5364,-253.847 380.5734,-246.9436 369.9855,-247.3283 372.5364,-253.847"/>
</g>
<!-- router_verifier -->
<!-- block_verifier_router -->
<a id="node6" class="node" target="_blank" href="https://doc-internal.zebra.zfnd.org/zebra_consensus/chain/index.html">
<title>router_verifier</title>
<title>block_verifier_router</title>
<ellipse fill="transparent" stroke="#000000" cx="244.6515" cy="-234" rx="65.3859" ry="18"/>
<text text-anchor="middle" x="244.6515" y="-229.8" font-family="'Opens sans', sans-serif" font-size="14.00" fill="#000000">router_verifier</text>
<text text-anchor="middle" x="244.6515" y="-229.8" font-family="'Opens sans', sans-serif" font-size="14.00" fill="#000000">block_verifier_router</text>
</a>
<!-- inbound&#45;&gt;router_verifier -->
<!-- inbound&#45;&gt;block_verifier_router -->
<g id="edge9" class="edge">
<title>inbound&#45;&gt;router_verifier</title>
<title>inbound&#45;&gt;block_verifier_router</title>
<path fill="none" stroke="#000000" d="M233.4366,-287.8314C235.0409,-280.131 236.9485,-270.9743 238.7314,-262.4166"/>
<polygon fill="#000000" stroke="#000000" points="242.2022,-262.9169 240.8154,-252.4133 235.3494,-261.4892 242.2022,-262.9169"/>
</g>
@ -104,9 +104,9 @@
<path fill="none" stroke="#000000" d="M383.846,-360.9895C393.4567,-351.221 404.1854,-338.1106 409.6515,-324 417.2551,-304.3715 417.9695,-280.5065 416.9367,-262.2845"/>
<polygon fill="#000000" stroke="#000000" points="420.424,-261.9839 416.1656,-252.2825 413.4447,-262.522 420.424,-261.9839"/>
</g>
<!-- rpc_server&#45;&gt;router_verifier -->
<!-- rpc_server&#45;&gt;block_verifier_router -->
<g id="edge11" class="edge">
<title>rpc_server&#45;&gt;router_verifier</title>
<title>rpc_server&#45;&gt;block_verifier_router</title>
<path fill="none" stroke="#000000" stroke-dasharray="1,5" d="M350.1767,-360.6302C329.2082,-335.4681 290.2442,-288.7112 265.9807,-259.595"/>
<polygon fill="#000000" stroke="#000000" points="268.6447,-257.3247 259.5541,-251.8831 263.2672,-261.806 268.6447,-257.3247"/>
</g>
@ -116,9 +116,9 @@
<ellipse fill="transparent" stroke="#000000" cx="112.6515" cy="-90" rx="86.7972" ry="18"/>
<text text-anchor="middle" x="112.6515" y="-85.8" font-family="'Opens sans', sans-serif" font-size="14.00" fill="#000000">checkpoint_verifier</text>
</a>
<!-- router_verifier&#45;&gt;checkpoint_verifier -->
<!-- block_verifier_router&#45;&gt;checkpoint_verifier -->
<g id="edge6" class="edge">
<title>router_verifier&#45;&gt;checkpoint_verifier</title>
<title>block_verifier_router&#45;&gt;checkpoint_verifier</title>
<path fill="none" stroke="#000000" d="M216.638,-217.5178C201.6091,-207.8136 183.4054,-194.5969 169.6515,-180 151.8569,-161.1147 136.447,-135.8982 126.1523,-116.962"/>
<polygon fill="#000000" stroke="#000000" points="129.1594,-115.1615 121.3857,-107.9628 122.9735,-118.438 129.1594,-115.1615"/>
</g>
@ -128,9 +128,9 @@
<ellipse fill="transparent" stroke="#000000" cx="244.6515" cy="-162" rx="65.9697" ry="18"/>
<text text-anchor="middle" x="244.6515" y="-157.8" font-family="'Opens sans', sans-serif" font-size="14.00" fill="#000000">block_verifier</text>
</a>
<!-- router_verifier&#45;&gt;block_verifier -->
<!-- block_verifier_router&#45;&gt;block_verifier -->
<g id="edge17" class="edge">
<title>router_verifier&#45;&gt;block_verifier</title>
<title>block_verifier_router&#45;&gt;block_verifier</title>
<path fill="none" stroke="#000000" d="M244.6515,-215.8314C244.6515,-208.131 244.6515,-198.9743 244.6515,-190.4166"/>
<polygon fill="#000000" stroke="#000000" points="248.1516,-190.4132 244.6515,-180.4133 241.1516,-190.4133 248.1516,-190.4132"/>
</g>
@ -146,9 +146,9 @@
<ellipse fill="transparent" stroke="#000000" cx="364.6515" cy="-306" rx="36.4761" ry="18"/>
<text text-anchor="middle" x="364.6515" y="-301.8" font-family="'Opens sans', sans-serif" font-size="14.00" fill="#000000">syncer</text>
</a>
<!-- syncer&#45;&gt;router_verifier -->
<!-- syncer&#45;&gt;block_verifier_router -->
<g id="edge10" class="edge">
<title>syncer&#45;&gt;router_verifier</title>
<title>syncer&#45;&gt;block_verifier_router</title>
<path fill="none" stroke="#000000" d="M341.5143,-292.1177C324.2684,-281.7701 300.3887,-267.4423 280.6551,-255.6022"/>
<polygon fill="#000000" stroke="#000000" points="282.2946,-252.5042 271.9189,-250.3604 278.6931,-258.5067 282.2946,-252.5042"/>
</g>

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 11 KiB

After

Width:  |  Height:  |  Size: 11 KiB

10
book/src/dev/overview.md
View File

@ -56,18 +56,18 @@ digraph services {
inbound -> state
rpc_server -> state
mempool -> transaction_verifier
router_verifier -> checkpoint_verifier
block_verifier_router -> checkpoint_verifier
inbound -> mempool
rpc_server -> mempool
inbound -> router_verifier
syncer -> router_verifier
rpc_server -> router_verifier [style=dotted]
inbound -> block_verifier_router
syncer -> block_verifier_router
rpc_server -> block_verifier_router [style=dotted]
syncer -> peer_set
mempool -> peer_set
block_verifier -> state
checkpoint_verifier -> state
block_verifier -> transaction_verifier
router_verifier -> block_verifier
block_verifier_router -> block_verifier
rpc_server -> inbound [style=invis] // for layout of the diagram
}

52
zebra-consensus/src/router/tests.rs
View File

@ -66,14 +66,18 @@ async fn verifiers_from_network(
+ 'static,
) {
let state_service = zs::init_test(network);
let (router_verifier, _transaction_verifier, _groth16_download_handle, _max_checkpoint_height) =
crate::router::init(Config::default(), network, state_service.clone(), true).await;
let (
block_verifier_router,
_transaction_verifier,
_groth16_download_handle,
_max_checkpoint_height,
) = crate::router::init(Config::default(), network, state_service.clone(), true).await;
// We can drop the download task handle here, because:
// - if the download task fails, the tests will panic, and
// - if the download task hangs, the tests will hang.
(router_verifier, state_service)
(block_verifier_router, state_service)
}
static BLOCK_VERIFY_TRANSCRIPT_GENESIS: Lazy<
@ -165,15 +169,19 @@ async fn verify_checkpoint(config: Config) -> Result<(), Report> {
// init_from_verifiers.
//
// Download task panics and timeouts are propagated to the tests that use Groth16 verifiers.
let (router_verifier, _transaction_verifier, _groth16_download_handle, _max_checkpoint_height) =
super::init(config.clone(), network, zs::init_test(network), true).await;
let (
block_verifier_router,
_transaction_verifier,
_groth16_download_handle,
_max_checkpoint_height,
) = super::init(config.clone(), network, zs::init_test(network), true).await;
// Add a timeout layer
let router_verifier =
TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(router_verifier);
let block_verifier_router =
TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(block_verifier_router);
let transcript = Transcript::from(BLOCK_VERIFY_TRANSCRIPT_GENESIS.iter().cloned());
transcript.check(router_verifier).await.unwrap();
transcript.check(block_verifier_router).await.unwrap();
Ok(())
}
@ -194,11 +202,11 @@ async fn verify_fail_no_coinbase() -> Result<(), Report> {
let (router, state_service) = verifiers_from_network(Network::Mainnet).await;
// Add a timeout layer
let router_verifier =
let block_verifier_router =
TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(router);
let transcript = Transcript::from(NO_COINBASE_TRANSCRIPT.iter().cloned());
transcript.check(router_verifier).await.unwrap();
transcript.check(block_verifier_router).await.unwrap();
let transcript = Transcript::from(NO_COINBASE_STATE_TRANSCRIPT.iter().cloned());
transcript.check(state_service).await.unwrap();
@ -216,14 +224,14 @@ async fn round_trip_checkpoint_test() -> Result<(), Report> {
async fn round_trip_checkpoint() -> Result<(), Report> {
let _init_guard = zebra_test::init();
let (router_verifier, state_service) = verifiers_from_network(Network::Mainnet).await;
let (block_verifier_router, state_service) = verifiers_from_network(Network::Mainnet).await;
// Add a timeout layer
let router_verifier =
TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(router_verifier);
let block_verifier_router =
TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(block_verifier_router);
let transcript = Transcript::from(BLOCK_VERIFY_TRANSCRIPT_GENESIS.iter().cloned());
transcript.check(router_verifier).await.unwrap();
transcript.check(block_verifier_router).await.unwrap();
let transcript = Transcript::from(STATE_VERIFY_TRANSCRIPT_GENESIS.iter().cloned());
transcript.check(state_service).await.unwrap();
@ -241,20 +249,26 @@ async fn verify_fail_add_block_checkpoint_test() -> Result<(), Report> {
async fn verify_fail_add_block_checkpoint() -> Result<(), Report> {
let _init_guard = zebra_test::init();
let (router_verifier, state_service) = verifiers_from_network(Network::Mainnet).await;
let (block_verifier_router, state_service) = verifiers_from_network(Network::Mainnet).await;
// Add a timeout layer
let router_verifier =
TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(router_verifier);
let block_verifier_router =
TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(block_verifier_router);
let transcript = Transcript::from(BLOCK_VERIFY_TRANSCRIPT_GENESIS.iter().cloned());
transcript.check(router_verifier.clone()).await.unwrap();
transcript
.check(block_verifier_router.clone())
.await
.unwrap();
let transcript = Transcript::from(STATE_VERIFY_TRANSCRIPT_GENESIS.iter().cloned());
transcript.check(state_service.clone()).await.unwrap();
let transcript = Transcript::from(BLOCK_VERIFY_TRANSCRIPT_GENESIS_FAIL.iter().cloned());
transcript.check(router_verifier.clone()).await.unwrap();
transcript
.check(block_verifier_router.clone())
.await
.unwrap();
let transcript = Transcript::from(STATE_VERIFY_TRANSCRIPT_GENESIS.iter().cloned());
transcript.check(state_service.clone()).await.unwrap();

14
zebra-rpc/src/methods/get_block_template_rpcs.rs
View File

@ -273,7 +273,7 @@ pub struct GetBlockTemplateRpcImpl<
latest_chain_tip: Tip,
/// The chain verifier, used for submitting blocks.
router_verifier: BlockVerifierRouter,
block_verifier_router: BlockVerifierRouter,
/// The chain sync status, used for checking if Zebra is likely close to the network chain tip.
sync_status: SyncStatus,
@ -319,7 +319,7 @@ where
mempool: Buffer<Mempool, mempool::Request>,
state: State,
latest_chain_tip: Tip,
router_verifier: BlockVerifierRouter,
block_verifier_router: BlockVerifierRouter,
sync_status: SyncStatus,
address_book: AddressBook,
) -> Self {
@ -358,7 +358,7 @@ where
mempool,
state,
latest_chain_tip,
router_verifier,
block_verifier_router,
sync_status,
address_book,
}
@ -454,7 +454,7 @@ where
.and_then(get_block_template::JsonParameters::block_proposal_data)
{
return validate_block_proposal(
self.router_verifier.clone(),
self.block_verifier_router.clone(),
block_proposal_bytes,
network,
latest_chain_tip,
@ -737,7 +737,7 @@ where
HexData(block_bytes): HexData,
_parameters: Option<submit_block::JsonParameters>,
) -> BoxFuture<Result<submit_block::Response>> {
let mut router_verifier = self.router_verifier.clone();
let mut block_verifier_router = self.block_verifier_router.clone();
async move {
let block: Block = match block_bytes.zcash_deserialize_into() {
@ -755,7 +755,7 @@ where
.unwrap_or_else(|| "invalid coinbase height".to_string());
let block_hash = block.hash();
let router_verifier_response = router_verifier
let block_verifier_router_response = block_verifier_router
.ready()
.await
.map_err(|error| Error {
@ -766,7 +766,7 @@ where
.call(zebra_consensus::Request::Commit(Arc::new(block)))
.await;
let chain_error = match router_verifier_response {
let chain_error = match block_verifier_router_response {
// Currently, this match arm returns `null` (Accepted) for blocks committed
// to any chain, but Accepted is only for blocks in the best chain.
//

8
zebra-rpc/src/methods/get_block_template_rpcs/get_block_template.rs
View File

@ -98,7 +98,7 @@ pub fn check_miner_address(
///
/// Returns a `getblocktemplate` [`Response`].
pub async fn validate_block_proposal<BlockVerifierRouter, Tip, SyncStatus>(
mut router_verifier: BlockVerifierRouter,
mut block_verifier_router: BlockVerifierRouter,
block_proposal_bytes: Vec<u8>,
network: Network,
latest_chain_tip: Tip,
@ -129,7 +129,7 @@ where
}
};
let router_verifier_response = router_verifier
let block_verifier_router_response = block_verifier_router
.ready()
.await
.map_err(|error| Error {
@ -140,12 +140,12 @@ where
.call(zebra_consensus::Request::CheckProposal(Arc::new(block)))
.await;
Ok(router_verifier_response
Ok(block_verifier_router_response
.map(|_hash| ProposalResponse::Valid)
.unwrap_or_else(|verify_chain_error| {
tracing::info!(
?verify_chain_error,
"error response from router_verifier in CheckProposal request"
"error response from block_verifier_router in CheckProposal request"
);
ProposalResponse::rejected("invalid proposal", verify_chain_error)

22
zebra-rpc/src/methods/tests/snapshot/get_block_template_rpcs.rs
View File

@ -85,7 +85,7 @@ pub async fn test_responses<State, ReadState>(
<ReadState as Service<zebra_state::ReadRequest>>::Future: Send,
{
let (
router_verifier,
block_verifier_router,
_transaction_verifier,
_parameter_download_task_handle,
_max_checkpoint_height,
@ -145,7 +145,7 @@ pub async fn test_responses<State, ReadState>(
Buffer::new(mempool.clone(), 1),
read_state,
mock_chain_tip.clone(),
router_verifier.clone(),
block_verifier_router.clone(),
mock_sync_status.clone(),
mock_address_book,
);
@ -267,7 +267,7 @@ pub async fn test_responses<State, ReadState>(
Buffer::new(mempool.clone(), 1),
read_state.clone(),
mock_chain_tip.clone(),
router_verifier,
block_verifier_router,
mock_sync_status.clone(),
MockAddressBookPeers::default(),
);
@ -365,16 +365,16 @@ pub async fn test_responses<State, ReadState>(
snapshot_rpc_getblocktemplate("invalid-proposal", get_block_template, None, &settings);
// the following snapshots use a mock read_state and router_verifier
// the following snapshots use a mock read_state and block_verifier_router
let mut mock_router_verifier = MockService::build().for_unit_tests();
let mut mock_block_verifier_router = MockService::build().for_unit_tests();
let get_block_template_rpc_mock_state_verifier = GetBlockTemplateRpcImpl::new(
network,
mining_config,
Buffer::new(mempool.clone(), 1),
read_state.clone(),
mock_chain_tip,
mock_router_verifier.clone(),
mock_block_verifier_router.clone(),
mock_sync_status,
MockAddressBookPeers::default(),
);
@ -387,15 +387,17 @@ pub async fn test_responses<State, ReadState>(
}),
);
let mock_router_verifier_request_handler = async move {
mock_router_verifier
let mock_block_verifier_router_request_handler = async move {
mock_block_verifier_router
.expect_request_that(|req| matches!(req, zebra_consensus::Request::CheckProposal(_)))
.await
.respond(Hash::from([0; 32]));
};
let (get_block_template, ..) =
tokio::join!(get_block_template_fut, mock_router_verifier_request_handler,);
let (get_block_template, ..) = tokio::join!(
get_block_template_fut,
mock_block_verifier_router_request_handler,
);
let get_block_template =
get_block_template.expect("unexpected error in getblocktemplate RPC call");

28
zebra-rpc/src/methods/tests/vectors.rs
View File

@ -840,7 +840,7 @@ async fn rpc_getblockcount() {
zebra_state::populated_state(blocks.clone(), Mainnet).await;
let (
router_verifier,
block_verifier_router,
_transaction_verifier,
_parameter_download_task_handle,
_max_checkpoint_height,
@ -859,7 +859,7 @@ async fn rpc_getblockcount() {
Buffer::new(mempool.clone(), 1),
read_state,
latest_chain_tip.clone(),
router_verifier,
block_verifier_router,
MockSyncStatus::default(),
MockAddressBookPeers::default(),
);
@ -890,7 +890,7 @@ async fn rpc_getblockcount_empty_state() {
zebra_state::init_test_services(Mainnet);
let (
router_verifier,
block_verifier_router,
_transaction_verifier,
_parameter_download_task_handle,
_max_checkpoint_height,
@ -909,7 +909,7 @@ async fn rpc_getblockcount_empty_state() {
Buffer::new(mempool.clone(), 1),
read_state,
latest_chain_tip.clone(),
router_verifier,
block_verifier_router,
MockSyncStatus::default(),
MockAddressBookPeers::default(),
);
@ -942,7 +942,7 @@ async fn rpc_getpeerinfo() {
zebra_state::init_test_services(Mainnet);
let (
router_verifier,
block_verifier_router,
_transaction_verifier,
_parameter_download_task_handle,
_max_checkpoint_height,
@ -975,7 +975,7 @@ async fn rpc_getpeerinfo() {
Buffer::new(mempool.clone(), 1),
read_state,
latest_chain_tip.clone(),
router_verifier,
block_verifier_router,
MockSyncStatus::default(),
mock_address_book,
);
@ -1017,7 +1017,7 @@ async fn rpc_getblockhash() {
zebra_state::populated_state(blocks.clone(), Mainnet).await;
let (
router_verifier,
block_verifier_router,
_transaction_verifier,
_parameter_download_task_handle,
_max_checkpoint_height,
@ -1036,7 +1036,7 @@ async fn rpc_getblockhash() {
Buffer::new(mempool.clone(), 1),
read_state,
latest_chain_tip.clone(),
tower::ServiceBuilder::new().service(router_verifier),
tower::ServiceBuilder::new().service(block_verifier_router),
MockSyncStatus::default(),
MockAddressBookPeers::default(),
);
@ -1205,7 +1205,7 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let read_state = MockService::build().for_unit_tests();
let router_verifier = MockService::build().for_unit_tests();
let block_verifier_router = MockService::build().for_unit_tests();
let mut mock_sync_status = MockSyncStatus::default();
mock_sync_status.set_is_close_to_tip(true);
@ -1246,7 +1246,7 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
Buffer::new(mempool.clone(), 1),
read_state.clone(),
mock_chain_tip,
router_verifier,
block_verifier_router,
mock_sync_status.clone(),
MockAddressBookPeers::default(),
);
@ -1491,7 +1491,7 @@ async fn rpc_submitblock_errors() {
// Init RPCs
let (
router_verifier,
block_verifier_router,
_transaction_verifier,
_parameter_download_task_handle,
_max_checkpoint_height,
@ -1510,7 +1510,7 @@ async fn rpc_submitblock_errors() {
Buffer::new(mempool.clone(), 1),
read_state,
latest_chain_tip.clone(),
router_verifier,
block_verifier_router,
MockSyncStatus::default(),
MockAddressBookPeers::default(),
);
@ -1658,7 +1658,7 @@ async fn rpc_getdifficulty() {
let mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let read_state = MockService::build().for_unit_tests();
let router_verifier = MockService::build().for_unit_tests();
let block_verifier_router = MockService::build().for_unit_tests();
let mut mock_sync_status = MockSyncStatus::default();
mock_sync_status.set_is_close_to_tip(true);
@ -1693,7 +1693,7 @@ async fn rpc_getdifficulty() {
Buffer::new(mempool.clone(), 1),
read_state.clone(),
mock_chain_tip,
router_verifier,
block_verifier_router,
mock_sync_status.clone(),
MockAddressBookPeers::default(),
);

4
zebra-rpc/src/server.rs
View File

@ -105,7 +105,7 @@ impl RpcServer {
mempool: Buffer<Mempool, mempool::Request>,
state: State,
#[cfg_attr(not(feature = "getblocktemplate-rpcs"), allow(unused_variables))]
router_verifier: BlockVerifierRouter,
block_verifier_router: BlockVerifierRouter,
#[cfg_attr(not(feature = "getblocktemplate-rpcs"), allow(unused_variables))]
sync_status: SyncStatus,
#[cfg_attr(not(feature = "getblocktemplate-rpcs"), allow(unused_variables))]
@ -171,7 +171,7 @@ impl RpcServer {
mempool.clone(),
state.clone(),
latest_chain_tip.clone(),
router_verifier,
block_verifier_router,
sync_status,
address_book,
);

28
zebra-rpc/src/server/tests/vectors.rs
View File

@ -52,7 +52,7 @@ fn rpc_server_spawn(parallel_cpu_threads: bool) {
rt.block_on(async {
let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut state: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut router_verifier: MockService<_, _, _, BoxError> =
let mut block_verifier_router: MockService<_, _, _, BoxError> =
MockService::build().for_unit_tests();
info!("spawning RPC server...");
@ -64,7 +64,7 @@ fn rpc_server_spawn(parallel_cpu_threads: bool) {
"RPC server test",
Buffer::new(mempool.clone(), 1),
Buffer::new(state.clone(), 1),
Buffer::new(router_verifier.clone(), 1),
Buffer::new(block_verifier_router.clone(), 1),
MockSyncStatus::default(),
MockAddressBookPeers::default(),
NoChainTip,
@ -75,7 +75,7 @@ fn rpc_server_spawn(parallel_cpu_threads: bool) {
mempool.expect_no_requests().await;
state.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// The server and queue tasks should continue without errors or panics
let rpc_server_task_result = rpc_server_task_handle.now_or_never();
@ -139,7 +139,7 @@ fn rpc_server_spawn_unallocated_port(parallel_cpu_threads: bool, do_shutdown: bo
rt.block_on(async {
let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut state: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut router_verifier: MockService<_, _, _, BoxError> =
let mut block_verifier_router: MockService<_, _, _, BoxError> =
MockService::build().for_unit_tests();
info!("spawning RPC server...");
@ -151,7 +151,7 @@ fn rpc_server_spawn_unallocated_port(parallel_cpu_threads: bool, do_shutdown: bo
"RPC server test",
Buffer::new(mempool.clone(), 1),
Buffer::new(state.clone(), 1),
Buffer::new(router_verifier.clone(), 1),
Buffer::new(block_verifier_router.clone(), 1),
MockSyncStatus::default(),
MockAddressBookPeers::default(),
NoChainTip,
@ -162,7 +162,7 @@ fn rpc_server_spawn_unallocated_port(parallel_cpu_threads: bool, do_shutdown: bo
mempool.expect_no_requests().await;
state.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
if do_shutdown {
rpc_server
@ -219,7 +219,7 @@ fn rpc_server_spawn_port_conflict() {
let test_task_handle = rt.spawn(async {
let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut state: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut router_verifier: MockService<_, _, _, BoxError> =
let mut block_verifier_router: MockService<_, _, _, BoxError> =
MockService::build().for_unit_tests();
info!("spawning RPC server 1...");
@ -232,7 +232,7 @@ fn rpc_server_spawn_port_conflict() {
"RPC server 1 test",
Buffer::new(mempool.clone(), 1),
Buffer::new(state.clone(), 1),
Buffer::new(router_verifier.clone(), 1),
Buffer::new(block_verifier_router.clone(), 1),
MockSyncStatus::default(),
MockAddressBookPeers::default(),
NoChainTip,
@ -250,7 +250,7 @@ fn rpc_server_spawn_port_conflict() {
"RPC server 2 conflict test",
Buffer::new(mempool.clone(), 1),
Buffer::new(state.clone(), 1),
Buffer::new(router_verifier.clone(), 1),
Buffer::new(block_verifier_router.clone(), 1),
MockSyncStatus::default(),
MockAddressBookPeers::default(),
NoChainTip,
@ -261,7 +261,7 @@ fn rpc_server_spawn_port_conflict() {
mempool.expect_no_requests().await;
state.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// Because there is a panic inside a multi-threaded executor,
// we can't depend on the exact behaviour of the other tasks,
@ -329,7 +329,7 @@ fn rpc_server_spawn_port_conflict_parallel_auto() {
let test_task_handle = rt.spawn(async {
let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut state: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
let mut router_verifier: MockService<_, _, _, BoxError> =
let mut block_verifier_router: MockService<_, _, _, BoxError> =
MockService::build().for_unit_tests();
info!("spawning parallel RPC server 1...");
@ -342,7 +342,7 @@ fn rpc_server_spawn_port_conflict_parallel_auto() {
"RPC server 1 test",
Buffer::new(mempool.clone(), 1),
Buffer::new(state.clone(), 1),
Buffer::new(router_verifier.clone(), 1),
Buffer::new(block_verifier_router.clone(), 1),
MockSyncStatus::default(),
MockAddressBookPeers::default(),
NoChainTip,
@ -360,7 +360,7 @@ fn rpc_server_spawn_port_conflict_parallel_auto() {
"RPC server 2 conflict test",
Buffer::new(mempool.clone(), 1),
Buffer::new(state.clone(), 1),
Buffer::new(router_verifier.clone(), 1),
Buffer::new(block_verifier_router.clone(), 1),
MockSyncStatus::default(),
MockAddressBookPeers::default(),
NoChainTip,
@ -371,7 +371,7 @@ fn rpc_server_spawn_port_conflict_parallel_auto() {
mempool.expect_no_requests().await;
state.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// Because there might be a panic inside a multi-threaded executor,
// we can't depend on the exact behaviour of the other tasks,

8
zebrad/src/commands/start.rs
View File

@ -158,7 +158,7 @@ impl StartCmd {
.await;
info!("initializing verifiers");
let (router_verifier, tx_verifier, consensus_task_handles, max_checkpoint_height) =
let (block_verifier_router, tx_verifier, consensus_task_handles, max_checkpoint_height) =
zebra_consensus::router::init(
config.consensus.clone(),
config.network.network,
@ -172,7 +172,7 @@ impl StartCmd {
&config,
max_checkpoint_height,
peer_set.clone(),
router_verifier.clone(),
block_verifier_router.clone(),
state.clone(),
latest_chain_tip.clone(),
);
@ -197,7 +197,7 @@ impl StartCmd {
let setup_data = InboundSetupData {
address_book: address_book.clone(),
block_download_peer_set: peer_set.clone(),
block_verifier: router_verifier.clone(),
block_verifier: block_verifier_router.clone(),
mempool: mempool.clone(),
state,
latest_chain_tip: latest_chain_tip.clone(),
@ -219,7 +219,7 @@ impl StartCmd {
user_agent(),
mempool.clone(),
read_only_state_service,
router_verifier,
block_verifier_router,
sync_status.clone(),
address_book,
latest_chain_tip.clone(),

68
zebrad/src/components/sync/tests/vectors.rs
View File

@ -45,7 +45,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
let (
chain_sync_future,
_sync_status,
mut router_verifier,
mut block_verifier_router,
mut peer_set,
mut state_service,
_mock_chain_tip_sender,
@ -88,7 +88,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
.await
.respond(zn::Response::Blocks(vec![Available(block0.clone())]));
router_verifier
block_verifier_router
.expect_request(zebra_consensus::Request::Commit(block0))
.await
.respond(block0_hash);
@ -96,7 +96,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
// We expect more requests to the state service, because the syncer keeps on running.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for genesis again
state_service
@ -144,7 +144,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for all non-tip blocks (blocks 1 & 2) in response order
state_service
@ -174,7 +174,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
.collect();
for _ in 1..=2 {
router_verifier
block_verifier_router
.expect_request_that(|req| remaining_blocks.remove(&req.block().hash()).is_some())
.await
.respond_with(|req| req.block().hash());
@ -186,7 +186,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
);
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
// ChainSync::extend_tips
@ -217,7 +217,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
}
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
// Blocks 3 & 4 are fetched in order, then verified concurrently
@ -238,7 +238,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
.collect();
for _ in 3..=4 {
router_verifier
block_verifier_router
.expect_request_that(|req| remaining_blocks.remove(&req.block().hash()).is_some())
.await
.respond_with(|req| req.block().hash());
@ -250,7 +250,7 @@ async fn sync_blocks_ok() -> Result<(), crate::BoxError> {
);
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
let chain_sync_result = chain_sync_task_handle.now_or_never();
@ -272,7 +272,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
let (
chain_sync_future,
_sync_status,
mut router_verifier,
mut block_verifier_router,
mut peer_set,
mut state_service,
_mock_chain_tip_sender,
@ -315,7 +315,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
.await
.respond(zn::Response::Blocks(vec![Available(block0.clone())]));
router_verifier
block_verifier_router
.expect_request(zebra_consensus::Request::Commit(block0))
.await
.respond(block0_hash);
@ -323,7 +323,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
// We expect more requests to the state service, because the syncer keeps on running.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for genesis again
state_service
@ -373,7 +373,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for all non-tip blocks (blocks 1 & 2) in response order
state_service
@ -403,7 +403,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
.collect();
for _ in 1..=2 {
router_verifier
block_verifier_router
.expect_request_that(|req| remaining_blocks.remove(&req.block().hash()).is_some())
.await
.respond_with(|req| req.block().hash());
@ -415,7 +415,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
);
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
// ChainSync::extend_tips
@ -448,7 +448,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
}
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
// Blocks 3 & 4 are fetched in order, then verified concurrently
@ -469,7 +469,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
.collect();
for _ in 3..=4 {
router_verifier
block_verifier_router
.expect_request_that(|req| remaining_blocks.remove(&req.block().hash()).is_some())
.await
.respond_with(|req| req.block().hash());
@ -481,7 +481,7 @@ async fn sync_blocks_duplicate_hashes_ok() -> Result<(), crate::BoxError> {
);
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
let chain_sync_result = chain_sync_task_handle.now_or_never();
@ -500,7 +500,7 @@ async fn sync_block_lookahead_drop() -> Result<(), crate::BoxError> {
let (
chain_sync_future,
_sync_status,
mut router_verifier,
mut block_verifier_router,
mut peer_set,
mut state_service,
_mock_chain_tip_sender,
@ -535,7 +535,7 @@ async fn sync_block_lookahead_drop() -> Result<(), crate::BoxError> {
// Block is dropped because it is too far ahead of the tip.
// We expect more requests to the state service, because the syncer keeps on running.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
let chain_sync_result = chain_sync_task_handle.now_or_never();
assert!(
@ -555,7 +555,7 @@ async fn sync_block_too_high_obtain_tips() -> Result<(), crate::BoxError> {
let (
chain_sync_future,
_sync_status,
mut router_verifier,
mut block_verifier_router,
mut peer_set,
mut state_service,
_mock_chain_tip_sender,
@ -597,7 +597,7 @@ async fn sync_block_too_high_obtain_tips() -> Result<(), crate::BoxError> {
.await
.respond(zn::Response::Blocks(vec![Available(block0.clone())]));
router_verifier
block_verifier_router
.expect_request(zebra_consensus::Request::Commit(block0))
.await
.respond(block0_hash);
@ -605,7 +605,7 @@ async fn sync_block_too_high_obtain_tips() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
// We expect more requests to the state service, because the syncer keeps on running.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for genesis again
state_service
@ -654,7 +654,7 @@ async fn sync_block_too_high_obtain_tips() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for all non-tip blocks (blocks 982k, 1, 2) in response order
state_service
@ -710,7 +710,7 @@ async fn sync_block_too_high_extend_tips() -> Result<(), crate::BoxError> {
let (
chain_sync_future,
_sync_status,
mut router_verifier,
mut block_verifier_router,
mut peer_set,
mut state_service,
_mock_chain_tip_sender,
@ -758,7 +758,7 @@ async fn sync_block_too_high_extend_tips() -> Result<(), crate::BoxError> {
.await
.respond(zn::Response::Blocks(vec![Available(block0.clone())]));
router_verifier
block_verifier_router
.expect_request(zebra_consensus::Request::Commit(block0))
.await
.respond(block0_hash);
@ -766,7 +766,7 @@ async fn sync_block_too_high_extend_tips() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
// We expect more requests to the state service, because the syncer keeps on running.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for genesis again
state_service
@ -814,7 +814,7 @@ async fn sync_block_too_high_extend_tips() -> Result<(), crate::BoxError> {
// Check that nothing unexpected happened.
peer_set.expect_no_requests().await;
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
// State is checked for all non-tip blocks (blocks 1 & 2) in response order
state_service
@ -844,7 +844,7 @@ async fn sync_block_too_high_extend_tips() -> Result<(), crate::BoxError> {
.collect();
for _ in 1..=2 {
router_verifier
block_verifier_router
.expect_request_that(|req| remaining_blocks.remove(&req.block().hash()).is_some())
.await
.respond_with(|req| req.block().hash());
@ -856,7 +856,7 @@ async fn sync_block_too_high_extend_tips() -> Result<(), crate::BoxError> {
);
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
// ChainSync::extend_tips
@ -888,7 +888,7 @@ async fn sync_block_too_high_extend_tips() -> Result<(), crate::BoxError> {
}
// Check that nothing unexpected happened.
router_verifier.expect_no_requests().await;
block_verifier_router.expect_no_requests().await;
state_service.expect_no_requests().await;
// Blocks 3, 4, 982k are fetched in order, then verified concurrently,
@ -951,7 +951,7 @@ fn setup() -> (
.with_max_request_delay(MAX_SERVICE_REQUEST_DELAY)
.for_unit_tests();
let router_verifier = MockService::build()
let block_verifier_router = MockService::build()
.with_max_request_delay(MAX_SERVICE_REQUEST_DELAY)
.for_unit_tests();
@ -965,7 +965,7 @@ fn setup() -> (
&config,
Height(0),
peer_set.clone(),
router_verifier.clone(),
block_verifier_router.clone(),
state_service.clone(),
mock_chain_tip,
);
@ -975,7 +975,7 @@ fn setup() -> (
(
chain_sync_future,
sync_status,
router_verifier,
block_verifier_router,
peer_set,
state_service,
mock_chain_tip_sender,