diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 4d17b70028810..a0b1464bae23e 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -48,11 +48,11 @@ variables:
CARGO_INCREMENTAL: 0
DOCKER_OS: "debian:stretch"
ARCH: "x86_64"
- # staging image with rust 1.65 and nightly-2022-11-16
- CI_IMAGE: "paritytech/ci-linux@sha256:786869e731963b3cc0a4aa9deb83367ed9e87a6ae48b6eb029d62b0cab4d87c1"
+ CI_IMAGE: "paritytech/ci-linux:production"
BUILDAH_IMAGE: "quay.io/buildah/stable:v1.27"
RUSTY_CACHIER_SINGLE_BRANCH: master
RUSTY_CACHIER_DONT_OPERATE_ON_MAIN_BRANCH: "true"
+ RUSTY_CACHIER_COMPRESSION_METHOD: zstd
ZOMBIENET_IMAGE: "docker.io/paritytech/zombienet:v1.3.22"
default:
diff --git a/Cargo.lock b/Cargo.lock
index c8d1d8d83f0d7..d333b79c8c403 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -187,9 +187,9 @@ checksum = "29d47fbf90d5149a107494b15a7dc8d69b351be2db3bb9691740e88ec17fd880"
[[package]]
name = "arc-swap"
-version = "1.5.1"
+version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "983cd8b9d4b02a6dc6ffa557262eb5858a27a0038ffffe21a0f133eaa819a164"
+checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6"
[[package]]
name = "array-bytes"
@@ -1022,9 +1022,9 @@ dependencies = [
[[package]]
name = "comfy-table"
-version = "6.1.3"
+version = "6.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e621e7e86c46fd8a14c32c6ae3cb95656621b4743a27d0cffedb831d46e7ad21"
+checksum = "6e7b787b0dc42e8111badfdbe4c3059158ccb2db8780352fa1b01e8ccf45cc4d"
dependencies = [
"strum",
"strum_macros",
@@ -3217,7 +3217,7 @@ checksum = "28dfb6c8100ccc63462345b67d1bbc3679177c75ee4bf59bf29c8b1d110b8189"
dependencies = [
"hermit-abi 0.2.6",
"io-lifetimes 1.0.3",
- "rustix 0.36.5",
+ "rustix 0.36.6",
"windows-sys 0.42.0",
]
@@ -3458,6 +3458,7 @@ dependencies = [
"pallet-message-queue",
"pallet-mmr",
"pallet-multisig",
+ "pallet-nfts",
"pallet-nis",
"pallet-nomination-pools",
"pallet-nomination-pools-benchmarking",
@@ -3706,9 +3707,9 @@ dependencies = [
[[package]]
name = "libp2p-kad"
-version = "0.42.0"
+version = "0.42.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ee545eedf4f88502b2a4a2323405c3225d212d643212b0615856ca227fb9c3"
+checksum = "2766dcd2be8c87d5e1f35487deb22d765f49c6ae1251b3633efe3b25698bd3d2"
dependencies = [
"arrayvec 0.7.2",
"asynchronous-codec",
@@ -4272,7 +4273,7 @@ version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b20a59d985586e4a5aef64564ac77299f8586d8be6cf9106a5a40207e8908efb"
dependencies = [
- "rustix 0.36.5",
+ "rustix 0.36.6",
]
[[package]]
@@ -4981,9 +4982,9 @@ checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
[[package]]
name = "nom"
-version = "7.1.1"
+version = "7.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8903e5a29a317527874d0402f867152a3d21c908bb0b933e416c65e301d4c36"
+checksum = "e5507769c4919c998e69e49c839d9dc6e693ede4cc4290d6ad8b41d4f09c548c"
dependencies = [
"memchr",
"minimal-lexical",
@@ -5118,9 +5119,9 @@ dependencies = [
[[package]]
name = "once_cell"
-version = "1.16.0"
+version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
+checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
[[package]]
name = "oorandom"
@@ -5897,6 +5898,24 @@ dependencies = [
"sp-std",
]
+[[package]]
+name = "pallet-nfts"
+version = "4.0.0-dev"
+dependencies = [
+ "enumflags2",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
[[package]]
name = "pallet-nicks"
version = "4.0.0-dev"
@@ -6788,9 +6807,9 @@ checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
[[package]]
name = "pest"
-version = "2.5.1"
+version = "2.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc8bed3549e0f9b0a2a78bf7c0018237a2cdf085eecbbc048e52612438e4e9d0"
+checksum = "0f6e86fb9e7026527a0d46bc308b841d73170ef8f443e1807f6ef88526a816d4"
dependencies = [
"thiserror",
"ucd-trie",
@@ -6798,9 +6817,9 @@ dependencies = [
[[package]]
name = "pest_derive"
-version = "2.5.1"
+version = "2.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdc078600d06ff90d4ed238f0119d84ab5d43dbaad278b0e33a8820293b32344"
+checksum = "96504449aa860c8dcde14f9fba5c58dc6658688ca1fe363589d6327b8662c603"
dependencies = [
"pest",
"pest_generator",
@@ -6808,9 +6827,9 @@ dependencies = [
[[package]]
name = "pest_generator"
-version = "2.5.1"
+version = "2.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a1af60b1c4148bb269006a750cff8e2ea36aff34d2d96cf7be0b14d1bed23c"
+checksum = "798e0220d1111ae63d66cb66a5dcb3fc2d986d520b98e49e1852bfdb11d7c5e7"
dependencies = [
"pest",
"pest_meta",
@@ -6821,9 +6840,9 @@ dependencies = [
[[package]]
name = "pest_meta"
-version = "2.5.1"
+version = "2.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fec8605d59fc2ae0c6c1aefc0c7c7a9769732017c0ce07f7a9cfffa7b4404f20"
+checksum = "984298b75898e30a843e278a9f2452c31e349a073a0ce6fd950a12a74464e065"
dependencies = [
"once_cell",
"pest",
@@ -6990,9 +7009,9 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
[[package]]
name = "predicates"
-version = "2.1.4"
+version = "2.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f54fc5dc63ed3bbf19494623db4f3af16842c0d975818e469022d09e53f0aa05"
+checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
dependencies = [
"difflib",
"float-cmp",
@@ -7668,9 +7687,9 @@ dependencies = [
[[package]]
name = "rustix"
-version = "0.36.5"
+version = "0.36.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3807b5d10909833d3e9acd1eb5fb988f79376ff10fce42937de71a449c4c588"
+checksum = "4feacf7db682c6c329c4ede12649cd36ecab0f3be5b7d74e6a20304725db4549"
dependencies = [
"bitflags",
"errno",
@@ -7916,6 +7935,7 @@ dependencies = [
"sp-keystore",
"sp-panic-handler",
"sp-runtime",
+ "sp-tracing",
"sp-version",
"tempfile",
"thiserror",
@@ -8416,6 +8436,7 @@ dependencies = [
"assert_matches",
"async-trait",
"asynchronous-codec",
+ "backtrace",
"bytes",
"either",
"fnv",
@@ -8627,6 +8648,7 @@ dependencies = [
"pin-project",
"sc-network-common",
"sc-peerset",
+ "sc-utils",
"sp-consensus",
"sp-runtime",
"substrate-prometheus-endpoint",
@@ -8963,6 +8985,7 @@ dependencies = [
"parking_lot 0.12.1",
"pin-project",
"rand 0.8.5",
+ "sc-utils",
"serde",
"serde_json",
"thiserror",
@@ -9061,6 +9084,7 @@ dependencies = [
name = "sc-utils"
version = "4.0.0-dev"
dependencies = [
+ "backtrace",
"futures",
"futures-timer",
"lazy_static",
@@ -9267,9 +9291,9 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
[[package]]
name = "serde"
-version = "1.0.151"
+version = "1.0.152"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97fed41fc1a24994d044e6db6935e69511a1153b52c15eb42493b26fa87feba0"
+checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
dependencies = [
"serde_derive",
]
@@ -9286,9 +9310,9 @@ dependencies = [
[[package]]
name = "serde_derive"
-version = "1.0.151"
+version = "1.0.152"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "255abe9a125a985c05190d687b320c12f9b1f0b99445e608c21ba0782c719ad8"
+checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
dependencies = [
"proc-macro2",
"quote",
@@ -11344,6 +11368,7 @@ dependencies = [
"sc-executor",
"sc-service",
"serde",
+ "serde_json",
"sp-api",
"sp-core",
"sp-debug-derive",
diff --git a/Cargo.toml b/Cargo.toml
index eb78d5e104486..8f55d8e527ecd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -122,6 +122,7 @@ members = [
"frame/preimage",
"frame/proxy",
"frame/message-queue",
+ "frame/nfts",
"frame/nomination-pools",
"frame/nomination-pools/fuzzer",
"frame/nomination-pools/benchmarking",
diff --git a/bin/node/cli/tests/common.rs b/bin/node/cli/tests/common.rs
index 358c09779d59a..c8f9e2b3d3c82 100644
--- a/bin/node/cli/tests/common.rs
+++ b/bin/node/cli/tests/common.rs
@@ -161,6 +161,7 @@ pub fn find_ws_url_from_output(read: impl Read + Send) -> (String, String) {
let line =
line.expect("failed to obtain next line from stdout for WS address discovery");
data.push_str(&line);
+ data.push_str("\n");
// does the line contain our port (we expect this specific output from substrate).
let sock_addr = match line.split_once("Running JSON-RPC WS server: addr=") {
@@ -170,7 +171,10 @@ pub fn find_ws_url_from_output(read: impl Read + Send) -> (String, String) {
Some(format!("ws://{}", sock_addr))
})
- .expect("We should get a WebSocket address");
+ .unwrap_or_else(|| {
+ eprintln!("Observed node output:\n{}", data);
+ panic!("We should get a WebSocket address")
+ });
(ws_url, data)
}
diff --git a/bin/node/cli/tests/remember_state_pruning_works.rs b/bin/node/cli/tests/remember_state_pruning_works.rs
new file mode 100644
index 0000000000000..5b8e34cc7a00d
--- /dev/null
+++ b/bin/node/cli/tests/remember_state_pruning_works.rs
@@ -0,0 +1,38 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program 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.
+
+// This program 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 this program. If not, see .
+
+use tempfile::tempdir;
+
+pub mod common;
+
+#[tokio::test]
+#[cfg(unix)]
+async fn remember_state_pruning_works() {
+ let base_path = tempdir().expect("could not create a temp dir");
+
+ // First run with `--state-pruning=archive`.
+ common::run_node_for_a_while(
+ base_path.path(),
+ &["--dev", "--state-pruning=archive", "--no-hardware-benchmarks"],
+ )
+ .await;
+
+ // Then run again without specifying the state pruning.
+ // This should load state pruning settings from the db.
+ common::run_node_for_a_while(base_path.path(), &["--dev", "--no-hardware-benchmarks"]).await;
+}
diff --git a/bin/node/executor/tests/basic.rs b/bin/node/executor/tests/basic.rs
index c88703b929e6b..02b2a8787b5d5 100644
--- a/bin/node/executor/tests/basic.rs
+++ b/bin/node/executor/tests/basic.rs
@@ -30,7 +30,7 @@ use sp_runtime::{
use kitchensink_runtime::{
constants::{currency::*, time::SLOT_DURATION},
Balances, CheckedExtrinsic, Header, Runtime, RuntimeCall, RuntimeEvent, System,
- TransactionPayment, UncheckedExtrinsic,
+ TransactionPayment, Treasury, UncheckedExtrinsic,
};
use node_primitives::{Balance, Hash};
use node_testing::keyring::*;
@@ -398,6 +398,7 @@ fn full_native_block_import_works() {
});
fees = t.execute_with(|| transfer_fee(&xt()));
+ let pot = t.execute_with(|| Treasury::pot());
executor_call(&mut t, "Core_execute_block", &block2.0, true).0.unwrap();
@@ -408,6 +409,14 @@ fn full_native_block_import_works() {
);
assert_eq!(Balances::total_balance(&bob()), 179 * DOLLARS - fees);
let events = vec![
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Treasury(pallet_treasury::Event::UpdatedInactive {
+ reactivated: 0,
+ deactivated: pot,
+ }),
+ topics: vec![],
+ },
EventRecord {
phase: Phase::ApplyExtrinsic(0),
event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
diff --git a/bin/node/runtime/Cargo.toml b/bin/node/runtime/Cargo.toml
index 477545c9ac332..201e3a85f8941 100644
--- a/bin/node/runtime/Cargo.toml
+++ b/bin/node/runtime/Cargo.toml
@@ -78,6 +78,7 @@ pallet-membership = { version = "4.0.0-dev", default-features = false, path = ".
pallet-message-queue = { version = "7.0.0-dev", default-features = false, path = "../../../frame/message-queue" }
pallet-mmr = { version = "4.0.0-dev", default-features = false, path = "../../../frame/merkle-mountain-range" }
pallet-multisig = { version = "4.0.0-dev", default-features = false, path = "../../../frame/multisig" }
+pallet-nfts = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nfts" }
pallet-nomination-pools = { version = "1.0.0", default-features = false, path = "../../../frame/nomination-pools"}
pallet-nomination-pools-benchmarking = { version = "1.0.0", default-features = false, optional = true, path = "../../../frame/nomination-pools/benchmarking" }
pallet-nomination-pools-runtime-api = { version = "1.0.0-dev", default-features = false, path = "../../../frame/nomination-pools/runtime-api" }
@@ -197,6 +198,7 @@ std = [
"pallet-root-testing/std",
"pallet-recovery/std",
"pallet-uniques/std",
+ "pallet-nfts/std",
"pallet-vesting/std",
"log/std",
"frame-try-runtime?/std",
@@ -253,6 +255,7 @@ runtime-benchmarks = [
"pallet-treasury/runtime-benchmarks",
"pallet-utility/runtime-benchmarks",
"pallet-uniques/runtime-benchmarks",
+ "pallet-nfts/runtime-benchmarks",
"pallet-vesting/runtime-benchmarks",
"pallet-whitelist/runtime-benchmarks",
"frame-system-benchmarking/runtime-benchmarks",
@@ -312,6 +315,7 @@ try-runtime = [
"pallet-asset-tx-payment/try-runtime",
"pallet-transaction-storage/try-runtime",
"pallet-uniques/try-runtime",
+ "pallet-nfts/try-runtime",
"pallet-vesting/try-runtime",
"pallet-whitelist/try-runtime",
]
diff --git a/bin/node/runtime/src/lib.rs b/bin/node/runtime/src/lib.rs
index e5776e3fd692c..0c946fa180f20 100644
--- a/bin/node/runtime/src/lib.rs
+++ b/bin/node/runtime/src/lib.rs
@@ -56,6 +56,7 @@ use pallet_grandpa::{
fg_primitives, AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList,
};
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
+use pallet_nfts::PalletFeatures;
use pallet_nis::WithMaximumOf;
use pallet_session::historical::{self as pallet_session_historical};
pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustment};
@@ -301,6 +302,7 @@ impl InstanceFilter for ProxyType {
RuntimeCall::Balances(..) |
RuntimeCall::Assets(..) |
RuntimeCall::Uniques(..) |
+ RuntimeCall::Nfts(..) |
RuntimeCall::Vesting(pallet_vesting::Call::vested_transfer { .. }) |
RuntimeCall::Indices(pallet_indices::Call::transfer { .. })
),
@@ -565,7 +567,7 @@ impl pallet_staking::Config for Runtime {
type BondingDuration = BondingDuration;
type SlashDeferDuration = SlashDeferDuration;
/// A super-majority of the council can cancel the slash.
- type SlashCancelOrigin = EitherOfDiverse<
+ type AdminOrigin = EitherOfDiverse<
EnsureRoot,
pallet_collective::EnsureProportionAtLeast,
>;
@@ -1528,6 +1530,10 @@ parameter_types! {
pub const ItemDeposit: Balance = 1 * DOLLARS;
pub const KeyLimit: u32 = 32;
pub const ValueLimit: u32 = 256;
+ pub const ApprovalsLimit: u32 = 20;
+ pub const ItemAttributesApprovalsLimit: u32 = 20;
+ pub const MaxTips: u32 = 10;
+ pub const MaxDeadlineDuration: BlockNumber = 12 * 30 * DAYS;
}
impl pallet_uniques::Config for Runtime {
@@ -1551,6 +1557,36 @@ impl pallet_uniques::Config for Runtime {
type Locker = ();
}
+parameter_types! {
+ pub Features: PalletFeatures = PalletFeatures::all_enabled();
+}
+
+impl pallet_nfts::Config for Runtime {
+ type RuntimeEvent = RuntimeEvent;
+ type CollectionId = u32;
+ type ItemId = u32;
+ type Currency = Balances;
+ type ForceOrigin = frame_system::EnsureRoot;
+ type CollectionDeposit = CollectionDeposit;
+ type ItemDeposit = ItemDeposit;
+ type MetadataDepositBase = MetadataDepositBase;
+ type AttributeDepositBase = MetadataDepositBase;
+ type DepositPerByte = MetadataDepositPerByte;
+ type StringLimit = StringLimit;
+ type KeyLimit = KeyLimit;
+ type ValueLimit = ValueLimit;
+ type ApprovalsLimit = ApprovalsLimit;
+ type ItemAttributesApprovalsLimit = ItemAttributesApprovalsLimit;
+ type MaxTips = MaxTips;
+ type MaxDeadlineDuration = MaxDeadlineDuration;
+ type Features = Features;
+ type WeightInfo = pallet_nfts::weights::SubstrateWeight;
+ #[cfg(feature = "runtime-benchmarks")]
+ type Helper = ();
+ type CreateOrigin = AsEnsureOriginWithArg>;
+ type Locker = ();
+}
+
impl pallet_transaction_storage::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
@@ -1705,6 +1741,7 @@ construct_runtime!(
Lottery: pallet_lottery,
Nis: pallet_nis,
Uniques: pallet_uniques,
+ Nfts: pallet_nfts,
TransactionStorage: pallet_transaction_storage,
VoterList: pallet_bags_list::,
StateTrieMigration: pallet_state_trie_migration,
@@ -1836,6 +1873,7 @@ mod benches {
[pallet_transaction_storage, TransactionStorage]
[pallet_treasury, Treasury]
[pallet_uniques, Uniques]
+ [pallet_nfts, Nfts]
[pallet_utility, Utility]
[pallet_vesting, Vesting]
[pallet_whitelist, Whitelist]
diff --git a/client/api/src/client.rs b/client/api/src/client.rs
index 05e3163dcc7bd..0d00257fa7b06 100644
--- a/client/api/src/client.rs
+++ b/client/api/src/client.rs
@@ -21,7 +21,7 @@
use sp_consensus::BlockOrigin;
use sp_core::storage::StorageKey;
use sp_runtime::{
- generic::{BlockId, SignedBlock},
+ generic::SignedBlock,
traits::{Block as BlockT, NumberFor},
Justifications,
};
@@ -120,14 +120,13 @@ pub trait BlockBackend {
/// that are indexed by the runtime with `storage_index_transaction`.
fn block_indexed_body(&self, hash: Block::Hash) -> sp_blockchain::Result>>>;
- /// Get full block by id.
- fn block(&self, id: &BlockId) -> sp_blockchain::Result>>;
+ /// Get full block by hash.
+ fn block(&self, hash: Block::Hash) -> sp_blockchain::Result>>;
- /// Get block status.
- fn block_status(&self, id: &BlockId)
- -> sp_blockchain::Result;
+ /// Get block status by block hash.
+ fn block_status(&self, hash: Block::Hash) -> sp_blockchain::Result;
- /// Get block justifications for the block with the given id.
+ /// Get block justifications for the block with the given hash.
fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result>;
/// Get block hash by number.
diff --git a/client/api/src/notifications.rs b/client/api/src/notifications.rs
index 9fcc381f9697e..4dd23581d2622 100644
--- a/client/api/src/notifications.rs
+++ b/client/api/src/notifications.rs
@@ -144,7 +144,9 @@ impl StorageNotifications {
filter_keys: Option<&[StorageKey]>,
filter_child_keys: Option<&[(StorageKey, Option>)]>,
) -> StorageEventStream {
- let receiver = self.0.subscribe(registry::SubscribeOp { filter_keys, filter_child_keys });
+ let receiver = self
+ .0
+ .subscribe(registry::SubscribeOp { filter_keys, filter_child_keys }, 100_000);
StorageEventStream(receiver)
}
diff --git a/client/beefy/rpc/src/lib.rs b/client/beefy/rpc/src/lib.rs
index 59a133b86214e..4fea98c6eb24e 100644
--- a/client/beefy/rpc/src/lib.rs
+++ b/client/beefy/rpc/src/lib.rs
@@ -120,7 +120,7 @@ where
) -> Result {
let beefy_best_block = Arc::new(RwLock::new(None));
- let stream = best_block_stream.subscribe();
+ let stream = best_block_stream.subscribe(100_000);
let closure_clone = beefy_best_block.clone();
let future = stream.for_each(move |best_beefy| {
let async_clone = closure_clone.clone();
@@ -141,7 +141,7 @@ where
fn subscribe_justifications(&self, mut sink: SubscriptionSink) -> SubscriptionResult {
let stream = self
.finality_proof_stream
- .subscribe()
+ .subscribe(100_000)
.map(|vfp| notification::EncodedVersionedFinalityProof::new::(vfp));
let fut = async move {
diff --git a/client/beefy/src/lib.rs b/client/beefy/src/lib.rs
index 35f7cac55a964..5b6531822a0a1 100644
--- a/client/beefy/src/lib.rs
+++ b/client/beefy/src/lib.rs
@@ -265,7 +265,7 @@ where
// Subscribe to finality notifications and justifications before waiting for runtime pallet and
// reuse the streams, so we don't miss notifications while waiting for pallet to be available.
let mut finality_notifications = client.finality_notification_stream().fuse();
- let block_import_justif = links.from_block_import_justif_stream.subscribe().fuse();
+ let block_import_justif = links.from_block_import_justif_stream.subscribe(100_000).fuse();
// Wait for BEEFY pallet to be active before starting voter.
let persisted_state =
diff --git a/client/beefy/src/tests.rs b/client/beefy/src/tests.rs
index ce6f6ae3c978a..66d3a210d7eba 100644
--- a/client/beefy/src/tests.rs
+++ b/client/beefy/src/tests.rs
@@ -430,8 +430,8 @@ pub(crate) fn get_beefy_streams(
let beefy_rpc_links = net.peer(index).data.beefy_rpc_links.lock().clone().unwrap();
let BeefyRPCLinks { from_voter_justif_stream, from_voter_best_beefy_stream } =
beefy_rpc_links;
- best_block_streams.push(from_voter_best_beefy_stream.subscribe());
- versioned_finality_proof_streams.push(from_voter_justif_stream.subscribe());
+ best_block_streams.push(from_voter_best_beefy_stream.subscribe(100_000));
+ versioned_finality_proof_streams.push(from_voter_justif_stream.subscribe(100_000));
});
(best_block_streams, versioned_finality_proof_streams)
}
@@ -736,7 +736,7 @@ async fn beefy_importing_blocks() {
let hashof1 = block.header.hash();
// Import without justifications.
- let mut justif_recv = justif_stream.subscribe();
+ let mut justif_recv = justif_stream.subscribe(100_000);
assert_eq!(
block_import
.import_block(params(block.clone(), None), HashMap::new())
@@ -779,7 +779,7 @@ async fn beefy_importing_blocks() {
let builder = full_client.new_block_at(&parent_id, Default::default(), false).unwrap();
let block = builder.build().unwrap().block;
let hashof2 = block.header.hash();
- let mut justif_recv = justif_stream.subscribe();
+ let mut justif_recv = justif_stream.subscribe(100_000);
assert_eq!(
block_import.import_block(params(block, justif), HashMap::new()).await.unwrap(),
ImportResult::Imported(ImportedAux {
@@ -823,7 +823,7 @@ async fn beefy_importing_blocks() {
let builder = full_client.new_block_at(&parent_id, Default::default(), false).unwrap();
let block = builder.build().unwrap().block;
let hashof3 = block.header.hash();
- let mut justif_recv = justif_stream.subscribe();
+ let mut justif_recv = justif_stream.subscribe(100_000);
assert_eq!(
block_import.import_block(params(block, justif), HashMap::new()).await.unwrap(),
ImportResult::Imported(ImportedAux {
diff --git a/client/cli/Cargo.toml b/client/cli/Cargo.toml
index 91b0745330698..5e1f2bab4be9f 100644
--- a/client/cli/Cargo.toml
+++ b/client/cli/Cargo.toml
@@ -50,6 +50,7 @@ sp-version = { version = "5.0.0", path = "../../primitives/version" }
[dev-dependencies]
tempfile = "3.1.0"
futures-timer = "3.0.1"
+sp-tracing = { version = "6.0.0", path = "../../primitives/tracing" }
[features]
default = ["rocksdb"]
diff --git a/client/cli/src/commands/export_blocks_cmd.rs b/client/cli/src/commands/export_blocks_cmd.rs
index e2f83200e511c..76fedff4d3ad7 100644
--- a/client/cli/src/commands/export_blocks_cmd.rs
+++ b/client/cli/src/commands/export_blocks_cmd.rs
@@ -23,7 +23,7 @@ use crate::{
};
use clap::Parser;
use log::info;
-use sc_client_api::{BlockBackend, UsageProvider};
+use sc_client_api::{BlockBackend, HeaderBackend, UsageProvider};
use sc_service::{chain_ops::export_blocks, config::DatabaseSource};
use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
use std::{fmt::Debug, fs, io, path::PathBuf, str::FromStr, sync::Arc};
@@ -73,7 +73,7 @@ impl ExportBlocksCmd {
) -> error::Result<()>
where
B: BlockT,
- C: BlockBackend + UsageProvider + 'static,
+ C: HeaderBackend + BlockBackend + UsageProvider + 'static,
<::Number as FromStr>::Err: Debug,
{
if let Some(path) = database_config.path() {
diff --git a/client/cli/src/params/pruning_params.rs b/client/cli/src/params/pruning_params.rs
index 7e50f53d7169a..fd01ba67bab7d 100644
--- a/client/cli/src/params/pruning_params.rs
+++ b/client/cli/src/params/pruning_params.rs
@@ -28,21 +28,44 @@ pub struct PruningParams {
/// This mode specifies when the block's state (ie, storage)
/// should be pruned (ie, removed) from the database.
///
+ /// This setting can only be set on the first creation of the database. Every subsequent run
+ /// will load the pruning mode from the database and will error if the stored mode doesn't
+ /// match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+ ///
/// Possible values:
- /// 'archive' Keep the state of all blocks.
- /// 'archive-canonical' Keep only the state of finalized blocks.
- /// number Keep the state of the last number of finalized blocks.
- #[arg(alias = "pruning", long, value_name = "PRUNING_MODE", default_value = "256")]
- pub state_pruning: DatabasePruningMode,
+ ///
+ /// - archive:
+ ///
+ /// Keep the state of all blocks.
+ ///
+ /// - 'archive-canonical'
+ ///
+ /// Keep only the state of finalized blocks.
+ ///
+ /// - number
+ ///
+ /// Keep the state of the last number of finalized blocks.
+ ///
+ /// [default: 256]
+ #[arg(alias = "pruning", long, value_name = "PRUNING_MODE")]
+ pub state_pruning: Option,
/// Specify the blocks pruning mode.
///
/// This mode specifies when the block's body (including justifications)
/// should be pruned (ie, removed) from the database.
///
/// Possible values:
- /// 'archive' Keep all blocks.
- /// 'archive-canonical' Keep only finalized blocks.
- /// number Keep the last `number` of finalized blocks.
+ /// - 'archive'
+ ///
+ /// Keep all blocks.
+ ///
+ /// - 'archive-canonical'
+ ///
+ /// Keep only finalized blocks.
+ ///
+ /// - number
+ ///
+ /// Keep the last `number` of finalized blocks.
#[arg(
alias = "keep-blocks",
long,
@@ -55,7 +78,7 @@ pub struct PruningParams {
impl PruningParams {
/// Get the pruning value from the parameters
pub fn state_pruning(&self) -> error::Result> {
- Ok(Some(self.state_pruning.into()))
+ Ok(self.state_pruning.map(|v| v.into()))
}
/// Get the block pruning value from the parameters
diff --git a/client/cli/src/runner.rs b/client/cli/src/runner.rs
index 897a2c4726ae8..c7a6f1f3c0f99 100644
--- a/client/cli/src/runner.rs
+++ b/client/cli/src/runner.rs
@@ -152,10 +152,38 @@ impl Runner {
//
// This is important to be done before we instruct the tokio runtime to shutdown. Otherwise
// the tokio runtime will wait the full 60 seconds for all tasks to stop.
- drop(task_manager);
+ let task_registry = task_manager.into_task_registry();
// Give all futures 60 seconds to shutdown, before tokio "leaks" them.
- self.tokio_runtime.shutdown_timeout(Duration::from_secs(60));
+ let shutdown_timeout = Duration::from_secs(60);
+ self.tokio_runtime.shutdown_timeout(shutdown_timeout);
+
+ let running_tasks = task_registry.running_tasks();
+
+ if !running_tasks.is_empty() {
+ log::error!("Detected running(potentially stalled) tasks on shutdown:");
+ running_tasks.iter().for_each(|(task, count)| {
+ let instances_desc =
+ if *count > 1 { format!("with {} instances ", count) } else { "".to_string() };
+
+ if task.is_default_group() {
+ log::error!(
+ "Task \"{}\" was still running {}after waiting {} seconds to finish.",
+ task.name,
+ instances_desc,
+ shutdown_timeout.as_secs(),
+ );
+ } else {
+ log::error!(
+ "Task \"{}\" (Group: {}) was still running {}after waiting {} seconds to finish.",
+ task.name,
+ task.group,
+ instances_desc,
+ shutdown_timeout.as_secs(),
+ );
+ }
+ });
+ }
res.map_err(Into::into)
}
@@ -388,34 +416,75 @@ mod tests {
assert!((count as u128) < (Duration::from_secs(30).as_millis() / 50));
}
+ fn run_test_in_another_process(
+ test_name: &str,
+ test_body: impl FnOnce(),
+ ) -> Option {
+ if std::env::var("RUN_FORKED_TEST").is_ok() {
+ test_body();
+ None
+ } else {
+ let output = std::process::Command::new(std::env::current_exe().unwrap())
+ .arg(test_name)
+ .env("RUN_FORKED_TEST", "1")
+ .output()
+ .unwrap();
+
+ assert!(output.status.success());
+ Some(output)
+ }
+ }
+
/// This test ensures that `run_node_until_exit` aborts waiting for "stuck" tasks after 60
/// seconds, aka doesn't wait until they are finished (which may never happen).
#[test]
fn ensure_run_until_exit_is_not_blocking_indefinitely() {
- let runner = create_runner();
+ let output = run_test_in_another_process(
+ "ensure_run_until_exit_is_not_blocking_indefinitely",
+ || {
+ sp_tracing::try_init_simple();
+
+ let runner = create_runner();
+
+ runner
+ .run_node_until_exit(move |cfg| async move {
+ let task_manager =
+ TaskManager::new(cfg.tokio_handle.clone(), None).unwrap();
+ let (sender, receiver) = futures::channel::oneshot::channel();
+
+ // We need to use `spawn_blocking` here so that we get a dedicated thread
+ // for our future. This future is more blocking code that will never end.
+ task_manager.spawn_handle().spawn_blocking("test", None, async move {
+ let _ = sender.send(());
+ loop {
+ std::thread::sleep(Duration::from_secs(30));
+ }
+ });
+
+ task_manager.spawn_essential_handle().spawn_blocking(
+ "test2",
+ None,
+ async {
+ // Let's stop this essential task directly when our other task
+ // started. It will signal that the task manager should end.
+ let _ = receiver.await;
+ },
+ );
+
+ Ok::<_, sc_service::Error>(task_manager)
+ })
+ .unwrap_err();
+ },
+ );
- runner
- .run_node_until_exit(move |cfg| async move {
- let task_manager = TaskManager::new(cfg.tokio_handle.clone(), None).unwrap();
- let (sender, receiver) = futures::channel::oneshot::channel();
+ let Some(output) = output else { return } ;
- // We need to use `spawn_blocking` here so that we get a dedicated thread for our
- // future. This future is more blocking code that will never end.
- task_manager.spawn_handle().spawn_blocking("test", None, async move {
- let _ = sender.send(());
- loop {
- std::thread::sleep(Duration::from_secs(30));
- }
- });
-
- task_manager.spawn_essential_handle().spawn_blocking("test2", None, async {
- // Let's stop this essential task directly when our other task started.
- // It will signal that the task manager should end.
- let _ = receiver.await;
- });
+ let stderr = dbg!(String::from_utf8(output.stderr).unwrap());
- Ok::<_, sc_service::Error>(task_manager)
- })
- .unwrap_err();
+ assert!(
+ stderr.contains("Task \"test\" was still running after waiting 60 seconds to finish.")
+ );
+ assert!(!stderr
+ .contains("Task \"test2\" was still running after waiting 60 seconds to finish."));
}
}
diff --git a/client/consensus/babe/src/lib.rs b/client/consensus/babe/src/lib.rs
index 1d5d4b5fe5413..41c00169e5412 100644
--- a/client/consensus/babe/src/lib.rs
+++ b/client/consensus/babe/src/lib.rs
@@ -543,7 +543,7 @@ fn aux_storage_cleanup + HeaderBackend, Block: B
let stale_forks = match client.expand_forks(¬ification.stale_heads) {
Ok(stale_forks) => stale_forks,
Err((stale_forks, e)) => {
- warn!(target: "babe", "{:?}", e,);
+ warn!(target: LOG_TARGET, "{:?}", e);
stale_forks
},
};
@@ -1511,11 +1511,12 @@ where
if let Some(next_epoch_descriptor) = next_epoch_digest {
old_epoch_changes = Some((*epoch_changes).clone());
- let viable_epoch = epoch_changes
+ let mut viable_epoch = epoch_changes
.viable_epoch(&epoch_descriptor, |slot| Epoch::genesis(&self.config, slot))
.ok_or_else(|| {
ConsensusError::ClientImport(Error::::FetchEpoch(parent_hash).into())
- })?;
+ })?
+ .into_cloned();
let epoch_config = next_config_digest
.map(Into::into)
@@ -1528,6 +1529,48 @@ where
log::Level::Info
};
+ if viable_epoch.as_ref().end_slot() <= slot {
+ // some epochs must have been skipped as our current slot
+ // fits outside the current epoch. we will figure out
+ // which epoch it belongs to and we will re-use the same
+ // data for that epoch
+ let mut epoch_data = viable_epoch.as_mut();
+ let skipped_epochs =
+ *slot.saturating_sub(epoch_data.start_slot) / epoch_data.duration;
+
+ // NOTE: notice that we are only updating a local copy of the `Epoch`, this
+ // makes it so that when we insert the next epoch into `EpochChanges` below
+ // (after incrementing it), it will use the correct epoch index and start slot.
+ // we do not update the original epoch that will be re-used because there might
+ // be other forks (that we haven't imported) where the epoch isn't skipped, and
+ // to import those forks we want to keep the original epoch data. not updating
+ // the original epoch works because when we search the tree for which epoch to
+ // use for a given slot, we will search in-depth with the predicate
+ // `epoch.start_slot <= slot` which will still match correctly without updating
+ // `start_slot` to the correct value as below.
+ let epoch_index = epoch_data.epoch_index.checked_add(skipped_epochs).expect(
+ "epoch number is u64; it should be strictly smaller than number of slots; \
+ slots relate in some way to wall clock time; \
+ if u64 is not enough we should crash for safety; qed.",
+ );
+
+ let start_slot = skipped_epochs
+ .checked_mul(epoch_data.duration)
+ .and_then(|skipped_slots| epoch_data.start_slot.checked_add(skipped_slots))
+ .expect(
+ "slot number is u64; it should relate in some way to wall clock time; \
+ if u64 is not enough we should crash for safety; qed.",
+ );
+
+ warn!(
+ target: LOG_TARGET,
+ "👶 Epoch(s) skipped: from {} to {}", epoch_data.epoch_index, epoch_index,
+ );
+
+ epoch_data.epoch_index = epoch_index;
+ epoch_data.start_slot = Slot::from(start_slot);
+ }
+
log!(
target: LOG_TARGET,
log_level,
diff --git a/client/consensus/babe/src/tests.rs b/client/consensus/babe/src/tests.rs
index 84ac3d7341199..f74864a003e2a 100644
--- a/client/consensus/babe/src/tests.rs
+++ b/client/consensus/babe/src/tests.rs
@@ -28,6 +28,7 @@ use rand_chacha::{
use sc_block_builder::{BlockBuilder, BlockBuilderProvider};
use sc_client_api::{backend::TransactionFor, BlockchainEvents, Finalizer};
use sc_consensus::{BoxBlockImport, BoxJustificationImport};
+use sc_consensus_epochs::{EpochIdentifier, EpochIdentifierPosition};
use sc_consensus_slots::BackoffAuthoringOnFinalizedHeadLagging;
use sc_network_test::{Block as TestBlock, *};
use sp_application_crypto::key_types::BABE;
@@ -1109,3 +1110,263 @@ async fn obsolete_blocks_aux_data_cleanup() {
// Present C4, C5
assert!(aux_data_check(&fork3_hashes, true));
}
+
+#[tokio::test]
+async fn allows_skipping_epochs() {
+ let mut net = BabeTestNet::new(1);
+
+ let peer = net.peer(0);
+ let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+ let client = peer.client().as_client();
+ let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+ let mut proposer_factory = DummyFactory {
+ client: client.clone(),
+ config: data.link.config.clone(),
+ epoch_changes: data.link.epoch_changes.clone(),
+ mutator: Arc::new(|_, _| ()),
+ };
+
+ let epoch_changes = data.link.epoch_changes.clone();
+ let epoch_length = data.link.config.epoch_length;
+
+ // we create all of the blocks in epoch 0 as well as a block in epoch 1
+ let blocks = propose_and_import_blocks(
+ &client,
+ &mut proposer_factory,
+ &mut block_import,
+ client.chain_info().genesis_hash,
+ epoch_length as usize + 1,
+ )
+ .await;
+
+ // the first block in epoch 0 (#1) announces both epoch 0 and 1 (this is a
+ // special genesis epoch)
+ let epoch0 = epoch_changes
+ .shared_data()
+ .epoch(&EpochIdentifier {
+ position: EpochIdentifierPosition::Genesis0,
+ hash: blocks[0],
+ number: 1,
+ })
+ .unwrap()
+ .clone();
+
+ assert_eq!(epoch0.epoch_index, 0);
+ assert_eq!(epoch0.start_slot, Slot::from(1));
+
+ let epoch1 = epoch_changes
+ .shared_data()
+ .epoch(&EpochIdentifier {
+ position: EpochIdentifierPosition::Genesis1,
+ hash: blocks[0],
+ number: 1,
+ })
+ .unwrap()
+ .clone();
+
+ assert_eq!(epoch1.epoch_index, 1);
+ assert_eq!(epoch1.start_slot, Slot::from(epoch_length + 1));
+
+ // the first block in epoch 1 (#7) announces epoch 2. we will be skipping
+ // this epoch and therefore re-using its data for epoch 3
+ let epoch2 = epoch_changes
+ .shared_data()
+ .epoch(&EpochIdentifier {
+ position: EpochIdentifierPosition::Regular,
+ hash: blocks[epoch_length as usize],
+ number: epoch_length + 1,
+ })
+ .unwrap()
+ .clone();
+
+ assert_eq!(epoch2.epoch_index, 2);
+ assert_eq!(epoch2.start_slot, Slot::from(epoch_length * 2 + 1));
+
+ // we now author a block that belongs to epoch 3, thereby skipping epoch 2
+ let last_block = client.expect_header(*blocks.last().unwrap()).unwrap();
+ let block = propose_and_import_block(
+ &last_block,
+ Some((epoch_length * 3 + 1).into()),
+ &mut proposer_factory,
+ &mut block_import,
+ )
+ .await;
+
+ // and the first block in epoch 3 (#8) announces epoch 4
+ let epoch4 = epoch_changes
+ .shared_data()
+ .epoch(&EpochIdentifier {
+ position: EpochIdentifierPosition::Regular,
+ hash: block,
+ number: epoch_length + 2,
+ })
+ .unwrap()
+ .clone();
+
+ assert_eq!(epoch4.epoch_index, 4);
+ assert_eq!(epoch4.start_slot, Slot::from(epoch_length * 4 + 1));
+
+ // if we try to get the epoch data for a slot in epoch 3
+ let epoch3 = epoch_changes
+ .shared_data()
+ .epoch_data_for_child_of(
+ descendent_query(&*client),
+ &block,
+ epoch_length + 2,
+ (epoch_length * 3 + 2).into(),
+ |slot| Epoch::genesis(&data.link.config, slot),
+ )
+ .unwrap()
+ .unwrap();
+
+ // we get back the data for epoch 2
+ assert_eq!(epoch3, epoch2);
+
+ // but if we try to get the epoch data for a slot in epoch 4
+ let epoch4_ = epoch_changes
+ .shared_data()
+ .epoch_data_for_child_of(
+ descendent_query(&*client),
+ &block,
+ epoch_length + 2,
+ (epoch_length * 4 + 1).into(),
+ |slot| Epoch::genesis(&data.link.config, slot),
+ )
+ .unwrap()
+ .unwrap();
+
+ // we get epoch 4 as expected
+ assert_eq!(epoch4, epoch4_);
+}
+
+#[tokio::test]
+async fn allows_skipping_epochs_on_some_forks() {
+ let mut net = BabeTestNet::new(1);
+
+ let peer = net.peer(0);
+ let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+ let client = peer.client().as_client();
+ let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+ let mut proposer_factory = DummyFactory {
+ client: client.clone(),
+ config: data.link.config.clone(),
+ epoch_changes: data.link.epoch_changes.clone(),
+ mutator: Arc::new(|_, _| ()),
+ };
+
+ let epoch_changes = data.link.epoch_changes.clone();
+ let epoch_length = data.link.config.epoch_length;
+
+ // we create all of the blocks in epoch 0 as well as two blocks in epoch 1
+ let blocks = propose_and_import_blocks(
+ &client,
+ &mut proposer_factory,
+ &mut block_import,
+ client.chain_info().genesis_hash,
+ epoch_length as usize + 1,
+ )
+ .await;
+
+ // we now author a block that belongs to epoch 2, built on top of the last
+ // authored block in epoch 1.
+ let last_block = client.expect_header(*blocks.last().unwrap()).unwrap();
+
+ let epoch2_block = propose_and_import_block(
+ &last_block,
+ Some((epoch_length * 2 + 1).into()),
+ &mut proposer_factory,
+ &mut block_import,
+ )
+ .await;
+
+ // if we try to get the epoch data for a slot in epoch 2, we get the data that
+ // was previously announced when epoch 1 started
+ let epoch2 = epoch_changes
+ .shared_data()
+ .epoch_data_for_child_of(
+ descendent_query(&*client),
+ &epoch2_block,
+ epoch_length + 2,
+ (epoch_length * 2 + 2).into(),
+ |slot| Epoch::genesis(&data.link.config, slot),
+ )
+ .unwrap()
+ .unwrap();
+
+ // we now author a block that belongs to epoch 3, built on top of the last
+ // authored block in epoch 1. authoring this block means we're skipping epoch 2
+ // entirely on this fork
+ let epoch3_block = propose_and_import_block(
+ &last_block,
+ Some((epoch_length * 3 + 1).into()),
+ &mut proposer_factory,
+ &mut block_import,
+ )
+ .await;
+
+ // if we try to get the epoch data for a slot in epoch 3
+ let epoch3_ = epoch_changes
+ .shared_data()
+ .epoch_data_for_child_of(
+ descendent_query(&*client),
+ &epoch3_block,
+ epoch_length + 2,
+ (epoch_length * 3 + 2).into(),
+ |slot| Epoch::genesis(&data.link.config, slot),
+ )
+ .unwrap()
+ .unwrap();
+
+ // we get back the data for epoch 2
+ assert_eq!(epoch3_, epoch2);
+
+ // if we try to get the epoch data for a slot in epoch 4 in the fork
+ // where we skipped epoch 2, we should get the epoch data for epoch 4
+ // that was announced at the beginning of epoch 3
+ let epoch_data = epoch_changes
+ .shared_data()
+ .epoch_data_for_child_of(
+ descendent_query(&*client),
+ &epoch3_block,
+ epoch_length + 2,
+ (epoch_length * 4 + 1).into(),
+ |slot| Epoch::genesis(&data.link.config, slot),
+ )
+ .unwrap()
+ .unwrap();
+
+ assert!(epoch_data != epoch3_);
+
+ // if we try to get the epoch data for a slot in epoch 4 in the fork
+ // where we didn't skip epoch 2, we should get back the data for epoch 3,
+ // that was announced when epoch 2 started in that fork
+ let epoch_data = epoch_changes
+ .shared_data()
+ .epoch_data_for_child_of(
+ descendent_query(&*client),
+ &epoch2_block,
+ epoch_length + 2,
+ (epoch_length * 4 + 1).into(),
+ |slot| Epoch::genesis(&data.link.config, slot),
+ )
+ .unwrap()
+ .unwrap();
+
+ assert!(epoch_data != epoch3_);
+
+ let epoch3 = epoch_changes
+ .shared_data()
+ .epoch(&EpochIdentifier {
+ position: EpochIdentifierPosition::Regular,
+ hash: epoch2_block,
+ number: epoch_length + 2,
+ })
+ .unwrap()
+ .clone();
+
+ assert_eq!(epoch_data, epoch3);
+}
diff --git a/client/consensus/common/src/import_queue/basic_queue.rs b/client/consensus/common/src/import_queue/basic_queue.rs
index b63bc192b2e77..a96b0a47e57c7 100644
--- a/client/consensus/common/src/import_queue/basic_queue.rs
+++ b/client/consensus/common/src/import_queue/basic_queue.rs
@@ -69,7 +69,7 @@ impl BasicQueue {
spawner: &impl sp_core::traits::SpawnEssentialNamed,
prometheus_registry: Option<&Registry>,
) -> Self {
- let (result_sender, result_port) = buffered_link::buffered_link();
+ let (result_sender, result_port) = buffered_link::buffered_link(100_000);
let metrics = prometheus_registry.and_then(|r| {
Metrics::register(r)
@@ -276,10 +276,10 @@ impl BlockImportWorker {
use worker_messages::*;
let (justification_sender, mut justification_port) =
- tracing_unbounded("mpsc_import_queue_worker_justification");
+ tracing_unbounded("mpsc_import_queue_worker_justification", 100_000);
let (block_import_sender, block_import_port) =
- tracing_unbounded("mpsc_import_queue_worker_blocks");
+ tracing_unbounded("mpsc_import_queue_worker_blocks", 100_000);
let mut worker = BlockImportWorker { result_sender, justification_import, metrics };
@@ -595,7 +595,7 @@ mod tests {
#[test]
fn prioritizes_finality_work_over_block_import() {
- let (result_sender, mut result_port) = buffered_link::buffered_link();
+ let (result_sender, mut result_port) = buffered_link::buffered_link(100_000);
let (worker, mut finality_sender, mut block_import_sender) =
BlockImportWorker::new(result_sender, (), Box::new(()), Some(Box::new(())), None);
diff --git a/client/consensus/common/src/import_queue/buffered_link.rs b/client/consensus/common/src/import_queue/buffered_link.rs
index e6d3b212fdbac..71adcf2dc2ea9 100644
--- a/client/consensus/common/src/import_queue/buffered_link.rs
+++ b/client/consensus/common/src/import_queue/buffered_link.rs
@@ -28,7 +28,7 @@
//! # use sp_test_primitives::Block;
//! # struct DummyLink; impl Link for DummyLink {}
//! # let mut my_link = DummyLink;
-//! let (mut tx, mut rx) = buffered_link::();
+//! let (mut tx, mut rx) = buffered_link::(100_000);
//! tx.blocks_processed(0, 0, vec![]);
//!
//! // Calls `my_link.blocks_processed(0, 0, vec![])` when polled.
@@ -51,9 +51,11 @@ use super::BlockImportResult;
/// Wraps around an unbounded channel from the `futures` crate. The sender implements `Link` and
/// can be used to buffer commands, and the receiver can be used to poll said commands and transfer
-/// them to another link.
-pub fn buffered_link() -> (BufferedLinkSender, BufferedLinkReceiver) {
- let (tx, rx) = tracing_unbounded("mpsc_buffered_link");
+/// them to another link. `queue_size_warning` sets the warning threshold of the channel queue size.
+pub fn buffered_link(
+ queue_size_warning: i64,
+) -> (BufferedLinkSender, BufferedLinkReceiver) {
+ let (tx, rx) = tracing_unbounded("mpsc_buffered_link", queue_size_warning);
let tx = BufferedLinkSender { tx };
let rx = BufferedLinkReceiver { rx: rx.fuse() };
(tx, rx)
@@ -175,7 +177,7 @@ mod tests {
#[test]
fn is_closed() {
- let (tx, rx) = super::buffered_link::();
+ let (tx, rx) = super::buffered_link::(1);
assert!(!tx.is_closed());
drop(rx);
assert!(tx.is_closed());
diff --git a/client/finality-grandpa/rpc/src/lib.rs b/client/finality-grandpa/rpc/src/lib.rs
index dfdad666ba8f3..70ff7ed176869 100644
--- a/client/finality-grandpa/rpc/src/lib.rs
+++ b/client/finality-grandpa/rpc/src/lib.rs
@@ -104,7 +104,7 @@ where
}
fn subscribe_justifications(&self, mut sink: SubscriptionSink) -> SubscriptionResult {
- let stream = self.justification_stream.subscribe().map(
+ let stream = self.justification_stream.subscribe(100_000).map(
|x: sc_finality_grandpa::GrandpaJustification| {
JustificationNotification::from(x)
},
diff --git a/client/finality-grandpa/src/communication/gossip.rs b/client/finality-grandpa/src/communication/gossip.rs
index 408cbda745e56..cbcafc727d436 100644
--- a/client/finality-grandpa/src/communication/gossip.rs
+++ b/client/finality-grandpa/src/communication/gossip.rs
@@ -1364,7 +1364,7 @@ impl GossipValidator {
None => None,
};
- let (tx, rx) = tracing_unbounded("mpsc_grandpa_gossip_validator");
+ let (tx, rx) = tracing_unbounded("mpsc_grandpa_gossip_validator", 100_000);
let val = GossipValidator {
inner: parking_lot::RwLock::new(Inner::new(config)),
set_state,
diff --git a/client/finality-grandpa/src/communication/periodic.rs b/client/finality-grandpa/src/communication/periodic.rs
index 7e50abb96e441..c00fed1296512 100644
--- a/client/finality-grandpa/src/communication/periodic.rs
+++ b/client/finality-grandpa/src/communication/periodic.rs
@@ -70,6 +70,7 @@ impl NeighborPacketWorker {
pub(super) fn new(rebroadcast_period: Duration) -> (Self, NeighborPacketSender) {
let (tx, rx) = tracing_unbounded::<(Vec, NeighborPacket>)>(
"mpsc_grandpa_neighbor_packet_worker",
+ 100_000,
);
let delay = Delay::new(rebroadcast_period);
diff --git a/client/finality-grandpa/src/communication/tests.rs b/client/finality-grandpa/src/communication/tests.rs
index eab7bb2df50cf..839b2d52be651 100644
--- a/client/finality-grandpa/src/communication/tests.rs
+++ b/client/finality-grandpa/src/communication/tests.rs
@@ -135,7 +135,7 @@ impl NetworkEventStream for TestNetwork {
&self,
_name: &'static str,
) -> Pin + Send>> {
- let (tx, rx) = tracing_unbounded("test");
+ let (tx, rx) = tracing_unbounded("test", 100_000);
let _ = self.sender.unbounded_send(Event::EventStream(tx));
Box::pin(rx)
}
@@ -253,7 +253,7 @@ fn voter_set_state() -> SharedVoterSetState {
// needs to run in a tokio runtime.
pub(crate) fn make_test_network() -> (impl Future