pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-29 21:41:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

start working on building the real overseer (#1795)

Browse Source 
* start working on building the real overseer

Unfortunately, this fails to compile right now due to an upstream
failure to compile which is probably brought on by a recent upgrade
to rustc v1.47.

* fill in AllSubsystems internal constructors

* replace fn make_metrics with Metrics::attempt_to_register

* update to account for #1740

* remove Metrics::register, rename Metrics::attempt_to_register

* add 'static bounds to real_overseer type params

* pass authority_discovery and network_service to real_overseer

It's not straightforwardly obvious that this is the best way to handle
the case when there is no authority discovery service, but it seems
to be the best option available at the moment.

* select a proper database configuration for the availability store db

* use subdirectory for av-store database path

* apply Basti's patch which avoids needing to parameterize everything on Block

* simplify path extraction

* get all tests to compile

* Fix Prometheus double-registry error

for debugging purposes, added this to node/subsystem-util/src/lib.rs:472-476:

```rust
Some(registry) => Self::try_register(registry).map_err(|err| {
	eprintln!("PrometheusError calling {}::register: {:?}", std::any::type_name::<Self>(), err);
	err
}),
```

That pointed out where the registration was failing, which led to
this fix. The test still doesn't pass, but it now fails in a new
and different way!

* authorities must have authority discovery, but not necessarily overseer handlers

* fix broken SpawnedSubsystem impls

detailed logging determined that using the `Box::new` style of
future generation, the `self.run` method was never being called,
leading to dropped receivers / closed senders for those subsystems,
causing the overseer to shut down immediately.

This is not the final fix needed to get things working properly,
but it's a good start.

* use prometheus properly

Prometheus lets us register simple counters, which aren't very
interesting. It also allows us to register CounterVecs, which are.
With a CounterVec, you can provide a set of labels, which can
later be used to filter the counts.

We were using them wrong, though. This pattern was repeated in a
variety of places in the code:

```rust
// panics with an cardinality mismatch
let my_counter = register(CounterVec::new(opts, &["succeeded", "failed"])?, registry)?;
my_counter.with_label_values(&["succeeded"]).inc()
```

The problem is that the labels provided in the constructor are not
the set of legal values which can be annotated, but a set of individual
label names which can have individual, arbitrary values.

This commit fixes that.

* get av-store subsystem to actually run properly and not die on first signal

* typo fix: incomming -> incoming

* don't disable authority discovery in test nodes

* Fix rococo-v1 missing session keys

* Update node/core/av-store/Cargo.toml

* try dummying out av-store on non-full-nodes

* overseer and subsystems are required only for full nodes

* Reduce the amount of warnings on browser target

* Fix two more warnings

* InclusionInherent should actually have an Inherent module on rococo

* Ancestry: don't return genesis' parent hash

* Update Cargo.lock

* fix broken test

* update test script: specify chainspec as script argument

* Apply suggestions from code review

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* Update node/service/src/lib.rs

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* node/service/src/lib: Return error via ? operator

* post-merge blues

* add is_collator flag

* prevent occasional av-store test panic

* simplify fix; expand application

* run authority_discovery in Role::Discover when collating

* distinguish between proposer closed channel errors

* add IsCollator enum, remove is_collator CLI flag

* improve formatting

* remove nop loop

* Fix some stuff

Co-authored-by: Andronik Ordian <write@reusable.software>
Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: Fedor Sakharov <fedor.sakharov@gmail.com>
Co-authored-by: Robert Habermeier <robert@Roberts-MBP.lan1>
Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
Co-authored-by: Max Inden <mail@max-inden.de>
This commit is contained in:
Peter Goodspeed-Niklaus
2020-10-28 11:26:50 +01:00
committed by GitHub
parent 5fbb8a381c
commit 1a25c41277
29 changed files with 420 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files
polkadot/Cargo.lock
Generated
+19 -1
View File
@@ -4922,6 +4922,7 @@ dependencies = [
"polkadot-node-subsystem-util",
"polkadot-overseer",
"polkadot-primitives",
"sc-service",
"smallvec 1.4.2",
"sp-core",
"thiserror",
@@ -5108,6 +5109,7 @@ dependencies = [
"sc-network",
"smallvec 1.4.2",
"sp-core",
"substrate-prometheus-endpoint",
"thiserror",
]
@@ -5454,13 +5456,29 @@ dependencies = [
"pallet-transaction-payment-rpc-runtime-api",
"parity-scale-codec",
"parking_lot 0.9.0",
"polkadot-availability-bitfield-distribution",
"polkadot-availability-distribution",
"polkadot-collator-protocol",
"polkadot-network-bridge",
"polkadot-node-collation-generation",
"polkadot-node-core-av-store",
"polkadot-node-core-backing",
"polkadot-node-core-bitfield-signing",
"polkadot-node-core-candidate-selection",
"polkadot-node-core-candidate-validation",
"polkadot-node-core-chain-api",
"polkadot-node-core-proposer",
"polkadot-node-core-provisioner",
"polkadot-node-core-runtime-api",
"polkadot-node-subsystem",
"polkadot-node-subsystem-util",
"polkadot-overseer",
"polkadot-parachain",
"polkadot-pov-distribution",
"polkadot-primitives",
"polkadot-rpc",
"polkadot-runtime",
"polkadot-statement-distribution",
"polkadot-test-client",
"rococo-v1-runtime",
"sc-authority-discovery",
@@ -5472,7 +5490,6 @@ dependencies = [
"sc-consensus-babe",
"sc-executor",
"sc-finality-grandpa",
"sc-keystore",
"sc-network",
"sc-service",
"sc-telemetry",
@@ -5489,6 +5506,7 @@ dependencies = [
"sp-finality-grandpa",
"sp-inherents",
"sp-io",
"sp-keystore",
"sp-offchain",
"sp-runtime",
"sp-session",
polkadot/cli/src/browser.rs
-1
View File
@@ -20,7 +20,6 @@ use browser_utils::{
Client,
browser_configuration, set_console_error_panic_hook, init_console_log,
};
use std::str::FromStr;
/// Starts the client.
#[wasm_bindgen]
polkadot/cli/src/command.rs
+1
View File
@@ -148,6 +148,7 @@ pub fn run() -> Result<()> {
_ => service::build_full(
config,
authority_discovery_disabled,
service::IsCollator::No,
grandpa_pause,
).map(|full| full.task_manager),
}
polkadot/node/core/av-store/Cargo.toml
+2
View File
@@ -19,6 +19,8 @@ polkadot-node-subsystem-util = { path = "../../subsystem-util" }
polkadot-overseer = { path = "../../overseer" }
polkadot-primitives = { path = "../../../primitives" }
sc-service = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
[dev-dependencies]
env_logger = "0.7.1"
assert_matches = "1.3.0"
polkadot/node/core/av-store/src/lib.rs
+31 -12
View File
@@ -397,6 +397,23 @@ pub struct Config {
pub path: PathBuf,
}
impl std::convert::TryFrom<sc_service::config::DatabaseConfig> for Config {
type Error = &'static str;
fn try_from(config: sc_service::config::DatabaseConfig) -> Result<Self, Self::Error> {
let path = config.path().ok_or("custom databases are not supported")?;
Ok(Self {
// substrate cache size is improper here; just use the default
cache_size: None,
// DB path is a sub-directory of substrate db path to give two properties:
// 1: column numbers don't conflict with substrate
// 2: commands like purge-chain work without further changes
path: path.join("parachains").join("av-store"),
})
}
}
impl AvailabilityStoreSubsystem {
/// Create a new `AvailabilityStoreSubsystem` with a given config on disk.
pub fn new_on_disk(config: Config, metrics: Metrics) -> io::Result<Self> {
@@ -449,7 +466,6 @@ async fn run<Context>(mut subsystem: AvailabilityStoreSubsystem, mut ctx: Contex
where
Context: SubsystemContext<Message=AvailabilityStoreMessage>,
{
let ctx = &mut ctx;
loop {
// Every time the following two methods are called a read from DB is performed.
// But given that these are very small values which are essentially a newtype
@@ -470,16 +486,19 @@ where
ActiveLeavesUpdate { activated, .. })
)) => {
for activated in activated.into_iter() {
process_block_activated(ctx, &subsystem.inner, activated).await?;
process_block_activated(&mut ctx, &subsystem.inner, activated).await?;
}
}
Ok(FromOverseer::Signal(OverseerSignal::BlockFinalized(hash))) => {
process_block_finalized(&subsystem, ctx, &subsystem.inner, hash).await?;
process_block_finalized(&subsystem, &mut ctx, &subsystem.inner, hash).await?;
}
Ok(FromOverseer::Communication { msg }) => {
process_message(&mut subsystem, ctx, msg).await?;
process_message(&mut subsystem, &mut ctx, msg).await?;
}
Err(_) => break,
Err(e) => {
log::error!("AvailabilityStoreSubsystem err: {:#?}", e);
break
},
}
}
pov_pruning_time = pov_pruning_time => {
@@ -945,15 +964,15 @@ fn query_inner<D: Decode>(db: &Arc<dyn KeyValueDB>, column: u32, key: &[u8]) ->
}
impl<Context> Subsystem<Context> for AvailabilityStoreSubsystem
where
Context: SubsystemContext<Message=AvailabilityStoreMessage>,
where
Context: SubsystemContext<Message = AvailabilityStoreMessage>,
{
fn start(self, ctx: Context) -> SpawnedSubsystem {
let future = Box::pin(async move {
if let Err(e) = run(self, ctx).await {
log::error!(target: LOG_TARGET, "Subsystem exited with an error {:?}", e);
}
});
let future = run(self, ctx)
.map(|r| if let Err(e) = r {
log::error!(target: "availabilitystore", "Subsystem exited with an error {:?}", e);
})
.boxed();
SpawnedSubsystem {
name: "availability-store-subsystem",
polkadot/node/core/candidate-selection/src/lib.rs
+4 -4
View File
@@ -420,10 +420,10 @@ impl metrics::Metrics for Metrics {
seconds: prometheus::register(
prometheus::CounterVec::new(
prometheus::Opts::new(
"candidate_selection_invalid_selections_total",
"Number of Candidate Selection subsystem seconding selections which proved to be invalid.",
"candidate_selection_seconds_total",
"Number of Candidate Selection subsystem seconding events.",
),
&["succeeded", "failed"],
&["success"],
)?,
registry,
)?,
@@ -433,7 +433,7 @@ impl metrics::Metrics for Metrics {
"candidate_selection_invalid_selections_total",
"Number of Candidate Selection subsystem seconding selections which proved to be invalid.",
),
&["succeeded", "failed"],
&["success"],
)?,
registry,
)?,
polkadot/node/core/candidate-validation/src/lib.rs
+2 -2
View File
@@ -82,7 +82,7 @@ impl Metrics {
metrics.validation_requests.with_label_values(&["invalid"]).inc();
},
Err(_) => {
metrics.validation_requests.with_label_values(&["failed"]).inc();
metrics.validation_requests.with_label_values(&["validation failure"]).inc();
},
}
}
@@ -98,7 +98,7 @@ impl metrics::Metrics for Metrics {
"parachain_validation_requests_total",
"Number of validation requests served.",
),
&["valid", "invalid", "failed"],
&["validity"],
)?,
registry,
)?,
polkadot/node/core/chain-api/src/lib.rs
+13 -7
View File
@@ -40,18 +40,19 @@ use polkadot_node_subsystem_util::{
};
use polkadot_primitives::v1::{Block, BlockId};
use sp_blockchain::HeaderBackend;
use std::sync::Arc;
use futures::prelude::*;
/// The Chain API Subsystem implementation.
pub struct ChainApiSubsystem<Client> {
client: Client,
client: Arc<Client>,
metrics: Metrics,
}
impl<Client> ChainApiSubsystem<Client> {
/// Create a new Chain API subsystem with the given client.
pub fn new(client: Client, metrics: Metrics) -> Self {
pub fn new(client: Arc<Client>, metrics: Metrics) -> Self {
ChainApiSubsystem {
client,
metrics,
@@ -126,8 +127,13 @@ where
// fewer than `k` ancestors are available
Ok(None) => None,
Ok(Some(header)) => {
hash = header.parent_hash;
Some(Ok(hash))
// stop at the genesis header.
if header.number == 1 {
None
} else {
hash = header.parent_hash;
Some(Ok(hash))
}
}
}
});
@@ -171,7 +177,7 @@ impl metrics::Metrics for Metrics {
"parachain_chain_api_requests_total",
"Number of Chain API requests served.",
),
&["succeeded", "failed"],
&["success"],
)?,
registry,
)?,
@@ -300,11 +306,11 @@ mod tests {
}
fn test_harness(
test: impl FnOnce(TestClient, TestSubsystemContextHandle<ChainApiMessage>)
test: impl FnOnce(Arc<TestClient>, TestSubsystemContextHandle<ChainApiMessage>)
-> BoxFuture<'static, ()>,
) {
let (ctx, ctx_handle) = make_subsystem_context(TaskExecutor::new());
let client = TestClient::default();
let client = Arc::new(TestClient::default());
let subsystem = ChainApiSubsystem::new(client.clone(), Metrics(None));
let chain_api_task = run(ctx, subsystem).map(|x| x.unwrap());
polkadot/node/core/proposer/src/lib.rs
+6 -5
View File
@@ -145,7 +145,7 @@ where
let (sender, receiver) = futures::channel::oneshot::channel();
overseer.wait_for_activation(parent_header_hash, sender).await?;
receiver.await.map_err(Error::ClosedChannelFromProvisioner)??;
receiver.await.map_err(|_| Error::ClosedChannelAwaitingActivation)??;
let (sender, receiver) = futures::channel::oneshot::channel();
// strictly speaking, we don't _have_ to .await this send_msg before opening the
@@ -156,7 +156,7 @@ where
ProvisionerMessage::RequestInherentData(parent_header_hash, sender),
)).await?;
receiver.await.map_err(Error::ClosedChannelFromProvisioner)
receiver.await.map_err(|_| Error::ClosedChannelAwaitingInherentData)
}
.boxed()
.fuse();
@@ -236,7 +236,8 @@ pub enum Error {
Blockchain(sp_blockchain::Error),
Inherent(sp_inherents::Error),
Timeout,
ClosedChannelFromProvisioner(futures::channel::oneshot::Canceled),
ClosedChannelAwaitingActivation,
ClosedChannelAwaitingInherentData,
Subsystem(SubsystemError)
}
@@ -271,7 +272,8 @@ impl fmt::Display for Error {
Self::Blockchain(err) => write!(f, "blockchain error: {}", err),
Self::Inherent(err) => write!(f, "inherent error: {:?}", err),
Self::Timeout => write!(f, "timeout: provisioner did not return inherent data after {:?}", PROPOSE_TIMEOUT),
Self::ClosedChannelFromProvisioner(err) => write!(f, "provisioner closed inherent data channel before sending: {}", err),
Self::ClosedChannelAwaitingActivation => write!(f, "closed channel from overseer when awaiting activation"),
Self::ClosedChannelAwaitingInherentData => write!(f, "closed channel from provisioner when awaiting inherent data"),
Self::Subsystem(err) => write!(f, "subsystem error: {:?}", err),
}
}
@@ -282,7 +284,6 @@ impl std::error::Error for Error {
match self {
Self::Consensus(err) => Some(err),
Self::Blockchain(err) => Some(err),
Self::ClosedChannelFromProvisioner(err) => Some(err),
Self::Subsystem(err) => Some(err),
_ => None
}
polkadot/node/core/provisioner/src/lib.rs
+2 -2
View File
@@ -482,7 +482,7 @@ impl Metrics {
fn on_inherent_data_request(&self, response: Result<(), ()>) {
if let Some(metrics) = &self.0 {
match response {
Ok(()) => metrics.inherent_data_requests.with_label_values(&["succeded"]).inc(),
Ok(()) => metrics.inherent_data_requests.with_label_values(&["succeeded"]).inc(),
Err(()) => metrics.inherent_data_requests.with_label_values(&["failed"]).inc(),
}
}
@@ -498,7 +498,7 @@ impl metrics::Metrics for Metrics {
"parachain_inherent_data_requests_total",
"Number of InherentData requests served by provisioner.",
),
&["succeeded", "failed"],
&["success"],
)?,
registry,
)?,
polkadot/node/core/runtime-api/src/lib.rs
+21 -16
View File
@@ -34,6 +34,7 @@ use polkadot_node_subsystem_util::{
metrics::{self, prometheus},
};
use polkadot_primitives::v1::{Block, BlockId, Hash, ParachainHost};
use std::sync::Arc;
use sp_api::{ProvideRuntimeApi};
@@ -41,19 +42,19 @@ use futures::prelude::*;
/// The `RuntimeApiSubsystem`. See module docs for more details.
pub struct RuntimeApiSubsystem<Client> {
client: Client,
client: Arc<Client>,
metrics: Metrics,
}
impl<Client> RuntimeApiSubsystem<Client> {
/// Create a new Runtime API subsystem wrapping the given client and metrics.
pub fn new(client: Client, metrics: Metrics) -> Self {
pub fn new(client: Arc<Client>, metrics: Metrics) -> Self {
RuntimeApiSubsystem { client, metrics }
}
}
impl<Client, Context> Subsystem<Context> for RuntimeApiSubsystem<Client> where
Client: ProvideRuntimeApi<Block> + Send + 'static,
Client: ProvideRuntimeApi<Block> + Send + 'static + Sync,
Client::Api: ParachainHost<Block>,
Context: SubsystemContext<Message = RuntimeApiMessage>
{
@@ -79,7 +80,7 @@ async fn run<Client>(
FromOverseer::Signal(OverseerSignal::BlockFinalized(_)) => {},
FromOverseer::Communication { msg } => match msg {
RuntimeApiMessage::Request(relay_parent, request) => make_runtime_api_request(
&subsystem.client,
&*subsystem.client,
&subsystem.metrics,
relay_parent,
request,
@@ -159,7 +160,7 @@ impl metrics::Metrics for Metrics {
"parachain_runtime_api_requests_total",
"Number of Runtime API requests served.",
),
&["succeeded", "failed"],
&["success"],
)?,
registry,
)?,
@@ -288,7 +289,7 @@ mod tests {
#[test]
fn requests_validators() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let runtime_api = MockRuntimeApi::default();
let runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
@@ -311,7 +312,7 @@ mod tests {
#[test]
fn requests_validator_groups() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let runtime_api = MockRuntimeApi::default();
let runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
@@ -334,7 +335,7 @@ mod tests {
#[test]
fn requests_availability_cores() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let runtime_api = MockRuntimeApi::default();
let runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
@@ -357,12 +358,12 @@ mod tests {
#[test]
fn requests_persisted_validation_data() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let mut runtime_api = MockRuntimeApi::default();
let mut runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let para_a = 5.into();
let para_b = 6.into();
runtime_api.validation_data.insert(para_a, Default::default());
Arc::get_mut(&mut runtime_api).unwrap().validation_data.insert(para_a, Default::default());
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
@@ -397,12 +398,12 @@ mod tests {
#[test]
fn requests_full_validation_data() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let mut runtime_api = MockRuntimeApi::default();
let mut runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let para_a = 5.into();
let para_b = 6.into();
runtime_api.validation_data.insert(para_a, Default::default());
Arc::get_mut(&mut runtime_api).unwrap().validation_data.insert(para_a, Default::default());
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
@@ -446,6 +447,8 @@ mod tests {
runtime_api.validation_outputs_results.insert(para_a, false);
runtime_api.validation_outputs_results.insert(para_b, true);
let runtime_api = Arc::new(runtime_api);
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
let test_task = async move {
@@ -491,7 +494,7 @@ mod tests {
#[test]
fn requests_session_index_for_child() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let runtime_api = MockRuntimeApi::default();
let runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
@@ -514,12 +517,12 @@ mod tests {
#[test]
fn requests_validation_code() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let mut runtime_api = MockRuntimeApi::default();
let mut runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let para_a = 5.into();
let para_b = 6.into();
runtime_api.validation_code.insert(para_a, Default::default());
Arc::get_mut(&mut runtime_api).unwrap().validation_code.insert(para_a, Default::default());
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
@@ -561,6 +564,8 @@ mod tests {
runtime_api.candidate_pending_availability.insert(para_a, Default::default());
let runtime_api = Arc::new(runtime_api);
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
let test_task = async move {
@@ -595,7 +600,7 @@ mod tests {
#[test]
fn requests_candidate_events() {
let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
let runtime_api = MockRuntimeApi::default();
let runtime_api = Arc::new(MockRuntimeApi::default());
let relay_parent = [1; 32].into();
let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
polkadot/node/network/availability-distribution/src/lib.rs
+1 -1
View File
@@ -796,7 +796,7 @@ impl AvailabilityDistributionSubsystem {
{
warn!(
target: TARGET,
"Failed to handle incomming network messages: {:?}", e
"Failed to handle incoming network messages: {:?}", e
);
}
}
polkadot/node/network/bitfield-distribution/src/lib.rs
+1 -1
View File
@@ -169,7 +169,7 @@ impl BitfieldDistribution {
trace!(target: TARGET, "Processing NetworkMessage");
// a network message was received
if let Err(e) = handle_network_msg(&mut ctx, &mut state, &self.metrics, event).await {
warn!(target: TARGET, "Failed to handle incomming network messages: {:?}", e);
warn!(target: TARGET, "Failed to handle incoming network messages: {:?}", e);
}
}
FromOverseer::Signal(OverseerSignal::ActiveLeaves(ActiveLeavesUpdate { activated, deactivated })) => {
polkadot/node/network/collator-protocol/src/collator_side.rs
+1 -1
View File
@@ -45,7 +45,7 @@ use polkadot_node_subsystem_util::{
};
#[derive(Clone, Default)]
pub(super) struct Metrics(Option<MetricsInner>);
pub struct Metrics(Option<MetricsInner>);
impl Metrics {
fn on_advertisment_made(&self) {
polkadot/node/network/collator-protocol/src/lib.rs
+7 -10
View File
@@ -37,7 +37,7 @@ use polkadot_node_network_protocol::{
use polkadot_primitives::v1::CollatorId;
use polkadot_node_subsystem_util::{
self as util,
metrics::{self, prometheus},
metrics::prometheus,
};
mod collator_side;
@@ -72,8 +72,11 @@ impl From<util::validator_discovery::Error> for Error {
type Result<T> = std::result::Result<T, Error>;
enum ProtocolSide {
/// What side of the collator protocol is being engaged
pub enum ProtocolSide {
/// Validators operate on the relay chain.
Validator(validator_side::Metrics),
/// Collators operate on a parachain.
Collator(CollatorId, collator_side::Metrics),
}
@@ -87,13 +90,7 @@ impl CollatorProtocolSubsystem {
/// If `id` is `Some` this is a collator side of the protocol.
/// If `id` is `None` this is a validator side of the protocol.
/// Caller must provide a registry for prometheus metrics.
pub fn new(id: Option<CollatorId>, registry: Option<&prometheus::Registry>) -> Self {
use metrics::Metrics;
let protocol_side = match id {
Some(id) => ProtocolSide::Collator(id, collator_side::Metrics::register(registry)),
None => ProtocolSide::Validator(validator_side::Metrics::register(registry)),
};
pub fn new(protocol_side: ProtocolSide) -> Self {
Self {
protocol_side,
}
@@ -127,7 +124,7 @@ where
fn start(self, ctx: Context) -> SpawnedSubsystem {
SpawnedSubsystem {
name: "collator-protocol-subsystem",
future: Box::pin(async move { self.run(ctx) }.map(|_| ())),
future: self.run(ctx).map(|_| ()).boxed(),
}
}
}
polkadot/node/network/collator-protocol/src/validator_side.rs
+2 -2
View File
@@ -52,7 +52,7 @@ const COST_REPORT_BAD: Rep = Rep::new(-50, "A collator was reported by another s
const BENEFIT_NOTIFY_GOOD: Rep = Rep::new(50, "A collator was noted good by another subsystem");
#[derive(Clone, Default)]
pub(super) struct Metrics(Option<MetricsInner>);
pub struct Metrics(Option<MetricsInner>);
impl Metrics {
fn on_request(&self, succeeded: std::result::Result<(), ()>) {
@@ -81,7 +81,7 @@ impl metrics::Metrics for Metrics {
"parachain_collation_requests_total",
"Number of collations requested from Collators.",
),
&["succeeded", "failed"],
&["success"],
)?,
registry,
)?
polkadot/node/network/statement-distribution/src/lib.rs
+9
View File
@@ -86,6 +86,15 @@ impl<C> Subsystem<C> for StatementDistribution
}
}
impl StatementDistribution {
/// Create a new Statement Distribution Subsystem
pub fn new(metrics: Metrics) -> StatementDistribution {
StatementDistribution {
metrics,
}
}
}
/// Tracks our impression of a single peer's view of the candidates a validator has seconded
/// for a given relay-parent.
///
polkadot/node/overseer/src/lib.rs
+1 -1
View File
@@ -1177,7 +1177,7 @@ where
let active_leaves = HashMap::new();
let metrics = <Metrics as metrics::Metrics>::register(prometheus_registry);
let metrics = <Metrics as metrics::Metrics>::register(prometheus_registry)?;
let activation_external_listeners = HashMap::new();
let this = Self {
polkadot/node/service/Cargo.toml
+41 -5
View File
@@ -15,7 +15,6 @@ sc-client-api = { git = "https://github.com/paritytech/substrate", branch = "mas
sc-client-db = { git = "https://github.com/paritytech/substrate", branch = "master" }
sc-consensus = { git = "https://github.com/paritytech/substrate", branch = "master" }
sc-executor = { git = "https://github.com/paritytech/substrate", branch = "master" }
sc-keystore = { git = "https://github.com/paritytech/substrate", branch = "master" }
sc-network = { git = "https://github.com/paritytech/substrate", branch = "master" }
sc-transaction-pool = { git = "https://github.com/paritytech/substrate", branch = "master" }
service = { package = "sc-service", git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
@@ -32,6 +31,7 @@ sp-block-builder = { git = "https://github.com/paritytech/substrate", branch = "
sp-blockchain = { git = "https://github.com/paritytech/substrate", branch = "master" }
sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
sp-io = { git = "https://github.com/paritytech/substrate", branch = "master" }
sp-keystore = { git = "https://github.com/paritytech/substrate", branch = "master" }
sp-offchain = { package = "sp-offchain", git = "https://github.com/paritytech/substrate", branch = "master" }
sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master" }
sp-session = { git = "https://github.com/paritytech/substrate", branch = "master" }
@@ -61,16 +61,36 @@ serde = { version = "1.0.102", features = ["derive"] }
slog = "2.5.2"
# Polkadot
kusama-runtime = { path = "../../runtime/kusama" }
polkadot-node-core-proposer = { path = "../core/proposer" }
polkadot-overseer = { path = "../overseer" }
polkadot-parachain = { path = "../../parachain" }
polkadot-primitives = { path = "../../primitives" }
polkadot-rpc = { path = "../../rpc" }
polkadot-runtime = { path = "../../runtime/polkadot" }
polkadot-subsystem = { package = "polkadot-node-subsystem", path = "../subsystem" }
rococo-runtime = { package = "rococo-v1-runtime", path = "../../runtime/rococo-v1" }
polkadot-node-subsystem-util = { path = "../subsystem-util" }
# Polkadot Runtimes
polkadot-runtime = { path = "../../runtime/polkadot" }
kusama-runtime = { path = "../../runtime/kusama" }
westend-runtime = { path = "../../runtime/westend" }
rococo-runtime = { package = "rococo-v1-runtime", path = "../../runtime/rococo-v1" }
# Polkadot Subsystems
polkadot-availability-bitfield-distribution = { path = "../network/bitfield-distribution", optional = true }
polkadot-availability-distribution = { path = "../network/availability-distribution", optional = true }
polkadot-collator-protocol = { path = "../network/collator-protocol", optional = true }
polkadot-network-bridge = { path = "../network/bridge", optional = true }
polkadot-node-collation-generation = { path = "../collation-generation", optional = true }
polkadot-node-core-av-store = { path = "../core/av-store", optional = true }
polkadot-node-core-backing = { path = "../core/backing", optional = true }
polkadot-node-core-bitfield-signing = { path = "../core/bitfield-signing", optional = true }
polkadot-node-core-candidate-selection = { path = "../core/candidate-selection", optional = true }
polkadot-node-core-candidate-validation = { path = "../core/candidate-validation", optional = true }
polkadot-node-core-chain-api = { path = "../core/chain-api", optional = true }
polkadot-node-core-provisioner = { path = "../core/provisioner", optional = true }
polkadot-node-core-runtime-api = { path = "../core/runtime-api", optional = true }
polkadot-pov-distribution = { path = "../network/pov-distribution", optional = true }
polkadot-statement-distribution = { path = "../network/statement-distribution", optional = true }
[dev-dependencies]
polkadot-test-client = { path = "../test/client" }
@@ -80,4 +100,20 @@ env_logger = "0.8.1"
default = ["db", "full-node"]
db = ["service/db"]
runtime-benchmarks = ["polkadot-runtime/runtime-benchmarks", "kusama-runtime/runtime-benchmarks", "westend-runtime/runtime-benchmarks"]
full-node = []
full-node = [
"polkadot-availability-bitfield-distribution",
"polkadot-availability-distribution",
"polkadot-collator-protocol",
"polkadot-network-bridge",
"polkadot-node-collation-generation",
"polkadot-node-core-av-store",
"polkadot-node-core-backing",
"polkadot-node-core-bitfield-signing",
"polkadot-node-core-candidate-selection",
"polkadot-node-core-candidate-validation",
"polkadot-node-core-chain-api",
"polkadot-node-core-provisioner",
"polkadot-node-core-runtime-api",
"polkadot-pov-distribution",
"polkadot-statement-distribution",
]
polkadot/node/service/src/chain_spec.rs
+2 -1
View File
@@ -134,13 +134,14 @@ fn westend_session_keys(
fn rococo_session_keys(
babe: BabeId,
_grandpa: GrandpaId,
grandpa: GrandpaId,
im_online: ImOnlineId,
parachain_validator: ValidatorId,
authority_discovery: AuthorityDiscoveryId
) -> rococo_runtime::SessionKeys {
rococo_runtime::SessionKeys {
babe,
grandpa,
im_online,
parachain_validator,
authority_discovery,
polkadot/node/service/src/grandpa_support.rs
+2
View File
@@ -16,6 +16,7 @@
//! Polkadot-specific GRANDPA integration utilities.
#[cfg(feature = "full-node")]
use polkadot_primitives::v1::Hash;
use sp_runtime::traits::{Block as BlockT, NumberFor};
@@ -94,6 +95,7 @@ where
/// intermediary pending changes are replaced with a static list comprised of
/// w3f validators and randomly selected validators from the latest session (at
/// #1500988).
#[cfg(feature = "full-node")]
pub(crate) fn kusama_hard_forks() -> Vec<(
grandpa_primitives::SetId,
(Hash, polkadot_primitives::v1::BlockNumber),
polkadot/node/service/src/lib.rs
+219 -87
View File
@@ -24,27 +24,34 @@ mod client;
use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
#[cfg(feature = "full-node")]
use log::info;
use polkadot_node_core_proposer::ProposerFactory;
use polkadot_overseer::{AllSubsystems, BlockInfo, Overseer, OverseerHandler};
use polkadot_subsystem::DummySubsystem;
use prometheus_endpoint::Registry;
use sc_client_api::ExecutorProvider;
use sc_executor::native_executor_instance;
use service::{error::Error as ServiceError, RpcHandlers};
use sp_blockchain::HeaderBackend;
use sp_core::traits::SpawnNamed;
use sp_trie::PrefixedMemoryDB;
use {
std::convert::TryInto,
std::time::Duration,
log::info,
polkadot_node_core_av_store::Config as AvailabilityConfig,
polkadot_node_core_proposer::ProposerFactory,
polkadot_overseer::{AllSubsystems, BlockInfo, Overseer, OverseerHandler},
polkadot_primitives::v1::ParachainHost,
authority_discovery::Service as AuthorityDiscoveryService,
sp_blockchain::HeaderBackend,
sp_core::traits::SpawnNamed,
sp_keystore::SyncCryptoStorePtr,
sp_trie::PrefixedMemoryDB,
sc_client_api::ExecutorProvider,
};
use std::sync::Arc;
use std::time::Duration;
use prometheus_endpoint::Registry;
use sc_executor::native_executor_instance;
use service::RpcHandlers;
pub use self::client::{AbstractClient, Client, ClientHandle, ExecuteWithClient, RuntimeApiCollection};
pub use chain_spec::{PolkadotChainSpec, KusamaChainSpec, WestendChainSpec, RococoChainSpec};
#[cfg(feature = "full-node")]
pub use codec::Codec;
pub use consensus_common::{Proposal, SelectChain, BlockImport, RecordProof, block_validation::Chain};
pub use polkadot_parachain::wasm_executor::run_worker as run_validation_worker;
pub use polkadot_primitives::v1::{Block, BlockId, CollatorId, Id as ParaId};
pub use polkadot_primitives::v1::{Block, BlockId, CollatorId, Hash, Id as ParaId};
pub use sc_client_api::{Backend, ExecutionStrategy, CallExecutor};
pub use sc_consensus::LongestChain;
pub use sc_executor::NativeExecutionDispatch;
@@ -115,7 +122,7 @@ impl IdentifyVariant for Box<dyn ChainSpec> {
}
// If we're using prometheus, use a registry with a prefix of `polkadot`.
fn set_prometheus_registry(config: &mut Configuration) -> Result<(), ServiceError> {
fn set_prometheus_registry(config: &mut Configuration) -> Result<(), Error> {
if let Some(PrometheusConfig { registry, .. }) = config.prometheus_config.as_mut() {
*registry = Registry::new_custom(Some("polkadot".into()), None)?;
}
@@ -124,8 +131,10 @@ fn set_prometheus_registry(config: &mut Configuration) -> Result<(), ServiceErro
}
pub type FullBackend = service::TFullBackend<Block>;
#[cfg(feature = "full-node")]
type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
pub type FullClient<RuntimeApi, Executor> = service::TFullClient<Block, RuntimeApi, Executor>;
#[cfg(feature = "full-node")]
type FullGrandpaBlockImport<RuntimeApi, Executor> = grandpa::GrandpaBlockImport<
FullBackend, Block, FullClient<RuntimeApi, Executor>, FullSelectChain
>;
@@ -276,42 +285,115 @@ fn new_partial<RuntimeApi, Executor>(config: &mut Configuration) -> Result<
})
}
fn real_overseer<S: SpawnNamed>(
#[cfg(feature="full-node")]
fn real_overseer<Spawner, RuntimeClient>(
leaves: impl IntoIterator<Item = BlockInfo>,
prometheus_registry: Option<&Registry>,
s: S,
) -> Result<(Overseer<S>, OverseerHandler), ServiceError> {
keystore: SyncCryptoStorePtr,
runtime_client: Arc<RuntimeClient>,
availability_config: AvailabilityConfig,
network_service: Arc<sc_network::NetworkService<Block, Hash>>,
authority_discovery: AuthorityDiscoveryService,
registry: Option<&Registry>,
spawner: Spawner,
) -> Result<(Overseer<Spawner>, OverseerHandler), Error>
where
RuntimeClient: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
RuntimeClient::Api: ParachainHost<Block>,
Spawner: 'static + SpawnNamed + Clone + Unpin,
{
use polkadot_node_subsystem_util::metrics::Metrics;
use polkadot_availability_distribution::AvailabilityDistributionSubsystem;
use polkadot_node_core_av_store::AvailabilityStoreSubsystem;
use polkadot_availability_bitfield_distribution::BitfieldDistribution as BitfieldDistributionSubsystem;
use polkadot_node_core_bitfield_signing::BitfieldSigningSubsystem;
use polkadot_node_core_backing::CandidateBackingSubsystem;
use polkadot_node_core_candidate_selection::CandidateSelectionSubsystem;
use polkadot_node_core_candidate_validation::CandidateValidationSubsystem;
use polkadot_node_core_chain_api::ChainApiSubsystem;
use polkadot_node_collation_generation::CollationGenerationSubsystem;
use polkadot_collator_protocol::{CollatorProtocolSubsystem, ProtocolSide};
use polkadot_network_bridge::NetworkBridge as NetworkBridgeSubsystem;
use polkadot_pov_distribution::PoVDistribution as PoVDistributionSubsystem;
use polkadot_node_core_provisioner::ProvisioningSubsystem as ProvisionerSubsystem;
use polkadot_node_core_runtime_api::RuntimeApiSubsystem;
use polkadot_statement_distribution::StatementDistribution as StatementDistributionSubsystem;
let all_subsystems = AllSubsystems {
candidate_validation: DummySubsystem,
candidate_backing: DummySubsystem,
candidate_selection: DummySubsystem,
statement_distribution: DummySubsystem,
availability_distribution: DummySubsystem,
bitfield_signing: DummySubsystem,
bitfield_distribution: DummySubsystem,
provisioner: DummySubsystem,
pov_distribution: DummySubsystem,
runtime_api: DummySubsystem,
availability_store: DummySubsystem,
network_bridge: DummySubsystem,
chain_api: DummySubsystem,
collation_generation: DummySubsystem,
collator_protocol: DummySubsystem,
availability_distribution: AvailabilityDistributionSubsystem::new(
keystore.clone(),
Metrics::register(registry)?,
),
availability_store: AvailabilityStoreSubsystem::new_on_disk(
availability_config,
Metrics::register(registry)?,
)?,
bitfield_distribution: BitfieldDistributionSubsystem::new(
Metrics::register(registry)?,
),
bitfield_signing: BitfieldSigningSubsystem::new(
spawner.clone(),
keystore.clone(),
Metrics::register(registry)?,
),
candidate_backing: CandidateBackingSubsystem::new(
spawner.clone(),
keystore.clone(),
Metrics::register(registry)?,
),
candidate_selection: CandidateSelectionSubsystem::new(
spawner.clone(),
(),
Metrics::register(registry)?,
),
candidate_validation: CandidateValidationSubsystem::new(
spawner.clone(),
Metrics::register(registry)?,
),
chain_api: ChainApiSubsystem::new(
runtime_client.clone(),
Metrics::register(registry)?,
),
collation_generation: CollationGenerationSubsystem::new(
Metrics::register(registry)?,
),
collator_protocol: CollatorProtocolSubsystem::new(
ProtocolSide::Validator(Metrics::register(registry)?),
),
network_bridge: NetworkBridgeSubsystem::new(
network_service,
authority_discovery,
),
pov_distribution: PoVDistributionSubsystem::new(
Metrics::register(registry)?,
),
provisioner: ProvisionerSubsystem::new(
spawner.clone(),
(),
Metrics::register(registry)?,
),
runtime_api: RuntimeApiSubsystem::new(
runtime_client,
Metrics::register(registry)?,
),
statement_distribution: StatementDistributionSubsystem::new(
Metrics::register(registry)?,
),
};
Overseer::new(
leaves,
all_subsystems,
prometheus_registry,
s,
).map_err(|e| ServiceError::Other(format!("Failed to create an Overseer: {:?}", e)))
registry,
spawner,
).map_err(|e| Error::Other(format!("Failed to create an Overseer: {:?}", e)))
}
#[cfg(feature = "full-node")]
pub struct NewFull<C> {
pub task_manager: TaskManager,
pub client: C,
pub overseer_handler: OverseerHandler,
pub overseer_handler: Option<OverseerHandler>,
pub network: Arc<sc_network::NetworkService<Block, <Block as BlockT>::Hash>>,
pub network_status_sinks: service::NetworkStatusSinks<Block>,
pub rpc_handlers: RpcHandlers,
@@ -334,6 +416,24 @@ impl<C> NewFull<C> {
}
}
/// Is this node a collator?
#[cfg(feature = "full-node")]
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum IsCollator {
/// This node is a collator.
Yes,
/// This node is not a collator.
No,
}
#[cfg(feature = "full-node")]
impl IsCollator {
/// Is this a collator?
fn is_collator(&self) -> bool {
*self == Self::Yes
}
}
/// Create a new full node of arbitrary runtime and executor.
///
/// This is an advanced feature and not recommended for general use. Generally, `build_full` is
@@ -342,6 +442,7 @@ impl<C> NewFull<C> {
pub fn new_full<RuntimeApi, Executor>(
mut config: Configuration,
authority_discovery_disabled: bool,
is_collator: IsCollator,
grandpa_pause: Option<(u32, u32)>,
) -> Result<NewFull<Arc<FullClient<RuntimeApi, Executor>>>, Error>
where
@@ -392,6 +493,8 @@ pub fn new_full<RuntimeApi, Executor>(
let telemetry_connection_sinks = service::TelemetryConnectionSinks::default();
let availability_config = config.database.clone().try_into();
let rpc_handlers = service::spawn_tasks(service::SpawnTasksParams {
config,
backend: backend.clone(),
@@ -428,28 +531,76 @@ pub fn new_full<RuntimeApi, Executor>(
})
.collect();
let (overseer, overseer_handler) = real_overseer(leaves, prometheus_registry.as_ref(), spawner)?;
let overseer_handler_clone = overseer_handler.clone();
let authority_discovery_service = if role.is_authority() || is_collator.is_collator() {
use sc_network::Event;
use futures::StreamExt;
task_manager.spawn_essential_handle().spawn_blocking("overseer", Box::pin(async move {
use futures::{pin_mut, select, FutureExt};
let forward = polkadot_overseer::forward_events(overseer_client, overseer_handler_clone);
let forward = forward.fuse();
let overseer_fut = overseer.run().fuse();
pin_mut!(overseer_fut);
pin_mut!(forward);
loop {
select! {
_ = forward => break,
_ = overseer_fut => break,
complete => break,
}
if authority_discovery_disabled {
Err("Authority discovery is mandatory for a validator.")?;
}
}));
let authority_discovery_role = if role.is_authority() {
authority_discovery::Role::PublishAndDiscover(
keystore_container.keystore(),
)
} else {
// don't publish our addresses when we're only a collator
authority_discovery::Role::Discover
};
let dht_event_stream = network.event_stream("authority-discovery")
.filter_map(|e| async move { match e {
Event::Dht(e) => Some(e),
_ => None,
}});
let (worker, service) = authority_discovery::new_worker_and_service(
client.clone(),
network.clone(),
Box::pin(dht_event_stream),
authority_discovery_role,
prometheus_registry.clone(),
);
task_manager.spawn_handle().spawn("authority-discovery-worker", worker.run());
Some(service)
} else {
None
};
// we'd say let overseer_handler = authority_discovery_service.map(|authority_discovery_service|, ...),
// but in that case we couldn't use ? to propagate errors
let overseer_handler = if let Some(authority_discovery_service) = authority_discovery_service {
let (overseer, overseer_handler) = real_overseer(
leaves,
keystore_container.sync_keystore(),
overseer_client.clone(),
availability_config?,
network.clone(),
authority_discovery_service,
prometheus_registry.as_ref(),
spawner,
)?;
let overseer_handler_clone = overseer_handler.clone();
task_manager.spawn_essential_handle().spawn_blocking("overseer", Box::pin(async move {
use futures::{pin_mut, select, FutureExt};
let forward = polkadot_overseer::forward_events(overseer_client, overseer_handler_clone);
let forward = forward.fuse();
let overseer_fut = overseer.run().fuse();
pin_mut!(overseer_fut);
pin_mut!(forward);
select! {
_ = forward => (),
_ = overseer_fut => (),
complete => (),
}
}));
Some(overseer_handler)
} else { None };
if role.is_authority() {
let can_author_with =
@@ -459,7 +610,7 @@ pub fn new_full<RuntimeApi, Executor>(
task_manager.spawn_handle(),
client.clone(),
transaction_pool,
overseer_handler.clone(),
overseer_handler.as_ref().ok_or("authorities require real overseer handlers")?.clone(),
prometheus_registry.as_ref(),
);
@@ -542,30 +693,6 @@ pub fn new_full<RuntimeApi, Executor>(
grandpa::setup_disabled_grandpa(network.clone())?;
}
if role.is_authority() && !authority_discovery_disabled {
use sc_network::Event;
use futures::StreamExt;
let authority_discovery_role = authority_discovery::Role::PublishAndDiscover(
keystore_container.keystore(),
);
let dht_event_stream = network.event_stream("authority-discovery")
.filter_map(|e| async move { match e {
Event::Dht(e) => Some(e),
_ => None,
}});
let (authority_discovery_worker, _service) = authority_discovery::new_worker_and_service(
client.clone(),
network.clone(),
Box::pin(dht_event_stream),
authority_discovery_role,
prometheus_registry.clone(),
);
task_manager.spawn_handle().spawn("authority-discovery-worker", authority_discovery_worker.run());
}
network_starter.start_network();
Ok(NewFull {
@@ -701,7 +828,7 @@ pub fn new_chain_ops(mut config: &mut Configuration) -> Result<
consensus_common::import_queue::BasicQueue<Block, PrefixedMemoryDB<BlakeTwo256>>,
TaskManager,
),
ServiceError
Error
>
{
config.keystore = service::config::KeystoreConfig::InMemory;
@@ -725,7 +852,7 @@ pub fn new_chain_ops(mut config: &mut Configuration) -> Result<
}
/// Build a new light node.
pub fn build_light(config: Configuration) -> Result<(TaskManager, RpcHandlers), ServiceError> {
pub fn build_light(config: Configuration) -> Result<(TaskManager, RpcHandlers), Error> {
if config.chain_spec.is_rococo() {
new_light::<rococo_runtime::RuntimeApi, RococoExecutor>(config)
} else if config.chain_spec.is_kusama() {
@@ -741,30 +868,35 @@ pub fn build_light(config: Configuration) -> Result<(TaskManager, RpcHandlers),
pub fn build_full(
config: Configuration,
authority_discovery_disabled: bool,
is_collator: IsCollator,
grandpa_pause: Option<(u32, u32)>,
) -> Result<NewFull<Client>, ServiceError> {
) -> Result<NewFull<Client>, Error> {
if config.chain_spec.is_rococo() {
new_full::<rococo_runtime::RuntimeApi, RococoExecutor>(
config,
authority_discovery_disabled,
is_collator,
grandpa_pause,
).map(|full| full.with_client(Client::Rococo))
} else if config.chain_spec.is_kusama() {
new_full::<kusama_runtime::RuntimeApi, KusamaExecutor>(
config,
authority_discovery_disabled,
is_collator,
grandpa_pause,
).map(|full| full.with_client(Client::Kusama))
} else if config.chain_spec.is_westend() {
new_full::<westend_runtime::RuntimeApi, WestendExecutor>(
config,
authority_discovery_disabled,
is_collator,
grandpa_pause,
).map(|full| full.with_client(Client::Westend))
} else {
new_full::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(
config,
authority_discovery_disabled,
is_collator,
grandpa_pause,
).map(|full| full.with_client(Client::Polkadot))
}
polkadot/node/subsystem-util/src/lib.rs
+9 -12
View File
@@ -470,18 +470,15 @@ pub mod metrics {
/// Try to register metrics in the Prometheus registry.
fn try_register(registry: &prometheus::Registry) -> Result<Self, prometheus::PrometheusError>;
/// Convience method to register metrics in the optional Prometheus registry.
/// If the registration fails, prints a warning and returns `Default::default()`.
fn register(registry: Option<&prometheus::Registry>) -> Self {
registry.map(|r| {
match Self::try_register(r) {
Err(e) => {
log::warn!("Failed to register metrics: {:?}", e);
Default::default()
},
Ok(metrics) => metrics,
}
}).unwrap_or_default()
/// Convenience method to register metrics in the optional Promethius registry.
///
/// If no registry is provided, returns `Default::default()`. Otherwise, returns the same
/// thing that `try_register` does.
fn register(registry: Option<&prometheus::Registry>) -> Result<Self, prometheus::PrometheusError> {
match registry {
None => Ok(Self::default()),
Some(registry) => Self::try_register(registry),
}
}
}
polkadot/node/subsystem/Cargo.toml
+1
View File
@@ -21,6 +21,7 @@ polkadot-statement-table = { path = "../../statement-table" }
sc-network = { git = "https://github.com/paritytech/substrate", branch = "master" }
smallvec = "1.4.1"
sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
substrate-prometheus-endpoint = { git = "https://github.com/paritytech/substrate", branch = "master" }
thiserror = "1.0.21"
[dev-dependencies]
polkadot/node/subsystem/src/lib.rs
+4
View File
@@ -132,6 +132,10 @@ pub enum SubsystemError {
#[error(transparent)]
Infallible(#[from] std::convert::Infallible),
/// Prometheus had a problem
#[error(transparent)]
Prometheus(#[from] substrate_prometheus_endpoint::PrometheusError),
/// An other error lacking particular type information.
#[error("Failed to {0}")]
Context(String),
polkadot/node/test/service/src/lib.rs
+4 -2
View File
@@ -26,7 +26,7 @@ use polkadot_overseer::OverseerHandler;
use polkadot_primitives::v1::{Id as ParaId, HeadData, ValidationCode, Balance};
use polkadot_runtime_common::BlockHashCount;
use polkadot_service::{
new_full, NewFull, FullClient, ClientHandle, ExecuteWithClient,
new_full, NewFull, FullClient, ClientHandle, ExecuteWithClient, IsCollator,
};
use polkadot_test_runtime::{Runtime, SignedExtra, SignedPayload, VERSION, ParasSudoWrapperCall, UncheckedExtrinsic};
use polkadot_runtime_parachains::paras::ParaGenesisArgs;
@@ -76,6 +76,7 @@ pub fn polkadot_test_new_full(
new_full::<polkadot_test_runtime::RuntimeApi, PolkadotTestExecutor>(
config,
authority_discovery_disabled,
IsCollator::No,
None,
).map_err(Into::into)
}
@@ -204,11 +205,12 @@ pub fn run_test_node(
) -> PolkadotTestNode {
let config = node_config(storage_update_func, task_executor, key, boot_nodes);
let multiaddr = config.network.listen_addresses[0].clone();
let authority_discovery_disabled = true;
let authority_discovery_disabled = false;
let NewFull {task_manager, client, network, rpc_handlers, overseer_handler, ..} =
polkadot_test_new_full(config, authority_discovery_disabled)
.expect("could not create Polkadot test service");
let overseer_handler = overseer_handler.expect("test node must have an overseer handler");
let peer_id = network.local_peer_id().clone();
let addr = MultiaddrWithPeerId { multiaddr, peer_id };
polkadot/runtime/rococo-v1/src/lib.rs
+2 -1
View File
@@ -347,6 +347,7 @@ pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
impl_opaque_keys! {
pub struct SessionKeys {
pub grandpa: Grandpa,
pub babe: Babe,
pub im_online: ImOnline,
pub parachain_validator: Initializer,
@@ -384,7 +385,7 @@ construct_runtime! {
ParachainOrigin: parachains_origin::{Module, Origin},
Config: parachains_configuration::{Module, Call, Storage},
Inclusion: parachains_inclusion::{Module, Call, Storage, Event<T>},
InclusionInherent: parachains_inclusion_inherent::{Module, Call, Storage},
InclusionInherent: parachains_inclusion_inherent::{Module, Call, Storage, Inherent},
Scheduler: parachains_scheduler::{Module, Call, Storage},
Paras: parachains_paras::{Module, Call, Storage},
Initializer: parachains_initializer::{Module, Call, Storage},
polkadot/scripts/two-node-local-net.sh
+5 -1
View File
@@ -6,6 +6,10 @@
set -e
# chainspec defaults to polkadot-local if no arguments are passed to this script;
# if arguments are passed in, the first is the chainspec
chainspec="${1:-polkadot-local}"
PROJECT_ROOT=$(git rev-parse --show-toplevel)
# shellcheck disable=SC1090
source "$(dirname "$0")"/common.sh
@@ -70,7 +74,7 @@ function run_node() {
# start the node
"$polkadot" \
--chain polkadot-local \
--chain "$chainspec" \
--tmp \
--port "$port" \
--rpc-port "$rpc_port" \
polkadot/tests/purge_chain_works.rs
+5 -2
View File
@@ -35,8 +35,11 @@ fn purge_chain_works() {
.unwrap();
// Let it produce some blocks.
thread::sleep(Duration::from_secs(30));
assert!(cmd.try_wait().unwrap().is_none(), "the process should still be running");
// poll once per second for faster failure
for _ in 0..30 {
thread::sleep(Duration::from_secs(1));
assert!(cmd.try_wait().unwrap().is_none(), "the process should still be running");
}
// Stop the process
kill(Pid::from_raw(cmd.id().try_into().unwrap()), SIGINT).unwrap();