mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-05-30 19:51:02 +00:00
Squashed 'bridges/' changes from 23dda62482..407bf44a8a
407bf44a8a add missing license header (#1204) 9babb19810 Custom relay strategy (#1198) c287872a11 fix clippy things (#1200) 3a40e62789 Expose some const value and type (#1186) 32b61476d1 increase sleep before connectingMillau (#1195) aabe7041fa revert messages transactions mortality (#1194) 3651f4f909 Message transactions mortality (#1191) 364d6e155d Bump dependencies (#1180) f0389acc08 cargo +nightly fmt --all (#1192) b270b6a016 Unify error enums in substrate and ethereum clients with `thiserror` (#1094) 58c4946f74 Limit max call size of Rialto/Millau runtimes (#1187) fd56a8cd56 Add UI to the deployment (#1047) 16f01dc736 Westend -> Millau alerts are pending before notifications are sent (#1184) 5628c11ece replace collective flip with babe randomness in Rialto (#1188) 1094a63b00 ignore another (pretty bad) RUSTSEC (#1185) 379fe323ea fix/ignore cargo deny issues (#1183) 92af5e6e64 additional log in finality relay + rephrase "failed" (#1182) b996a3b681 Rialto parachain in test deployments (#1178) 28d9332b44 Resubmit transactions strategy for Polkadot/Kusama (#1175) d0172c6847 Playing with CI (#1179) fb6f42456d fix checks order when registering parachain (#1177) ee828c005a Register-parachain subcommand of substrate-relay (#1170) 8cd2b1a112 Token swap pallet benchmarks (#1174) bb811accb1 fix collision with westend bridge (#1172) 8d2fba70ed add token swaps to test deployments (#1169) b6d1bdfe2c publish rialto parachain collator image (#1171) 834ae4a10a Fix OutboundLaneData types (#1159) 5ee0ea1626 copypasted -> copied (#1168) c3bb835f18 fix spelling (#1167) f90d041dc9 Upgrade `jsonrpsee` to v0.3 (#1051) 598c9b6d0d add some basic tests for swap tokens (#1164) 05e88c61f5 publish images when tag of specific format(e.g. v2021-09-27 + v2021-09-27-1) is published (#1166) 7f3f94a6e0 Fix CI again (#1165) ff37de332f Move calculation relayer reward into `MessageDeliveryAndDispatchPayment` (#1153) 36fbba839b fix clippy warning (#1163) 16da44d018 explicit wasm build (#1158) c9c8226449 Match substrate's fmt (#1148) 2fdd7f3e5e Fix/ignore clippy warnings (#1157) 43dfcc2686 Adding LookupAddress (#1156) 951eaa5582 Add rialto-parachain runtime and node (#1142) 803d266d61 Rename MessageId -> BridgeMessageId (#1152) 5f234484fc Box large arguments of GRANDPA pallet (#1154) cf9abc1011 Fix spelling (#1150) ab83ba2e58 Relay subcommand that performs token RLT <> MLAU token swap (#1141) 832536caf0 Polkadot <> Kusama relayers (#1122) 6d0daa8975 Add `OnMessageAccepted` callback (#1134) 5d03a20b3e Integrate token swap pallet into Millau runtime (#1099) ea4cfa833e Adding MultiAddress type and ValidationCodeHash (#1139) c20325a784 Add tests for `Raw` and `BridgeSendMessage` enum `Call` variants (#1125) 6d802416e2 increase pause before pining Rialto nodes (#1137) b54fa56b62 calculate fee using full message payload (#1132) ca5d8178f5 Add parachain pallets to rialto runtime (#1053) 9eaae4142e fix transaction resubmitter limits for Millau -> Rialto transactions (#1135) 9d4e17783c add --mandatory-headers-only cli option to complex relay (#1129) 1c5e0ec1cb Add local CI info to README (#1131) a8e0929e14 chore: spellchecker fixes (#1130) 3b8e2118e3 set fee for importing mandatory headers to zero (#1127) 49bba9aa52 another bunch of words for spellchecker (#1128) 8a72eafef6 Increase pause before messages generation start (#1126) 1f0ba9a191 Move some associated types from relay_substrate_client::Chain to bp_runtime::Chain (#1087) 74bc1a5b54 Transactions resubmitter (#1083) 21ba001f26 log max balance drop when sending message (#1117) 638a7ddffa Code Cleaning (#1124) be6555c51b Fix buildah logout (#1120) 87539c4a98 Format code work (#1116) 526fe7fdd7 fix spelling (#1119) bd4ce7f241 Fix spelling (#1118) 3c1147858e added missing constants to Kusama/Polkadot primitives (#1114) 52093b22ab Fix delivery transaction estimation used by rational relayer (#1109) 77a2f2fbed Remove fund account checks from upgrade. (#1111) 824334802b Rename param and update comment (#1108) d7784bfe06 Fix spellcheck (#1110) 0b18f5906a Refactor substrate messages source and substrate messages target (#1105) b27240bbff fix compilation (#1107) 9697da4fe8 Emit mortal transactions from relay (#1073) b29396c077 Change vault vars type to env vars (#1084) 35e0bbdc0c Make clippy mandatory. (#1103) a517e8541f Remove unused deps (#1102) 873dae608a Remove unnessary deps (#1101) 13450b74ee Stored conversion rate updater (#1005) 74389829f3 [BREAKING] Migrate messages pallet to frame v2 (#1088) 424da938dd README fix (#1100) 865744c909 upgrade currency exchange pallet to frame v2 (#1097) b5038148b3 Add missing docs (#1095) 0791e911c1 Common crate for substrate-relay (#1082) 3834c9d880 Update high-level-overview.md (#1093) c93553face Increase the time window for messaging alerts. (#1092) 8b9cc3cecd migrate pallet-shift-session-manager to frame v2 (#1090) dc91813c22 migrate eth PoA pallet to frame v2 (#1091) f16bb098cc Migrate dispatch pallet to frame v2 (#1089) 19f4325348 Bridge/This Chain Ids should be exposed as constants on pallet level. (#1085) 6381122df7 Change ChainSpec::from_genesis for Rialto and Millau chains to reflect the chain names. (#1079) 0f1d33e973 Make CI happy again (#1086) 238e65d96f fix typo (#1080) fc008457b6 Token-swap-over-bridge pallet (#944) 3fb97fa5ef Fix full spellcheck (#1076) eae4ed7170 fixed wrong trace (#1075) 219a0fad04 merge two weight-related loops in messages pallet (#1071) fc85632fdb increase_message_fee depends on stored mesage size (#1066) 530f37a23b companion for https://github.com/paritytech/polkadot/pull/3507 (#1067) 53b8cba683 sc_basic_authorship=trace for millau nodes (#1074) 9874e05e98 Improve traces of message generator scripts (#1069) 7b5ee84fbb extract message_details impl into runtime common (#1070) 5a4aed5a8b refund weight for mot pruning messages (#1062) 90e3d1e111 Fix Westend -> Millau sync (#1064) 427d30ddfc When restarting client, also "restart" tokio runtime (#1065) d47c05eeef Change get pipeline sensitive variables from Vault instead of GitLab settings (#1063) d775a85415 use tokio reactor to execute jsonrpsee futures (#1061) 15c8cd61cb Use BABE to author blocks on Rialto (previously: Aura) (#1050) 5186293500 Allow reading suri && password override from file (#1059) b506298262 Update jsonrpsee reference (#1049) 1734d00517 enable weight fee adjustent in Rialto/Millau (#1044) 607265afae Pay dispatch fee at target chain cli option (#1043) ce79ef91be bump dependencies before start referencing polkadot repo (#1048) 924fa24f6d Cli option for greedy relayer + run no-losses relayer by default (#1042) e21eba7b59 Yrong README Fixup + M1 Fixes (#1045) 20d08204a2 Confirm delivery detects when more than expected messages are confirmed (#1039) 994b846b52 pre and post dispatch weights of OnDeliveryConfirmed callback (#1040) 1dd5297e84 give real value to Rialto and Millau tokens (#1038) 035bee8715 Use real conversion rate in greedy relayer strategy (#1035) 9cfaecd0f7 fixed metrics prefix (#1037) 1d8d224937 Use kebab-case for bridge arguments (#1036) f30a4c79a6 Shared reference to conversion rate metric value (#1034) c34d7a5cbb estimate transaction fee (#1015) 93404b18bb change alert period from 2m to 10m for Westend -> Millau (GRANDPA or public node itself is lagging sometimes) (#1032) git-subtree-dir: bridges git-subtree-split: 407bf44a8a5f4e60aceef2dc755cd9ff09929ac3
This commit is contained in:
antonio-dropulic
@@ -1,594 +0,0 @@
|
||||
// Copyright 2019-2021 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Parity Bridges Common.
|
||||
|
||||
// Parity Bridges Common is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Parity Bridges Common is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Parity Bridges Common. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#![cfg(test)]
|
||||
|
||||
use crate::sync_loop::{run, SourceClient, TargetClient};
|
||||
use crate::sync_types::{HeadersSyncPipeline, QueuedHeader, SourceHeader, SubmittedHeaders};
|
||||
|
||||
use async_trait::async_trait;
|
||||
use backoff::backoff::Backoff;
|
||||
use futures::{future::FutureExt, stream::StreamExt};
|
||||
use parking_lot::Mutex;
|
||||
use relay_utils::{
|
||||
metrics::MetricsParams, process_future_result, relay_loop::Client as RelayClient, retry_backoff, HeaderId,
|
||||
MaybeConnectionError,
|
||||
};
|
||||
use std::{
|
||||
collections::{HashMap, HashSet},
|
||||
sync::Arc,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
pub type TestNumber = u64;
|
||||
pub type TestHash = u64;
|
||||
pub type TestHeaderId = HeaderId<TestHash, TestNumber>;
|
||||
pub type TestExtra = u64;
|
||||
pub type TestCompletion = u64;
|
||||
pub type TestQueuedHeader = QueuedHeader<TestHeadersSyncPipeline>;
|
||||
|
||||
#[derive(Default, Debug, Clone, PartialEq)]
|
||||
pub struct TestHeader {
|
||||
pub hash: TestHash,
|
||||
pub number: TestNumber,
|
||||
pub parent_hash: TestHash,
|
||||
}
|
||||
|
||||
impl SourceHeader<TestHash, TestNumber> for TestHeader {
|
||||
fn id(&self) -> TestHeaderId {
|
||||
HeaderId(self.number, self.hash)
|
||||
}
|
||||
|
||||
fn parent_id(&self) -> TestHeaderId {
|
||||
HeaderId(self.number - 1, self.parent_hash)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct TestError(bool);
|
||||
|
||||
impl MaybeConnectionError for TestError {
|
||||
fn is_connection_error(&self) -> bool {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub struct TestHeadersSyncPipeline;
|
||||
|
||||
impl HeadersSyncPipeline for TestHeadersSyncPipeline {
|
||||
const SOURCE_NAME: &'static str = "Source";
|
||||
const TARGET_NAME: &'static str = "Target";
|
||||
|
||||
type Hash = TestHash;
|
||||
type Number = TestNumber;
|
||||
type Header = TestHeader;
|
||||
type Extra = TestExtra;
|
||||
type Completion = TestCompletion;
|
||||
|
||||
fn estimate_size(_: &TestQueuedHeader) -> usize {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
enum SourceMethod {
|
||||
BestBlockNumber,
|
||||
HeaderByHash(TestHash),
|
||||
HeaderByNumber(TestNumber),
|
||||
HeaderCompletion(TestHeaderId),
|
||||
HeaderExtra(TestHeaderId, TestQueuedHeader),
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct Source {
|
||||
data: Arc<Mutex<SourceData>>,
|
||||
on_method_call: Arc<dyn Fn(SourceMethod, &mut SourceData) + Send + Sync>,
|
||||
}
|
||||
|
||||
struct SourceData {
|
||||
best_block_number: Result<TestNumber, TestError>,
|
||||
header_by_hash: HashMap<TestHash, TestHeader>,
|
||||
header_by_number: HashMap<TestNumber, TestHeader>,
|
||||
provides_completion: bool,
|
||||
provides_extra: bool,
|
||||
}
|
||||
|
||||
impl Source {
|
||||
pub fn new(
|
||||
best_block_id: TestHeaderId,
|
||||
headers: Vec<(bool, TestHeader)>,
|
||||
on_method_call: impl Fn(SourceMethod, &mut SourceData) + Send + Sync + 'static,
|
||||
) -> Self {
|
||||
Source {
|
||||
data: Arc::new(Mutex::new(SourceData {
|
||||
best_block_number: Ok(best_block_id.0),
|
||||
header_by_hash: headers
|
||||
.iter()
|
||||
.map(|(_, header)| (header.hash, header.clone()))
|
||||
.collect(),
|
||||
header_by_number: headers
|
||||
.iter()
|
||||
.filter_map(|(is_canonical, header)| {
|
||||
if *is_canonical {
|
||||
Some((header.hash, header.clone()))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
provides_completion: true,
|
||||
provides_extra: true,
|
||||
})),
|
||||
on_method_call: Arc::new(on_method_call),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl RelayClient for Source {
|
||||
type Error = TestError;
|
||||
|
||||
async fn reconnect(&mut self) -> Result<(), TestError> {
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl SourceClient<TestHeadersSyncPipeline> for Source {
|
||||
async fn best_block_number(&self) -> Result<TestNumber, TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(SourceMethod::BestBlockNumber, &mut *data);
|
||||
data.best_block_number.clone()
|
||||
}
|
||||
|
||||
async fn header_by_hash(&self, hash: TestHash) -> Result<TestHeader, TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(SourceMethod::HeaderByHash(hash), &mut *data);
|
||||
data.header_by_hash.get(&hash).cloned().ok_or(TestError(false))
|
||||
}
|
||||
|
||||
async fn header_by_number(&self, number: TestNumber) -> Result<TestHeader, TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(SourceMethod::HeaderByNumber(number), &mut *data);
|
||||
data.header_by_number.get(&number).cloned().ok_or(TestError(false))
|
||||
}
|
||||
|
||||
async fn header_completion(&self, id: TestHeaderId) -> Result<(TestHeaderId, Option<TestCompletion>), TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(SourceMethod::HeaderCompletion(id), &mut *data);
|
||||
if data.provides_completion {
|
||||
Ok((id, Some(test_completion(id))))
|
||||
} else {
|
||||
Ok((id, None))
|
||||
}
|
||||
}
|
||||
|
||||
async fn header_extra(
|
||||
&self,
|
||||
id: TestHeaderId,
|
||||
header: TestQueuedHeader,
|
||||
) -> Result<(TestHeaderId, TestExtra), TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(SourceMethod::HeaderExtra(id, header), &mut *data);
|
||||
if data.provides_extra {
|
||||
Ok((id, test_extra(id)))
|
||||
} else {
|
||||
Err(TestError(false))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum TargetMethod {
|
||||
BestHeaderId,
|
||||
IsKnownHeader(TestHeaderId),
|
||||
SubmitHeaders(Vec<TestQueuedHeader>),
|
||||
IncompleteHeadersIds,
|
||||
CompleteHeader(TestHeaderId, TestCompletion),
|
||||
RequiresExtra(TestQueuedHeader),
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct Target {
|
||||
data: Arc<Mutex<TargetData>>,
|
||||
on_method_call: Arc<dyn Fn(TargetMethod, &mut TargetData) + Send + Sync>,
|
||||
}
|
||||
|
||||
struct TargetData {
|
||||
best_header_id: Result<TestHeaderId, TestError>,
|
||||
is_known_header_by_hash: HashMap<TestHash, bool>,
|
||||
submitted_headers: HashMap<TestHash, TestQueuedHeader>,
|
||||
submit_headers_result: Option<SubmittedHeaders<TestHeaderId, TestError>>,
|
||||
completed_headers: HashMap<TestHash, TestCompletion>,
|
||||
requires_completion: bool,
|
||||
requires_extra: bool,
|
||||
}
|
||||
|
||||
impl Target {
|
||||
pub fn new(
|
||||
best_header_id: TestHeaderId,
|
||||
headers: Vec<TestHeaderId>,
|
||||
on_method_call: impl Fn(TargetMethod, &mut TargetData) + Send + Sync + 'static,
|
||||
) -> Self {
|
||||
Target {
|
||||
data: Arc::new(Mutex::new(TargetData {
|
||||
best_header_id: Ok(best_header_id),
|
||||
is_known_header_by_hash: headers.iter().map(|header| (header.1, true)).collect(),
|
||||
submitted_headers: HashMap::new(),
|
||||
submit_headers_result: None,
|
||||
completed_headers: HashMap::new(),
|
||||
requires_completion: false,
|
||||
requires_extra: false,
|
||||
})),
|
||||
on_method_call: Arc::new(on_method_call),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl RelayClient for Target {
|
||||
type Error = TestError;
|
||||
|
||||
async fn reconnect(&mut self) -> Result<(), TestError> {
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl TargetClient<TestHeadersSyncPipeline> for Target {
|
||||
async fn best_header_id(&self) -> Result<TestHeaderId, TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(TargetMethod::BestHeaderId, &mut *data);
|
||||
data.best_header_id.clone()
|
||||
}
|
||||
|
||||
async fn is_known_header(&self, id: TestHeaderId) -> Result<(TestHeaderId, bool), TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(TargetMethod::IsKnownHeader(id), &mut *data);
|
||||
data.is_known_header_by_hash
|
||||
.get(&id.1)
|
||||
.cloned()
|
||||
.map(|is_known_header| Ok((id, is_known_header)))
|
||||
.unwrap_or(Ok((id, false)))
|
||||
}
|
||||
|
||||
async fn submit_headers(&self, headers: Vec<TestQueuedHeader>) -> SubmittedHeaders<TestHeaderId, TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(TargetMethod::SubmitHeaders(headers.clone()), &mut *data);
|
||||
data.submitted_headers
|
||||
.extend(headers.iter().map(|header| (header.id().1, header.clone())));
|
||||
data.submit_headers_result.take().expect("test must accept headers")
|
||||
}
|
||||
|
||||
async fn incomplete_headers_ids(&self) -> Result<HashSet<TestHeaderId>, TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(TargetMethod::IncompleteHeadersIds, &mut *data);
|
||||
if data.requires_completion {
|
||||
Ok(data
|
||||
.submitted_headers
|
||||
.iter()
|
||||
.filter(|(hash, _)| !data.completed_headers.contains_key(hash))
|
||||
.map(|(_, header)| header.id())
|
||||
.collect())
|
||||
} else {
|
||||
Ok(HashSet::new())
|
||||
}
|
||||
}
|
||||
|
||||
async fn complete_header(&self, id: TestHeaderId, completion: TestCompletion) -> Result<TestHeaderId, TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(TargetMethod::CompleteHeader(id, completion), &mut *data);
|
||||
data.completed_headers.insert(id.1, completion);
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
async fn requires_extra(&self, header: TestQueuedHeader) -> Result<(TestHeaderId, bool), TestError> {
|
||||
let mut data = self.data.lock();
|
||||
(self.on_method_call)(TargetMethod::RequiresExtra(header.clone()), &mut *data);
|
||||
if data.requires_extra {
|
||||
Ok((header.id(), true))
|
||||
} else {
|
||||
Ok((header.id(), false))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn test_tick() -> Duration {
|
||||
// in ideal world that should have been Duration::from_millis(0), because we do not want
|
||||
// to sleep in tests at all, but that could lead to `select! {}` always waking on tick
|
||||
// => not doing actual job
|
||||
Duration::from_millis(10)
|
||||
}
|
||||
|
||||
fn test_id(number: TestNumber) -> TestHeaderId {
|
||||
HeaderId(number, number)
|
||||
}
|
||||
|
||||
fn test_header(number: TestNumber) -> TestHeader {
|
||||
let id = test_id(number);
|
||||
TestHeader {
|
||||
hash: id.1,
|
||||
number: id.0,
|
||||
parent_hash: if number == 0 {
|
||||
TestHash::default()
|
||||
} else {
|
||||
test_id(number - 1).1
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn test_forked_id(number: TestNumber, forked_from: TestNumber) -> TestHeaderId {
|
||||
const FORK_OFFSET: TestNumber = 1000;
|
||||
|
||||
if number == forked_from {
|
||||
HeaderId(number, number)
|
||||
} else {
|
||||
HeaderId(number, FORK_OFFSET + number)
|
||||
}
|
||||
}
|
||||
|
||||
fn test_forked_header(number: TestNumber, forked_from: TestNumber) -> TestHeader {
|
||||
let id = test_forked_id(number, forked_from);
|
||||
TestHeader {
|
||||
hash: id.1,
|
||||
number: id.0,
|
||||
parent_hash: if number == 0 {
|
||||
TestHash::default()
|
||||
} else {
|
||||
test_forked_id(number - 1, forked_from).1
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn test_completion(id: TestHeaderId) -> TestCompletion {
|
||||
id.0
|
||||
}
|
||||
|
||||
fn test_extra(id: TestHeaderId) -> TestExtra {
|
||||
id.0
|
||||
}
|
||||
|
||||
fn source_reject_completion(method: &SourceMethod) {
|
||||
if let SourceMethod::HeaderCompletion(_) = method {
|
||||
unreachable!("HeaderCompletion request is not expected")
|
||||
}
|
||||
}
|
||||
|
||||
fn source_reject_extra(method: &SourceMethod) {
|
||||
if let SourceMethod::HeaderExtra(_, _) = method {
|
||||
unreachable!("HeaderExtra request is not expected")
|
||||
}
|
||||
}
|
||||
|
||||
fn target_accept_all_headers(method: &TargetMethod, data: &mut TargetData, requires_extra: bool) {
|
||||
if let TargetMethod::SubmitHeaders(ref submitted) = method {
|
||||
assert_eq!(submitted.iter().all(|header| header.extra().is_some()), requires_extra,);
|
||||
|
||||
data.submit_headers_result = Some(SubmittedHeaders {
|
||||
submitted: submitted.iter().map(|header| header.id()).collect(),
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn target_signal_exit_when_header_submitted(
|
||||
method: &TargetMethod,
|
||||
header_id: TestHeaderId,
|
||||
exit_signal: &futures::channel::mpsc::UnboundedSender<()>,
|
||||
) {
|
||||
if let TargetMethod::SubmitHeaders(ref submitted) = method {
|
||||
if submitted.iter().any(|header| header.id() == header_id) {
|
||||
exit_signal.unbounded_send(()).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn target_signal_exit_when_header_completed(
|
||||
method: &TargetMethod,
|
||||
header_id: TestHeaderId,
|
||||
exit_signal: &futures::channel::mpsc::UnboundedSender<()>,
|
||||
) {
|
||||
if let TargetMethod::CompleteHeader(completed_id, _) = method {
|
||||
if *completed_id == header_id {
|
||||
exit_signal.unbounded_send(()).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn run_backoff_test(result: Result<(), TestError>) -> (Duration, Duration) {
|
||||
let mut backoff = retry_backoff();
|
||||
|
||||
// no randomness in tests (otherwise intervals may overlap => asserts are failing)
|
||||
backoff.randomization_factor = 0f64;
|
||||
|
||||
// increase backoff's current interval
|
||||
let interval1 = backoff.next_backoff().unwrap();
|
||||
let interval2 = backoff.next_backoff().unwrap();
|
||||
assert!(interval2 > interval1);
|
||||
|
||||
// successful future result leads to backoff's reset
|
||||
let go_offline_future = futures::future::Fuse::terminated();
|
||||
futures::pin_mut!(go_offline_future);
|
||||
|
||||
process_future_result(
|
||||
result,
|
||||
&mut backoff,
|
||||
|_| {},
|
||||
&mut go_offline_future,
|
||||
async_std::task::sleep,
|
||||
|| "Test error".into(),
|
||||
);
|
||||
|
||||
(interval2, backoff.next_backoff().unwrap())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn process_future_result_resets_backoff_on_success() {
|
||||
let (interval2, interval_after_reset) = run_backoff_test(Ok(()));
|
||||
assert!(interval2 > interval_after_reset);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn process_future_result_resets_backoff_on_connection_error() {
|
||||
let (interval2, interval_after_reset) = run_backoff_test(Err(TestError(true)));
|
||||
assert!(interval2 > interval_after_reset);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn process_future_result_does_not_reset_backoff_on_non_connection_error() {
|
||||
let (interval2, interval_after_reset) = run_backoff_test(Err(TestError(false)));
|
||||
assert!(interval2 < interval_after_reset);
|
||||
}
|
||||
|
||||
struct SyncLoopTestParams {
|
||||
best_source_header: TestHeader,
|
||||
headers_on_source: Vec<(bool, TestHeader)>,
|
||||
best_target_header: TestHeader,
|
||||
headers_on_target: Vec<TestHeader>,
|
||||
target_requires_extra: bool,
|
||||
target_requires_completion: bool,
|
||||
stop_at: TestHeaderId,
|
||||
}
|
||||
|
||||
fn run_sync_loop_test(params: SyncLoopTestParams) {
|
||||
let (exit_sender, exit_receiver) = futures::channel::mpsc::unbounded();
|
||||
let target_requires_extra = params.target_requires_extra;
|
||||
let target_requires_completion = params.target_requires_completion;
|
||||
let stop_at = params.stop_at;
|
||||
let source = Source::new(
|
||||
params.best_source_header.id(),
|
||||
params.headers_on_source,
|
||||
move |method, _| {
|
||||
if !target_requires_extra {
|
||||
source_reject_extra(&method);
|
||||
}
|
||||
if !target_requires_completion {
|
||||
source_reject_completion(&method);
|
||||
}
|
||||
},
|
||||
);
|
||||
let target = Target::new(
|
||||
params.best_target_header.id(),
|
||||
params.headers_on_target.into_iter().map(|header| header.id()).collect(),
|
||||
move |method, data| {
|
||||
target_accept_all_headers(&method, data, target_requires_extra);
|
||||
if target_requires_completion {
|
||||
target_signal_exit_when_header_completed(&method, stop_at, &exit_sender);
|
||||
} else {
|
||||
target_signal_exit_when_header_submitted(&method, stop_at, &exit_sender);
|
||||
}
|
||||
},
|
||||
);
|
||||
target.data.lock().requires_extra = target_requires_extra;
|
||||
target.data.lock().requires_completion = target_requires_completion;
|
||||
|
||||
let _ = async_std::task::block_on(run(
|
||||
source,
|
||||
test_tick(),
|
||||
target,
|
||||
test_tick(),
|
||||
(),
|
||||
crate::sync::tests::default_sync_params(),
|
||||
MetricsParams::disabled(),
|
||||
exit_receiver.into_future().map(|(_, _)| ()),
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_loop_is_able_to_synchronize_single_header() {
|
||||
run_sync_loop_test(SyncLoopTestParams {
|
||||
best_source_header: test_header(1),
|
||||
headers_on_source: vec![(true, test_header(1))],
|
||||
best_target_header: test_header(0),
|
||||
headers_on_target: vec![test_header(0)],
|
||||
target_requires_extra: false,
|
||||
target_requires_completion: false,
|
||||
stop_at: test_id(1),
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_loop_is_able_to_synchronize_single_header_with_extra() {
|
||||
run_sync_loop_test(SyncLoopTestParams {
|
||||
best_source_header: test_header(1),
|
||||
headers_on_source: vec![(true, test_header(1))],
|
||||
best_target_header: test_header(0),
|
||||
headers_on_target: vec![test_header(0)],
|
||||
target_requires_extra: true,
|
||||
target_requires_completion: false,
|
||||
stop_at: test_id(1),
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_loop_is_able_to_synchronize_single_header_with_completion() {
|
||||
run_sync_loop_test(SyncLoopTestParams {
|
||||
best_source_header: test_header(1),
|
||||
headers_on_source: vec![(true, test_header(1))],
|
||||
best_target_header: test_header(0),
|
||||
headers_on_target: vec![test_header(0)],
|
||||
target_requires_extra: false,
|
||||
target_requires_completion: true,
|
||||
stop_at: test_id(1),
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_loop_is_able_to_reorganize_from_shorter_fork() {
|
||||
run_sync_loop_test(SyncLoopTestParams {
|
||||
best_source_header: test_header(3),
|
||||
headers_on_source: vec![
|
||||
(true, test_header(1)),
|
||||
(true, test_header(2)),
|
||||
(true, test_header(3)),
|
||||
(false, test_forked_header(1, 0)),
|
||||
(false, test_forked_header(2, 0)),
|
||||
],
|
||||
best_target_header: test_forked_header(2, 0),
|
||||
headers_on_target: vec![test_header(0), test_forked_header(1, 0), test_forked_header(2, 0)],
|
||||
target_requires_extra: false,
|
||||
target_requires_completion: false,
|
||||
stop_at: test_id(3),
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_loop_is_able_to_reorganize_from_longer_fork() {
|
||||
run_sync_loop_test(SyncLoopTestParams {
|
||||
best_source_header: test_header(3),
|
||||
headers_on_source: vec![
|
||||
(true, test_header(1)),
|
||||
(true, test_header(2)),
|
||||
(true, test_header(3)),
|
||||
(false, test_forked_header(1, 0)),
|
||||
(false, test_forked_header(2, 0)),
|
||||
(false, test_forked_header(3, 0)),
|
||||
(false, test_forked_header(4, 0)),
|
||||
(false, test_forked_header(5, 0)),
|
||||
],
|
||||
best_target_header: test_forked_header(5, 0),
|
||||
headers_on_target: vec![
|
||||
test_header(0),
|
||||
test_forked_header(1, 0),
|
||||
test_forked_header(2, 0),
|
||||
test_forked_header(3, 0),
|
||||
test_forked_header(4, 0),
|
||||
test_forked_header(5, 0),
|
||||
],
|
||||
target_requires_extra: false,
|
||||
target_requires_completion: false,
|
||||
stop_at: test_id(3),
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user