From f98f5c7885487120e90057c9f77291b6af85225f Mon Sep 17 00:00:00 2001 From: Bernhard Schuster Date: Mon, 20 Sep 2021 14:05:50 +0200 Subject: [PATCH] Revert "remove connected disconnected state only (#3868)" This reverts commit 7bc352628e65ec99f3393503a28c8a0c8e4202bd. --- Cargo.lock | 1 - doc/testing.md | 3 +- node/malus/src/variant-a.rs | 5 +- node/overseer/examples/minimal-example.rs | 14 +- .../proc-macro/src/impl_builder.rs | 2 +- node/overseer/src/dummy.rs | 54 ---- node/overseer/src/lib.rs | 87 ++++-- node/overseer/src/metrics.rs | 4 +- node/overseer/src/subsystems.rs | 42 ++- node/overseer/src/tests.rs | 74 ++--- node/service/Cargo.toml | 1 - node/service/src/lib.rs | 274 +++++++----------- node/service/src/overseer.rs | 196 +------------ node/service/src/relay_chain_selection.rs | 79 ++--- node/service/src/tests.rs | 2 +- node/subsystem-test-helpers/src/lib.rs | 7 +- node/subsystem/src/lib.rs | 4 +- 17 files changed, 302 insertions(+), 547 deletions(-) delete mode 100644 node/overseer/src/dummy.rs diff --git a/Cargo.lock b/Cargo.lock index e70b8e44a447..c46974710b2d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6842,7 +6842,6 @@ dependencies = [ "kvdb", "kvdb-rocksdb", "log", - "lru", "pallet-babe", "pallet-im-online", "pallet-mmr-primitives", diff --git a/doc/testing.md b/doc/testing.md index 6709d1b9bdeb..8230ea352c0f 100644 --- a/doc/testing.md +++ b/doc/testing.md @@ -185,7 +185,6 @@ struct BehaveMaleficient; impl OverseerGen for BehaveMaleficient { fn generate<'a, Spawner, RuntimeClient>( &self, - connector: OverseerConnector, args: OverseerGenArgs<'a, Spawner, RuntimeClient>, ) -> Result<(Overseer>, OverseerHandler), Error> where @@ -214,7 +213,7 @@ impl OverseerGen for BehaveMaleficient { ), ); - Overseer::new(leaves, all_subsystems, registry, runtime_client, spawner, connector) + Overseer::new(leaves, all_subsystems, registry, runtime_client, spawner) .map_err(|e| e.into()) // A builder pattern will simplify this further diff --git a/node/malus/src/variant-a.rs b/node/malus/src/variant-a.rs index 8abdf75198b3..a545bd360faf 100644 --- a/node/malus/src/variant-a.rs +++ b/node/malus/src/variant-a.rs @@ -37,7 +37,7 @@ use polkadot_cli::{ use polkadot_node_core_candidate_validation::CandidateValidationSubsystem; use polkadot_node_subsystem::{ messages::{AllMessages, CandidateValidationMessage}, - overseer::{self, OverseerConnector, OverseerHandle}, + overseer::{self, OverseerHandle}, FromOverseer, }; @@ -86,7 +86,6 @@ struct BehaveMaleficient; impl OverseerGen for BehaveMaleficient { fn generate<'a, Spawner, RuntimeClient>( &self, - connector: OverseerConnector, args: OverseerGenArgs<'a, Spawner, RuntimeClient>, ) -> Result<(Overseer>, OverseerHandle), Error> where @@ -114,7 +113,7 @@ impl OverseerGen for BehaveMaleficient { }, ); - Overseer::new(leaves, all_subsystems, registry, runtime_client, spawner, connector) + Overseer::new(leaves, all_subsystems, registry, runtime_client, spawner) .map_err(|e| e.into()) } } diff --git a/node/overseer/examples/minimal-example.rs b/node/overseer/examples/minimal-example.rs index 0c4a3bdc6ae6..6970054a3013 100644 --- a/node/overseer/examples/minimal-example.rs +++ b/node/overseer/examples/minimal-example.rs @@ -29,8 +29,7 @@ use polkadot_node_subsystem_types::messages::{ use polkadot_overseer::{ self as overseer, gen::{FromOverseer, SpawnedSubsystem}, - AllMessages, AllSubsystems, HeadSupportsParachains, Overseer, OverseerConnector, - OverseerSignal, SubsystemError, + AllMessages, AllSubsystems, HeadSupportsParachains, Overseer, OverseerSignal, SubsystemError, }; use polkadot_primitives::v1::Hash; @@ -174,15 +173,8 @@ fn main() { .replace_candidate_validation(|_| Subsystem2) .replace_candidate_backing(|orig| orig); - let (overseer, _handle) = Overseer::new( - vec![], - all_subsystems, - None, - AlwaysSupportsParachains, - spawner, - OverseerConnector::default(), - ) - .unwrap(); + let (overseer, _handle) = + Overseer::new(vec![], all_subsystems, None, AlwaysSupportsParachains, spawner).unwrap(); let overseer_fut = overseer.run().fuse(); let timer_stream = timer_stream; diff --git a/node/overseer/overseer-gen/proc-macro/src/impl_builder.rs b/node/overseer/overseer-gen/proc-macro/src/impl_builder.rs index b736de97d463..832e193fd4d1 100644 --- a/node/overseer/overseer-gen/proc-macro/src/impl_builder.rs +++ b/node/overseer/overseer-gen/proc-macro/src/impl_builder.rs @@ -130,7 +130,7 @@ pub(crate) fn impl_builder(info: &OverseerInfo) -> proc_macro2::TokenStream { &mut self.handle } /// Obtain access to the overseer handle. - pub fn as_handle(&self) -> &#handle { + pub fn as_handle(&mut self) -> &#handle { &self.handle } } diff --git a/node/overseer/src/dummy.rs b/node/overseer/src/dummy.rs deleted file mode 100644 index c3d3d4fcf3c8..000000000000 --- a/node/overseer/src/dummy.rs +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright 2020 Parity Technologies (UK) Ltd. -// This file is part of Polkadot. - -// Polkadot 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. - -// Polkadot 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 Polkadot. If not, see . - -use crate::{AllMessages, OverseerSignal}; -use polkadot_node_subsystem_types::errors::SubsystemError; -use polkadot_overseer_gen::{FromOverseer, SpawnedSubsystem, Subsystem, SubsystemContext}; - -/// A dummy subsystem that implements [`Subsystem`] for all -/// types of messages. Used for tests or as a placeholder. -#[derive(Clone, Copy, Debug)] -pub struct DummySubsystem; - -impl Subsystem for DummySubsystem -where - Context: SubsystemContext< - Signal = OverseerSignal, - Error = SubsystemError, - AllMessages = AllMessages, - >, -{ - fn start(self, mut ctx: Context) -> SpawnedSubsystem { - let future = Box::pin(async move { - loop { - match ctx.recv().await { - Err(_) => return Ok(()), - Ok(FromOverseer::Signal(OverseerSignal::Conclude)) => return Ok(()), - Ok(overseer_msg) => { - tracing::debug!( - target: "dummy-subsystem", - "Discarding a message sent from overseer {:?}", - overseer_msg - ); - continue - }, - } - } - }); - - SpawnedSubsystem { name: "dummy-subsystem", future } - } -} diff --git a/node/overseer/src/lib.rs b/node/overseer/src/lib.rs index c226f2dfa0c1..2fb9ffd359b2 100644 --- a/node/overseer/src/lib.rs +++ b/node/overseer/src/lib.rs @@ -70,6 +70,7 @@ use std::{ use futures::{channel::oneshot, future::BoxFuture, select, Future, FutureExt, StreamExt}; use lru::LruCache; +use parking_lot::RwLock; use client::{BlockImportNotification, BlockchainEvents, FinalityNotification}; use polkadot_primitives::v1::{Block, BlockId, BlockNumber, Hash, ParachainHost}; @@ -90,17 +91,12 @@ pub use polkadot_node_subsystem_types::{ jaeger, ActivatedLeaf, ActiveLeavesUpdate, LeafStatus, OverseerSignal, }; -/// Test helper supplements. -pub mod dummy; -pub use self::dummy::DummySubsystem; - // TODO legacy, to be deleted, left for easier integration // TODO https://github.com/paritytech/polkadot/issues/3427 mod subsystems; -pub use self::subsystems::AllSubsystems; +pub use self::subsystems::{AllSubsystems, DummySubsystem}; -/// Metrics re-exports of `polkadot-metrics`. -pub mod metrics; +mod metrics; use self::metrics::Metrics; use polkadot_node_metrics::{ @@ -119,7 +115,7 @@ pub use polkadot_overseer_gen::{ /// Store 2 days worth of blocks, not accounting for forks, /// in the LRU cache. Assumes a 6-second block time. -pub const KNOWN_LEAVES_CACHE_SIZE: usize = 2 * 24 * 3600 / 6; +const KNOWN_LEAVES_CACHE_SIZE: usize = 2 * 24 * 3600 / 6; #[cfg(test)] mod tests; @@ -145,12 +141,18 @@ where /// /// [`Overseer`]: struct.Overseer.html #[derive(Clone)] -pub struct Handle(pub OverseerHandle); +pub enum Handle { + /// Used only at initialization to break the cyclic dependency. + // TODO: refactor in https://github.com/paritytech/polkadot/issues/3427 + Disconnected(Arc>>), + /// A handle to the overseer. + Connected(OverseerHandle), +} impl Handle { - /// Create a new [`Handle`]. - pub fn new(raw: OverseerHandle) -> Self { - Self(raw) + /// Create a new disconnected [`Handle`]. + pub fn new_disconnected() -> Self { + Self::Disconnected(Arc::new(RwLock::new(None))) } /// Inform the `Overseer` that that some block was imported. @@ -199,8 +201,58 @@ impl Handle { /// Most basic operation, to stop a server. async fn send_and_log_error(&mut self, event: Event) { - if self.0.send(event).await.is_err() { - tracing::info!(target: LOG_TARGET, "Failed to send an event to Overseer"); + self.try_connect(); + if let Self::Connected(ref mut handle) = self { + if handle.send(event).await.is_err() { + tracing::info!(target: LOG_TARGET, "Failed to send an event to Overseer"); + } + } else { + tracing::warn!(target: LOG_TARGET, "Using a disconnected Handle to send to Overseer"); + } + } + + /// Whether the handle is disconnected. + pub fn is_disconnected(&self) -> bool { + match self { + Self::Disconnected(ref x) => x.read().is_none(), + _ => false, + } + } + + /// Connect this handle and all disconnected clones of it to the overseer. + pub fn connect_to_overseer(&mut self, handle: OverseerHandle) { + match self { + Self::Disconnected(ref mut x) => { + let mut maybe_handle = x.write(); + if maybe_handle.is_none() { + tracing::info!(target: LOG_TARGET, "🖇️ Connecting all Handles to Overseer"); + *maybe_handle = Some(handle); + } else { + tracing::warn!( + target: LOG_TARGET, + "Attempting to connect a clone of a connected Handle", + ); + } + }, + _ => { + tracing::warn!( + target: LOG_TARGET, + "Attempting to connect an already connected Handle", + ); + }, + } + } + + /// Try upgrading from `Self::Disconnected` to `Self::Connected` state + /// after calling `connect_to_overseer` on `self` or a clone of `self`. + fn try_connect(&mut self) { + if let Self::Disconnected(ref mut x) = self { + let guard = x.write(); + if let Some(ref h) = *guard { + let handle = h.clone(); + drop(guard); + *self = Self::Connected(handle); + } } } } @@ -438,13 +490,12 @@ where /// # use polkadot_primitives::v1::Hash; /// # use polkadot_overseer::{ /// # self as overseer, - /// # Overseer, /// # OverseerSignal, - /// # OverseerConnector, /// # SubsystemSender as _, /// # AllMessages, /// # AllSubsystems, /// # HeadSupportsParachains, + /// # Overseer, /// # SubsystemError, /// # gen::{ /// # SubsystemContext, @@ -498,7 +549,6 @@ where /// None, /// AlwaysSupportsParachains, /// spawner, - /// OverseerConnector::default(), /// ).unwrap(); /// /// let timer = Delay::new(Duration::from_millis(50)).fuse(); @@ -565,7 +615,6 @@ where prometheus_registry: Option<&prometheus::Registry>, supports_parachains: SupportsParachains, s: S, - connector: OverseerConnector, ) -> SubsystemResult<(Self, OverseerHandle)> where CV: Subsystem, SubsystemError> + Send, @@ -630,7 +679,7 @@ where .supports_parachains(supports_parachains) .metrics(metrics.clone()) .spawner(s) - .build_with_connector(connector)?; + .build()?; // spawn the metrics metronome task { diff --git a/node/overseer/src/metrics.rs b/node/overseer/src/metrics.rs index fa883857e9be..ab3b2a3bc14b 100644 --- a/node/overseer/src/metrics.rs +++ b/node/overseer/src/metrics.rs @@ -17,7 +17,7 @@ //! Prometheus metrics related to the overseer and its channels. use super::*; -pub use polkadot_node_metrics::metrics::{self, prometheus, Metrics as MetricsTrait}; +use polkadot_node_metrics::metrics::{self, prometheus}; use parity_util_mem::MemoryAllocationSnapshot; @@ -110,7 +110,7 @@ impl Metrics { } } -impl MetricsTrait for Metrics { +impl metrics::Metrics for Metrics { fn try_register(registry: &prometheus::Registry) -> Result { let metrics = MetricsInner { activated_heads_total: prometheus::register( diff --git a/node/overseer/src/subsystems.rs b/node/overseer/src/subsystems.rs index 695d368dc16c..648528730d67 100644 --- a/node/overseer/src/subsystems.rs +++ b/node/overseer/src/subsystems.rs @@ -19,9 +19,47 @@ //! In the future, everything should be set up using the generated //! overseer builder pattern instead. -use crate::dummy::DummySubsystem; +use crate::{AllMessages, OverseerSignal}; +use polkadot_node_subsystem_types::errors::SubsystemError; use polkadot_overseer_all_subsystems_gen::AllSubsystemsGen; -use polkadot_overseer_gen::MapSubsystem; +use polkadot_overseer_gen::{ + FromOverseer, MapSubsystem, SpawnedSubsystem, Subsystem, SubsystemContext, +}; + +/// A dummy subsystem that implements [`Subsystem`] for all +/// types of messages. Used for tests or as a placeholder. +#[derive(Clone, Copy, Debug)] +pub struct DummySubsystem; + +impl Subsystem for DummySubsystem +where + Context: SubsystemContext< + Signal = OverseerSignal, + Error = SubsystemError, + AllMessages = AllMessages, + >, +{ + fn start(self, mut ctx: Context) -> SpawnedSubsystem { + let future = Box::pin(async move { + loop { + match ctx.recv().await { + Err(_) => return Ok(()), + Ok(FromOverseer::Signal(OverseerSignal::Conclude)) => return Ok(()), + Ok(overseer_msg) => { + tracing::debug!( + target: "dummy-subsystem", + "Discarding a message sent from overseer {:?}", + overseer_msg + ); + continue + }, + } + } + }); + + SpawnedSubsystem { name: "dummy-subsystem", future } + } +} /// This struct is passed as an argument to create a new instance of an [`Overseer`]. /// diff --git a/node/overseer/src/tests.rs b/node/overseer/src/tests.rs index 349b04d34be3..7564116e7141 100644 --- a/node/overseer/src/tests.rs +++ b/node/overseer/src/tests.rs @@ -32,7 +32,7 @@ use polkadot_primitives::v1::{ ValidatorIndex, }; -use crate::{self as overseer, gen::Delay, HeadSupportsParachains, Overseer, OverseerConnector}; +use crate::{self as overseer, gen::Delay, HeadSupportsParachains, Overseer}; use metered_channel as metered; use assert_matches::assert_matches; @@ -164,16 +164,9 @@ fn overseer_works() { .replace_candidate_validation(move |_| TestSubsystem1(s1_tx)) .replace_candidate_backing(move |_| TestSubsystem2(s2_tx)); - let (overseer, handle) = Overseer::new( - vec![], - all_subsystems, - None, - MockSupportsParachains, - spawner, - OverseerConnector::default(), - ) - .unwrap(); - let mut handle = Handle(handle); + let (overseer, handle) = + Overseer::new(vec![], all_subsystems, None, MockSupportsParachains, spawner).unwrap(); + let mut handle = Handle::Connected(handle); let overseer_fut = overseer.run().fuse(); pin_mut!(overseer_fut); @@ -234,10 +227,9 @@ fn overseer_metrics_work() { Some(®istry), MockSupportsParachains, spawner, - OverseerConnector::default(), ) .unwrap(); - let mut handle = Handle(handle); + let mut handle = Handle::Connected(handle); let overseer_fut = overseer.run().fuse(); pin_mut!(overseer_fut); @@ -288,15 +280,8 @@ fn overseer_ends_on_subsystem_exit() { executor::block_on(async move { let all_subsystems = AllSubsystems::<()>::dummy().replace_candidate_backing(|_| ReturnOnStart); - let (overseer, _handle) = Overseer::new( - vec![], - all_subsystems, - None, - MockSupportsParachains, - spawner, - OverseerConnector::default(), - ) - .unwrap(); + let (overseer, _handle) = + Overseer::new(vec![], all_subsystems, None, MockSupportsParachains, spawner).unwrap(); overseer.run().await.unwrap(); }) @@ -397,16 +382,10 @@ fn overseer_start_stop_works() { let all_subsystems = AllSubsystems::<()>::dummy() .replace_candidate_validation(move |_| TestSubsystem5(tx_5)) .replace_candidate_backing(move |_| TestSubsystem6(tx_6)); - let (overseer, handle) = Overseer::new( - vec![first_block], - all_subsystems, - None, - MockSupportsParachains, - spawner, - OverseerConnector::default(), - ) - .unwrap(); - let mut handle = Handle(handle); + let (overseer, handle) = + Overseer::new(vec![first_block], all_subsystems, None, MockSupportsParachains, spawner) + .unwrap(); + let mut handle = Handle::Connected(handle); let overseer_fut = overseer.run().fuse(); pin_mut!(overseer_fut); @@ -507,10 +486,9 @@ fn overseer_finalize_works() { None, MockSupportsParachains, spawner, - OverseerConnector::default(), ) .unwrap(); - let mut handle = Handle(handle); + let mut handle = Handle::Connected(handle); let overseer_fut = overseer.run().fuse(); pin_mut!(overseer_fut); @@ -595,16 +573,10 @@ fn do_not_send_empty_leaves_update_on_block_finalization() { let all_subsystems = AllSubsystems::<()>::dummy().replace_candidate_backing(move |_| TestSubsystem6(tx_5)); - let (overseer, handle) = Overseer::new( - Vec::new(), - all_subsystems, - None, - MockSupportsParachains, - spawner, - OverseerConnector::default(), - ) - .unwrap(); - let mut handle = Handle(handle); + let (overseer, handle) = + Overseer::new(Vec::new(), all_subsystems, None, MockSupportsParachains, spawner) + .unwrap(); + let mut handle = Handle::Connected(handle); let overseer_fut = overseer.run().fuse(); pin_mut!(overseer_fut); @@ -877,17 +849,9 @@ fn overseer_all_subsystems_receive_signals_and_messages() { dispute_distribution: subsystem.clone(), chain_selection: subsystem.clone(), }; - - let (overseer, handle) = Overseer::new( - vec![], - all_subsystems, - None, - MockSupportsParachains, - spawner, - OverseerConnector::default(), - ) - .unwrap(); - let mut handle = Handle(handle); + let (overseer, handle) = + Overseer::new(vec![], all_subsystems, None, MockSupportsParachains, spawner).unwrap(); + let mut handle = Handle::Connected(handle); let overseer_fut = overseer.run().fuse(); pin_mut!(overseer_fut); diff --git a/node/service/Cargo.toml b/node/service/Cargo.toml index 632c83c94980..affd8b25b33b 100644 --- a/node/service/Cargo.toml +++ b/node/service/Cargo.toml @@ -26,7 +26,6 @@ sc-keystore = { git = "https://github.com/paritytech/substrate", branch = "maste sc-basic-authorship = { git = "https://github.com/paritytech/substrate", branch = "master" } service = { package = "sc-service", git = "https://github.com/paritytech/substrate", branch = "master", default-features = false } telemetry = { package = "sc-telemetry", git = "https://github.com/paritytech/substrate", branch = "master" } -lru = "0.6" # Substrate Primitives sp-authority-discovery = { git = "https://github.com/paritytech/substrate", branch = "master" } diff --git a/node/service/src/lib.rs b/node/service/src/lib.rs index 66047854f3c2..bcb181fa04b8 100644 --- a/node/service/src/lib.rs +++ b/node/service/src/lib.rs @@ -54,7 +54,7 @@ use { pub use sp_core::traits::SpawnNamed; #[cfg(feature = "full-node")] pub use { - polkadot_overseer::{Handle, Overseer, OverseerConnector, OverseerHandle}, + polkadot_overseer::{Handle, Overseer, OverseerHandle}, polkadot_primitives::v1::ParachainHost, sc_client_api::AuxStore, sp_authority_discovery::AuthorityDiscoveryApi, @@ -68,8 +68,6 @@ use polkadot_subsystem::jaeger; use std::{sync::Arc, time::Duration}; use prometheus_endpoint::Registry; -#[cfg(feature = "full-node")] -use service::KeystoreContainer; use service::RpcHandlers; use telemetry::TelemetryWorker; #[cfg(feature = "full-node")] @@ -304,15 +302,14 @@ fn jaeger_launch_collector_with_agent( } #[cfg(feature = "full-node")] -type FullSelectChain = relay_chain_selection::SelectRelayChain; +type FullSelectChain = relay_chain_selection::SelectRelayChainWithFallback; #[cfg(feature = "full-node")] -type FullGrandpaBlockImport = - grandpa::GrandpaBlockImport< - FullBackend, - Block, - FullClient, - ChainSelection, - >; +type FullGrandpaBlockImport = grandpa::GrandpaBlockImport< + FullBackend, + Block, + FullClient, + FullSelectChain, +>; #[cfg(feature = "light-node")] type LightBackend = service::TLightBackendWithHash; @@ -322,29 +319,36 @@ type LightClient = service::TLightClientWithBackend; #[cfg(feature = "full-node")] -struct Basics -where - RuntimeApi: ConstructRuntimeApi> - + Send - + Sync - + 'static, - RuntimeApi::RuntimeApi: - RuntimeApiCollection>, - ExecutorDispatch: NativeExecutionDispatch + 'static, -{ - task_manager: TaskManager, - client: Arc>, - backend: Arc, - keystore_container: KeystoreContainer, - telemetry: Option, -} - -#[cfg(feature = "full-node")] -fn new_partial_basics( +fn new_partial( config: &mut Configuration, jaeger_agent: Option, telemetry_worker_handle: Option, -) -> Result, Error> +) -> Result< + service::PartialComponents< + FullClient, + FullBackend, + FullSelectChain, + sc_consensus::DefaultImportQueue>, + sc_transaction_pool::FullPool>, + ( + impl service::RpcExtensionBuilder, + ( + babe::BabeBlockImport< + Block, + FullClient, + FullGrandpaBlockImport, + >, + grandpa::LinkHalf, FullSelectChain>, + babe::BabeLink, + beefy_gadget::notification::BeefySignedCommitmentSender, + ), + grandpa::SharedVoterState, + std::time::Duration, // slot-duration + Option, + ), + >, + Error, +> where RuntimeApi: ConstructRuntimeApi> + Send @@ -387,62 +391,21 @@ where )?; let client = Arc::new(client); - jaeger_launch_collector_with_agent(task_manager.spawn_handle(), &*config, jaeger_agent)?; - - let telemetry: Option<_> = telemetry.map(|(worker, telemetry)| { + let telemetry = telemetry.map(|(worker, telemetry)| { if let Some(worker) = worker { task_manager.spawn_handle().spawn("telemetry", worker.run()); } telemetry }); - Ok(Basics { task_manager, client, backend, keystore_container, telemetry }) -} + jaeger_launch_collector_with_agent(task_manager.spawn_handle(), &*config, jaeger_agent)?; + + let select_chain = relay_chain_selection::SelectRelayChainWithFallback::new( + backend.clone(), + Handle::new_disconnected(), + polkadot_node_subsystem_util::metrics::Metrics::register(config.prometheus_registry())?, + ); -#[cfg(feature = "full-node")] -fn new_partial( - config: &mut Configuration, - Basics { task_manager, backend, client, keystore_container, telemetry }: Basics< - RuntimeApi, - ExecutorDispatch, - >, - select_chain: ChainSelection, -) -> Result< - service::PartialComponents< - FullClient, - FullBackend, - ChainSelection, - sc_consensus::DefaultImportQueue>, - sc_transaction_pool::FullPool>, - ( - impl service::RpcExtensionBuilder, - ( - babe::BabeBlockImport< - Block, - FullClient, - FullGrandpaBlockImport, - >, - grandpa::LinkHalf, ChainSelection>, - babe::BabeLink, - beefy_gadget::notification::BeefySignedCommitmentSender, - ), - grandpa::SharedVoterState, - std::time::Duration, // slot-duration - Option, - ), - >, - Error, -> -where - RuntimeApi: ConstructRuntimeApi> - + Send - + Sync - + 'static, - RuntimeApi::RuntimeApi: - RuntimeApiCollection>, - ExecutorDispatch: NativeExecutionDispatch + 'static, - ChainSelection: 'static + SelectChain, -{ let transaction_pool = sc_transaction_pool::BasicPool::new_full( config.transaction_pool.clone(), config.role.is_authority().into(), @@ -711,50 +674,23 @@ where let disable_grandpa = config.disable_grandpa; let name = config.network.node_name.clone(); - let overseer_connector = OverseerConnector::default(); - - let handle = Handle(overseer_connector.as_handle().clone()); - - let basics = new_partial_basics::( - &mut config, - jaeger_agent, - telemetry_worker_handle, - )?; - - // we should remove this check before we deploy parachains on polkadot - // TODO: https://github.com/paritytech/polkadot/issues/3326 - let chain_spec = &config.chain_spec as &dyn IdentifyVariant; - - let is_relay_chain = chain_spec.is_kusama() || - chain_spec.is_westend() || - chain_spec.is_rococo() || - chain_spec.is_wococo(); - - let prometheus_registry = config.prometheus_registry().cloned(); - - use relay_chain_selection::SelectRelayChain; - - let select_chain = SelectRelayChain::new( - basics.backend.clone(), - is_relay_chain, - handle.clone(), - polkadot_node_subsystem_util::metrics::Metrics::register(prometheus_registry.as_ref())?, - ); - let service::PartialComponents::<_, _, SelectRelayChain<_>, _, _, _> { + let service::PartialComponents { client, backend, mut task_manager, keystore_container, - select_chain, + mut select_chain, import_queue, transaction_pool, other: (rpc_extensions_builder, import_setup, rpc_setup, slot_duration, mut telemetry), - } = new_partial::>( + } = new_partial::( &mut config, - basics, - select_chain, + jaeger_agent, + telemetry_worker_handle, )?; + let prometheus_registry = config.prometheus_registry().cloned(); + let shared_voter_state = rpc_setup; let auth_disc_publish_non_global_ips = config.network.allow_non_globals_in_dht; @@ -914,10 +850,8 @@ where local_keystore.and_then(move |k| authority_discovery_service.map(|a| (a, k))); let overseer_handle = if let Some((authority_discovery_service, keystore)) = maybe_params { - // already have access to the handle - let (overseer, _handle) = overseer_gen + let (overseer, overseer_handle) = overseer_gen .generate::>( - overseer_connector, OverseerGenArgs { leaves: active_leaves, keystore, @@ -941,29 +875,40 @@ where dispute_coordinator_config, }, )?; + let handle = Handle::Connected(overseer_handle.clone()); + let handle_clone = handle.clone(); - { - let handle = handle.clone(); - task_manager.spawn_essential_handle().spawn_blocking( - "overseer", - Box::pin(async move { - use futures::{pin_mut, select, FutureExt}; + 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, handle); + let forward = polkadot_overseer::forward_events(overseer_client, handle_clone); - let forward = forward.fuse(); - let overseer_fut = overseer.run().fuse(); + let forward = forward.fuse(); + let overseer_fut = overseer.run().fuse(); - pin_mut!(overseer_fut); - pin_mut!(forward); + pin_mut!(overseer_fut); + pin_mut!(forward); - select! { - _ = forward => (), - _ = overseer_fut => (), - complete => (), - } - }), - ); + select! { + _ = forward => (), + _ = overseer_fut => (), + complete => (), + } + }), + ); + // we should remove this check before we deploy parachains on polkadot + // TODO: https://github.com/paritytech/polkadot/issues/3326 + let should_connect_overseer = chain_spec.is_kusama() || + chain_spec.is_westend() || + chain_spec.is_rococo() || + chain_spec.is_wococo(); + + if should_connect_overseer { + select_chain.connect_to_overseer(overseer_handle.clone()); + } else { + tracing::info!("Overseer is running in the disconnected state"); } Some(handle) } else { @@ -1283,31 +1228,6 @@ where Ok((task_manager, rpc_handlers)) } -macro_rules! chain_ops { - ($config:expr, $jaeger_agent:expr, $telemetry_worker_handle:expr; $scope:ident, $executor:ident, $variant:ident) => {{ - let telemetry_worker_handle = $telemetry_worker_handle; - let jaeger_agent = $jaeger_agent; - let mut config = $config; - let basics = new_partial_basics::<$scope::RuntimeApi, $executor>( - config, - jaeger_agent, - telemetry_worker_handle, - )?; - - use ::sc_consensus::LongestChain; - // use the longest chain selection, since there is no overseer available - let chain_selection = LongestChain::new(basics.backend.clone()); - - let service::PartialComponents { client, backend, import_queue, task_manager, .. } = - new_partial::<$scope::RuntimeApi, $executor, LongestChain<_, Block>>( - &mut config, - basics, - chain_selection, - )?; - Ok((Arc::new(Client::$variant(client)), backend, import_queue, task_manager)) - }}; -} - /// Builds a new object suitable for chain operations. #[cfg(feature = "full-node")] pub fn new_chain_ops( @@ -1324,26 +1244,48 @@ pub fn new_chain_ops( > { config.keystore = service::config::KeystoreConfig::InMemory; - let telemetry_worker_handle = None; - #[cfg(feature = "rococo-native")] if config.chain_spec.is_rococo() || config.chain_spec.is_wococo() { - return chain_ops!(config, jaeger_agent, telemetry_worker_handle; rococo_runtime, RococoExecutorDispatch, Rococo) + let service::PartialComponents { client, backend, import_queue, task_manager, .. } = + new_partial::( + config, + jaeger_agent, + None, + )?; + return Ok((Arc::new(Client::Rococo(client)), backend, import_queue, task_manager)) } #[cfg(feature = "kusama-native")] if config.chain_spec.is_kusama() { - return chain_ops!(config, jaeger_agent, telemetry_worker_handle; kusama_runtime, KusamaExecutorDispatch, Kusama) + let service::PartialComponents { client, backend, import_queue, task_manager, .. } = + new_partial::( + config, + jaeger_agent, + None, + )?; + return Ok((Arc::new(Client::Kusama(client)), backend, import_queue, task_manager)) } #[cfg(feature = "westend-native")] if config.chain_spec.is_westend() { - return chain_ops!(config, jaeger_agent, telemetry_worker_handle; westend_runtime, WestendExecutorDispatch, Westend) + let service::PartialComponents { client, backend, import_queue, task_manager, .. } = + new_partial::( + config, + jaeger_agent, + None, + )?; + return Ok((Arc::new(Client::Westend(client)), backend, import_queue, task_manager)) } #[cfg(feature = "polkadot-native")] { - chain_ops!(config, jaeger_agent, telemetry_worker_handle; polkadot_runtime, PolkadotExecutorDispatch, Polkadot) + let service::PartialComponents { client, backend, import_queue, task_manager, .. } = + new_partial::( + config, + jaeger_agent, + None, + )?; + return Ok((Arc::new(Client::Polkadot(client)), backend, import_queue, task_manager)) } #[cfg(not(feature = "polkadot-native"))] diff --git a/node/service/src/overseer.rs b/node/service/src/overseer.rs index 385bab190266..66156fd18298 100644 --- a/node/service/src/overseer.rs +++ b/node/service/src/overseer.rs @@ -15,7 +15,6 @@ // along with Polkadot. If not, see . use super::{AuthorityDiscoveryApi, Block, Error, Hash, IsCollator, Registry, SpawnNamed}; -use lru::LruCache; use polkadot_availability_distribution::IncomingRequestReceivers; use polkadot_node_core_approval_voting::Config as ApprovalVotingConfig; use polkadot_node_core_av_store::Config as AvailabilityConfig; @@ -23,14 +22,7 @@ use polkadot_node_core_candidate_validation::Config as CandidateValidationConfig use polkadot_node_core_chain_selection::Config as ChainSelectionConfig; use polkadot_node_core_dispute_coordinator::Config as DisputeCoordinatorConfig; use polkadot_node_network_protocol::request_response::{v1 as request_v1, IncomingRequestReceiver}; -#[cfg(any(feature = "malus", test))] -pub use polkadot_overseer::dummy::DummySubsystem; -pub use polkadot_overseer::{ - metrics::{Metrics, MetricsTrait}, - AllSubsystems, BlockInfo, HeadSupportsParachains, Overseer, OverseerBuilder, OverseerConnector, - OverseerHandle, -}; - +use polkadot_overseer::{AllSubsystems, BlockInfo, Overseer, OverseerHandle}; use polkadot_primitives::v1::ParachainHost; use sc_authority_discovery::Service as AuthorityDiscoveryService; use sc_client_api::AuxStore; @@ -263,176 +255,6 @@ where Ok(all_subsystems) } -/// Obtain a prepared `OverseerBuilder`, that is initialized -/// with all default values. -pub fn prepared_overseer_builder<'a, Spawner, RuntimeClient>( - OverseerGenArgs { - leaves, - keystore, - runtime_client, - parachains_db, - network_service, - authority_discovery_service, - pov_req_receiver, - chunk_req_receiver, - collation_req_receiver, - available_data_req_receiver, - statement_req_receiver, - dispute_req_receiver, - registry, - spawner, - is_collator, - approval_voting_config, - availability_config, - candidate_validation_config, - chain_selection_config, - dispute_coordinator_config, - }: OverseerGenArgs<'a, Spawner, RuntimeClient>, -) -> Result< - OverseerBuilder< - Spawner, - Arc, - CandidateValidationSubsystem, - CandidateBackingSubsystem, - StatementDistributionSubsystem, - AvailabilityDistributionSubsystem, - AvailabilityRecoverySubsystem, - BitfieldSigningSubsystem, - BitfieldDistributionSubsystem, - ProvisionerSubsystem, - RuntimeApiSubsystem, - AvailabilityStoreSubsystem, - NetworkBridgeSubsystem< - Arc>, - AuthorityDiscoveryService, - >, - ChainApiSubsystem, - CollationGenerationSubsystem, - CollatorProtocolSubsystem, - ApprovalDistributionSubsystem, - ApprovalVotingSubsystem, - GossipSupportSubsystem, - DisputeCoordinatorSubsystem, - DisputeParticipationSubsystem, - DisputeDistributionSubsystem, - ChainSelectionSubsystem, - >, - Error, -> -where - RuntimeClient: 'static + ProvideRuntimeApi + HeaderBackend + AuxStore, - RuntimeClient::Api: ParachainHost + BabeApi + AuthorityDiscoveryApi, - Spawner: 'static + SpawnNamed + Clone + Unpin, -{ - use polkadot_node_subsystem_util::metrics::Metrics; - use std::iter::FromIterator; - - let metrics = ::register(registry)?; - - let builder = Overseer::builder() - .availability_distribution(AvailabilityDistributionSubsystem::new( - keystore.clone(), - IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver }, - Metrics::register(registry)?, - )) - .availability_recovery(AvailabilityRecoverySubsystem::with_chunks_only( - available_data_req_receiver, - Metrics::register(registry)?, - )) - .availability_store(AvailabilityStoreSubsystem::new( - parachains_db.clone(), - 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_validation(CandidateValidationSubsystem::with_config( - candidate_validation_config, - Metrics::register(registry)?, // candidate-validation metrics - Metrics::register(registry)?, // validation host metrics - )) - .chain_api(ChainApiSubsystem::new(runtime_client.clone(), Metrics::register(registry)?)) - .collation_generation(CollationGenerationSubsystem::new(Metrics::register(registry)?)) - .collator_protocol({ - let side = match is_collator { - IsCollator::Yes(collator_pair) => ProtocolSide::Collator( - network_service.local_peer_id().clone(), - collator_pair, - collation_req_receiver, - Metrics::register(registry)?, - ), - IsCollator::No => ProtocolSide::Validator { - keystore: keystore.clone(), - eviction_policy: Default::default(), - metrics: Metrics::register(registry)?, - }, - }; - CollatorProtocolSubsystem::new(side) - }) - .network_bridge(NetworkBridgeSubsystem::new( - network_service.clone(), - authority_discovery_service.clone(), - Box::new(network_service.clone()), - Metrics::register(registry)?, - )) - .provisioner(ProvisionerSubsystem::new(spawner.clone(), (), Metrics::register(registry)?)) - .runtime_api(RuntimeApiSubsystem::new( - runtime_client.clone(), - Metrics::register(registry)?, - spawner.clone(), - )) - .statement_distribution(StatementDistributionSubsystem::new( - keystore.clone(), - statement_req_receiver, - Metrics::register(registry)?, - )) - .approval_distribution(ApprovalDistributionSubsystem::new(Metrics::register(registry)?)) - .approval_voting(ApprovalVotingSubsystem::with_config( - approval_voting_config, - parachains_db.clone(), - keystore.clone(), - Box::new(network_service.clone()), - Metrics::register(registry)?, - )) - .gossip_support(GossipSupportSubsystem::new(keystore.clone())) - .dispute_coordinator(DisputeCoordinatorSubsystem::new( - parachains_db.clone(), - dispute_coordinator_config, - keystore.clone(), - Metrics::register(registry)?, - )) - .dispute_participation(DisputeParticipationSubsystem::new()) - .dispute_distribution(DisputeDistributionSubsystem::new( - keystore.clone(), - dispute_req_receiver, - authority_discovery_service.clone(), - Metrics::register(registry)?, - )) - .chain_selection(ChainSelectionSubsystem::new(chain_selection_config, parachains_db)) - .leaves(Vec::from_iter( - leaves - .into_iter() - .map(|BlockInfo { hash, parent_hash: _, number }| (hash, number)), - )) - .activation_external_listeners(Default::default()) - .span_per_active_leaf(Default::default()) - .active_leaves(Default::default()) - .supports_parachains(runtime_client) - .known_leaves(LruCache::new(KNOWN_LEAVES_CACHE_SIZE)) - .metrics(metrics) - .spawner(spawner); - Ok(builder) -} - /// Trait for the `fn` generating the overseer. /// /// Default behavior is to create an unmodified overseer, as `RealOverseerGen` @@ -441,7 +263,6 @@ pub trait OverseerGen { /// Overwrite the full generation of the overseer, including the subsystems. fn generate<'a, Spawner, RuntimeClient>( &self, - connector: OverseerConnector, args: OverseerGenArgs<'a, Spawner, RuntimeClient>, ) -> Result<(Overseer>, OverseerHandle), Error> where @@ -450,22 +271,19 @@ pub trait OverseerGen { Spawner: 'static + SpawnNamed + Clone + Unpin, { let gen = RealOverseerGen; - RealOverseerGen::generate::(&gen, connector, args) + RealOverseerGen::generate::(&gen, args) } // It would be nice to make `create_subsystems` part of this trait, // but the amount of generic arguments that would be required as // as consequence make this rather annoying to implement and use. } -use polkadot_overseer::KNOWN_LEAVES_CACHE_SIZE; - /// The regular set of subsystems. pub struct RealOverseerGen; impl OverseerGen for RealOverseerGen { fn generate<'a, Spawner, RuntimeClient>( &self, - connector: OverseerConnector, args: OverseerGenArgs<'a, Spawner, RuntimeClient>, ) -> Result<(Overseer>, OverseerHandle), Error> where @@ -473,8 +291,14 @@ impl OverseerGen for RealOverseerGen { RuntimeClient::Api: ParachainHost + BabeApi + AuthorityDiscoveryApi, Spawner: 'static + SpawnNamed + Clone + Unpin, { - prepared_overseer_builder(args)? - .build_with_connector(connector) + let spawner = args.spawner.clone(); + let leaves = args.leaves.clone(); + let runtime_client = args.runtime_client.clone(); + let registry = args.registry.clone(); + + let all_subsystems = create_default_subsystems::(args)?; + + Overseer::new(leaves, all_subsystems, registry, runtime_client, spawner) .map_err(|e| e.into()) } } diff --git a/node/service/src/relay_chain_selection.rs b/node/service/src/relay_chain_selection.rs index cece25d3e547..184d526eac47 100644 --- a/node/service/src/relay_chain_selection.rs +++ b/node/service/src/relay_chain_selection.rs @@ -39,7 +39,7 @@ use super::{HeaderProvider, HeaderProviderProvider}; use consensus_common::{Error as ConsensusError, SelectChain}; use futures::channel::oneshot; use polkadot_node_subsystem_util::metrics::{self, prometheus}; -use polkadot_overseer::{AllMessages, Handle}; +use polkadot_overseer::{AllMessages, Handle, OverseerHandle}; use polkadot_primitives::v1::{ Block as PolkadotBlock, BlockNumber, Hash, Header as PolkadotHeader, }; @@ -109,57 +109,66 @@ impl Metrics { } /// A chain-selection implementation which provides safety for relay chains. -pub struct SelectRelayChain> { - is_relay_chain: bool, - longest_chain: sc_consensus::LongestChain, - selection: SelectRelayChainInner, +pub struct SelectRelayChainWithFallback> { + // A fallback to use in case the overseer is disconnected. + // + // This is used on relay chains which have not yet enabled + // parachains as well as situations where the node is offline. + fallback: sc_consensus::LongestChain, + selection: SelectRelayChain, } -impl Clone for SelectRelayChain +impl Clone for SelectRelayChainWithFallback where B: sc_client_api::Backend, - SelectRelayChainInner: Clone, + SelectRelayChain: Clone, { fn clone(&self) -> Self { - Self { - is_relay_chain: self.is_relay_chain, - longest_chain: self.longest_chain.clone(), - selection: self.selection.clone(), - } + Self { fallback: self.fallback.clone(), selection: self.selection.clone() } } } -impl SelectRelayChain +impl SelectRelayChainWithFallback where B: sc_client_api::Backend + 'static, { - /// Create a new [`SelectRelayChain`] wrapping the given chain backend + /// Create a new [`SelectRelayChainWithFallback`] wrapping the given chain backend /// and a handle to the overseer. - pub fn new(backend: Arc, is_relay_chain: bool, overseer: Handle, metrics: Metrics) -> Self { - SelectRelayChain { - is_relay_chain, - longest_chain: sc_consensus::LongestChain::new(backend.clone()), - selection: SelectRelayChainInner::new(backend, overseer, metrics), + pub fn new(backend: Arc, overseer: Handle, metrics: Metrics) -> Self { + SelectRelayChainWithFallback { + fallback: sc_consensus::LongestChain::new(backend.clone()), + selection: SelectRelayChain::new(backend, overseer, metrics), } } } +impl SelectRelayChainWithFallback +where + B: sc_client_api::Backend + 'static, +{ + /// Given an overseer handle, this connects the [`SelectRelayChainWithFallback`]'s + /// internal handle and its clones to the same overseer. + pub fn connect_to_overseer(&mut self, handle: OverseerHandle) { + self.selection.overseer.connect_to_overseer(handle); + } +} + #[async_trait::async_trait] -impl SelectChain for SelectRelayChain +impl SelectChain for SelectRelayChainWithFallback where B: sc_client_api::Backend + 'static, { async fn leaves(&self) -> Result, ConsensusError> { - if !self.is_relay_chain { - return self.longest_chain.leaves().await + if self.selection.overseer.is_disconnected() { + return self.fallback.leaves().await } self.selection.leaves().await } async fn best_chain(&self) -> Result { - if !self.is_relay_chain { - return self.longest_chain.best_chain().await + if self.selection.overseer.is_disconnected() { + return self.fallback.best_chain().await } self.selection.best_chain().await } @@ -170,34 +179,34 @@ where maybe_max_number: Option, ) -> Result, ConsensusError> { let longest_chain_best = - self.longest_chain.finality_target(target_hash, maybe_max_number).await?; + self.fallback.finality_target(target_hash, maybe_max_number).await?; - if !self.is_relay_chain { + if self.selection.overseer.is_disconnected() { return Ok(longest_chain_best) } self.selection - .finality_target_with_longest_chain(target_hash, longest_chain_best, maybe_max_number) + .finality_target_with_fallback(target_hash, longest_chain_best, maybe_max_number) .await } } /// A chain-selection implementation which provides safety for relay chains /// but does not handle situations where the overseer is not yet connected. -pub struct SelectRelayChainInner { +pub struct SelectRelayChain { backend: Arc, overseer: OH, metrics: Metrics, } -impl SelectRelayChainInner +impl SelectRelayChain where B: HeaderProviderProvider, OH: OverseerHandleT, { - /// Create a new [`SelectRelayChainInner`] wrapping the given chain backend + /// Create a new [`SelectRelayChain`] wrapping the given chain backend /// and a handle to the overseer. pub fn new(backend: Arc, overseer: OH, metrics: Metrics) -> Self { - SelectRelayChainInner { backend, overseer, metrics } + SelectRelayChain { backend, overseer, metrics } } fn block_header(&self, hash: Hash) -> Result { @@ -225,13 +234,13 @@ where } } -impl Clone for SelectRelayChainInner +impl Clone for SelectRelayChain where B: HeaderProviderProvider + Send + Sync, OH: OverseerHandleT, { fn clone(&self) -> Self { - SelectRelayChainInner { + SelectRelayChain { backend: self.backend.clone(), overseer: self.overseer.clone(), metrics: self.metrics.clone(), @@ -264,7 +273,7 @@ impl OverseerHandleT for Handle { } } -impl SelectRelayChainInner +impl SelectRelayChain where B: HeaderProviderProvider, OH: OverseerHandleT, @@ -308,7 +317,7 @@ where /// /// It will also constrain the chain to only chains which are fully /// approved, and chains which contain no disputes. - pub(crate) async fn finality_target_with_longest_chain( + pub(crate) async fn finality_target_with_fallback( &self, target_hash: Hash, best_leaf: Option, diff --git a/node/service/src/tests.rs b/node/service/src/tests.rs index 7dc5fe19ecbd..34ac69d78cc7 100644 --- a/node/service/src/tests.rs +++ b/node/service/src/tests.rs @@ -79,7 +79,7 @@ fn test_harness>( let (finality_target_tx, finality_target_rx) = oneshot::channel::>(); - let select_relay_chain = SelectRelayChainInner::::new( + let select_relay_chain = SelectRelayChain::::new( Arc::new(case_vars.chain.clone()), context.sender().clone(), Default::default(), diff --git a/node/subsystem-test-helpers/src/lib.rs b/node/subsystem-test-helpers/src/lib.rs index c180c1d0ea88..80dae08825b0 100644 --- a/node/subsystem-test-helpers/src/lib.rs +++ b/node/subsystem-test-helpers/src/lib.rs @@ -372,9 +372,7 @@ mod tests { use super::*; use futures::executor::block_on; use polkadot_node_subsystem::messages::CollatorProtocolMessage; - use polkadot_overseer::{ - AllSubsystems, Handle, HeadSupportsParachains, Overseer, OverseerConnector, - }; + use polkadot_overseer::{AllSubsystems, Handle, HeadSupportsParachains, Overseer}; use polkadot_primitives::v1::Hash; struct AlwaysSupportsParachains; @@ -396,10 +394,9 @@ mod tests { None, AlwaysSupportsParachains, spawner.clone(), - OverseerConnector::default(), ) .unwrap(); - let mut handle = Handle(handle); + let mut handle = Handle::Connected(handle); spawner.spawn("overseer", overseer.run().then(|_| async { () }).boxed()); diff --git a/node/subsystem/src/lib.rs b/node/subsystem/src/lib.rs index 429120709a07..f0918ab1dc02 100644 --- a/node/subsystem/src/lib.rs +++ b/node/subsystem/src/lib.rs @@ -24,9 +24,7 @@ pub use jaeger::*; pub use polkadot_node_jaeger as jaeger; -pub use polkadot_overseer::{ - self as overseer, dummy::DummySubsystem, ActiveLeavesUpdate, OverseerConnector, OverseerSignal, -}; +pub use polkadot_overseer::{self as overseer, ActiveLeavesUpdate, DummySubsystem, OverseerSignal}; pub use polkadot_node_subsystem_types::{ errors::{self, *},