start working on building the real overseer

node/network/collator-protocol/src/collator_side.rs

@@ -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) {

node/network/collator-protocol/src/lib.rs

@@ -36,7 +36,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;
@@ -71,28 +71,25 @@ 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),
 }
 
 /// The collator protocol subsystem.
 pub struct CollatorProtocolSubsystem {
-	protocol_side: ProtocolSide, 
+	protocol_side: ProtocolSide,
 }
 
 impl CollatorProtocolSubsystem {
 	/// Start the collator protocol.
 	/// If `id` is `Some` this is a collator side of the protocol.
-	/// If `id` is `None` this is a validator 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,
 		}

node/network/collator-protocol/src/validator_side.rs

@@ -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<(), ()>) {

node/network/statement-distribution/src/lib.rs

@@ -83,6 +83,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.
 ///

node/overseer/src/lib.rs

@@ -1169,7 +1169,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 {

node/service/Cargo.toml

@@ -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" }
+polkadot-availability-distribution = { path = "../network/availability-distribution" }
+polkadot-collator-protocol = { path = "../network/collator-protocol" }
+polkadot-network-bridge = { path = "../network/bridge" }
+polkadot-node-collation-generation = { path = "../collation-generation" }
+polkadot-node-core-av-store = { path = "../core/av-store" }
+polkadot-node-core-backing = { path = "../core/backing" }
+polkadot-node-core-bitfield-signing = { path = "../core/bitfield-signing" }
+polkadot-node-core-candidate-selection = { path = "../core/candidate-selection" }
+polkadot-node-core-candidate-validation = { path = "../core/candidate-validation" }
+polkadot-node-core-chain-api = { path = "../core/chain-api" }
+polkadot-node-core-provisioner = { path = "../core/provisioner" }
+polkadot-node-core-runtime-api = { path = "../core/runtime-api" }
+polkadot-pov-distribution = { path = "../network/pov-distribution" }
+polkadot-statement-distribution = { path = "../network/statement-distribution" }
 
 [dev-dependencies]
 polkadot-test-runtime-client = { path = "../../runtime/test-runtime/client" }

node/service/src/lib.rs

@@ -23,15 +23,18 @@ mod client;
 
 use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
 use log::info;
+use polkadot_node_core_av_store::Config as AvailabilityConfig;
 use polkadot_node_core_proposer::ProposerFactory;
 use polkadot_overseer::{AllSubsystems, BlockInfo, Overseer, OverseerHandler};
-use polkadot_subsystem::DummySubsystem;
+use polkadot_primitives::v1::ParachainHost;
 use prometheus_endpoint::Registry;
+use authority_discovery::Service as AuthorityDiscoveryService;
 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_keystore::SyncCryptoStorePtr;
 use sp_trie::PrefixedMemoryDB;
 use std::sync::Arc;
 use std::time::Duration;
@@ -42,7 +45,7 @@ pub use chain_spec::{PolkadotChainSpec, KusamaChainSpec, WestendChainSpec, Rococ
 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;
@@ -266,34 +269,105 @@ fn new_partial<RuntimeApi, Executor>(config: &mut Configuration) -> Result<
 	})
 }
 
-fn real_overseer<S: SpawnNamed>(
+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: RuntimeClient,
+	availability_config: AvailabilityConfig,
+	network_service: Arc<sc_network::NetworkService<Block, Hash>>,
+	authority_discovery: AuthorityDiscoveryService,
+	registry: Option<&Registry>,
+	spawner: Spawner,
+) -> Result<(Overseer<Spawner>, OverseerHandler), ServiceError>
+where
+	RuntimeClient: ProvideRuntimeApi<Block> + HeaderBackend<Block>,
+	RuntimeClient::Api: ParachainHost<Block>,
+	Spawner: 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,
+			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,
+		registry,
+		spawner,
 	).map_err(|e| ServiceError::Other(format!("Failed to create an Overseer: {:?}", e)))
 }
 
@@ -418,7 +492,16 @@ pub fn new_full<RuntimeApi, Executor>(
 		})
 		.collect();
 
-	let (overseer, handler) = real_overseer(leaves, prometheus_registry.as_ref(), spawner)?;
+	let (overseer, handler) = real_overseer(
+		leaves,
+		keystore_container.sync_keystore(),
+		overseer_client,
+		unimplemented!("TODO: availability_config"),
+		unimplemented!("TODO: network_service"),
+		unimplemented!("TODO: authority_discovery"),
+		prometheus_registry.as_ref(),
+		spawner,
+	)?;
 	let handler_clone = handler.clone();
 
 	task_manager.spawn_essential_handle().spawn_blocking("overseer", Box::pin(async move {

node/subsystem-util/src/lib.rs

@@ -462,18 +462,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),
+			}
 		}
 	}