Add basic BABE consensus type (#2165)

* Add basic BABE consensus type

* Update core/consensus/babe/slots/Cargo.toml

Co-Authored-By: DemiMarie-parity <48690212+DemiMarie-parity@users.noreply.github.com>

* Fix parameterization and run `rustfmt`

* Respond to review comments

* Update various Cargo.lock files

* Revert "Update various Cargo.lock files"

This reverts commit af53d7624752a744320e9cbb25749fdd8e6f46d2.

* `BabeSealSignature` → `BabeSeal`

* Move slot code to its own crate

This was highly non-trivial, due to cyclic dependencies.

* Remove redundancy between AuRa and BABE

Some of the code duplication was removed using a macro.

* Fix build error

* Avoid non-`#[doc(hidden)]` re-exports

Also, bump some library versions in `Cargo.toml`.

* Remove dead code in AuRa

* Remove impl_slot macro

It was more trouble than it was worth.

Also, delete useless dependencies on Serde.

* AuRa and BABE need different DB keys

* Bring back `aura::Network`, but deprecate it.

* Improve docs and add `slot_duration` inherent method

* Add docs to `substrate_consensus_aura::SlotDuration`

* Add missing documentation and #![forbid(missing_docs, unsafe_code)]

* Add a #![forbid(missing_docs)]

* Remove dependency of `test-runtime` on `slots`

* Update core/consensus/babe/src/lib.rs

Co-Authored-By: DemiMarie-parity <48690212+DemiMarie-parity@users.noreply.github.com>

* Remove wrongly added file

* Fix copyright notice

Co-Authored-By: DemiMarie-parity <48690212+DemiMarie-parity@users.noreply.github.com>

* Bump `impl_version` and `spec_version`

* Fix deprecation version; remove spurious carets

* Update Cargo.lock

* Update dependencies

substrate/core/consensus/aura/Cargo.toml

@@ -1,23 +1,22 @@
 [package]
 name = "substrate-consensus-aura"
-version = "1.0.0"
+version = "1.0.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 description = "Aura consensus algorithm for substrate"
 edition = "2018"
 
 [dependencies]
-parity-codec = "3.3"
-client = { package = "substrate-client", path = "../../client" }
+parity-codec = "3.4"
 primitives = { package = "substrate-primitives", path = "../../primitives" }
 runtime_support = { package = "srml-support", path = "../../../srml/support" }
-runtime_primitives = { package = "sr-primitives", path = "../../sr-primitives" }
 runtime_version = { package = "sr-version", path = "../../sr-version" }
 runtime_io = { package = "sr-io", path = "../../sr-io" }
-aura_slots = { package = "substrate-consensus-aura-slots", path = "slots" }
+slots = { package = "substrate-consensus-slots", path = "../slots" }
 aura_primitives = { package = "substrate-consensus-aura-primitives", path = "primitives" }
 inherents = { package = "substrate-inherents", path = "../../inherents" }
 srml-consensus = { path = "../../../srml/consensus" }
 srml-aura = { path = "../../../srml/aura" }
+client = { package = "substrate-client", path = "../../client" }
 substrate-telemetry = { path = "../../telemetry" }
 futures = "0.1.17"
 tokio = "0.1.7"
@@ -26,6 +25,7 @@ error-chain = "0.12"
 log = "0.4"
 consensus_common = { package = "substrate-consensus-common", path = "../common" }
 authorities = { package = "substrate-consensus-authorities", path = "../authorities" }
+runtime_primitives = { package = "sr-primitives", path = "../../sr-primitives" }
 
 [dev-dependencies]
 keyring = { package = "substrate-keyring", path = "../../keyring" }

substrate/core/consensus/aura/slots/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "substrate-consensus-aura-slots"
-version = "1.0.0"
-authors = ["Parity Technologies <admin@parity.io>"]
-description = "Generic slots-based utilities for consensus"
-edition = "2018"
-
-[dependencies]
-codec = { package = "parity-codec", version = "3.2" }
-client = { package = "substrate-client", path = "../../../client" }
-primitives = { package = "substrate-primitives", path = "../../../primitives" }
-runtime_primitives = { package = "sr-primitives", path = "../../../sr-primitives" }
-aura_primitives = { package = "substrate-consensus-aura-primitives", path = "../primitives" }
-consensus_common = { package = "substrate-consensus-common", path = "../../common" }
-inherents = { package = "substrate-inherents", path = "../../../inherents" }
-futures = "0.1.17"
-tokio = "0.1.7"
-parking_lot = "0.7.1"
-error-chain = "0.12"
-log = "0.4"

substrate/core/consensus/aura/slots/src/lib.rs

@@ -1,255 +0,0 @@
-// Copyright 2019 Parity Technologies (UK) Ltd.
-// This file is part of Substrate.
-
-// Substrate 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.
-
-// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
-
-mod slots;
-
-pub use slots::{Slots, SlotInfo};
-
-use std::sync::{mpsc, Arc};
-use std::thread;
-use futures::prelude::*;
-use futures::{Future, IntoFuture, future::{self, Either}};
-use log::{warn, debug, info};
-use runtime_primitives::generic::BlockId;
-use runtime_primitives::traits::{ProvideRuntimeApi, Block};
-use consensus_common::SyncOracle;
-use inherents::{InherentData, InherentDataProviders};
-use aura_primitives::AuraApi;
-use client::ChainHead;
-use codec::Encode;
-
-/// A worker that should be invoked at every new slot.
-pub trait SlotWorker<B: Block> {
-	type OnSlot: IntoFuture<Item=(), Error=consensus_common::Error>;
-
-	/// Called when the proposer starts.
-	fn on_start(
-		&self,
-		slot_duration: u64
-	) -> Result<(), consensus_common::Error>;
-
-	/// Called when a new slot is triggered.
-	fn on_slot(
-		&self,
-		chain_head: B::Header,
-		slot_info: SlotInfo,
-	) -> Self::OnSlot;
-}
-
-/// Slot compatible inherent data.
-pub trait SlotCompatible {
-	/// Extract timestamp and slot from inherent data.
-	fn extract_timestamp_and_slot(inherent: &InherentData) -> Result<(u64, u64), consensus_common::Error>;
-}
-
-/// Convert an inherent error to common error.
-pub fn inherent_to_common_error(err: inherents::RuntimeString) -> consensus_common::Error {
-	consensus_common::ErrorKind::InherentData(err.into()).into()
-}
-
-/// Start a new slot worker in a separate thread.
-pub fn start_slot_worker_thread<B, C, W, SO, SC, OnExit>(
-	slot_duration: SlotDuration,
-	client: Arc<C>,
-	worker: Arc<W>,
-	sync_oracle: SO,
-	on_exit: OnExit,
-	inherent_data_providers: InherentDataProviders,
-) -> Result<(), consensus_common::Error> where
-	B: Block + 'static,
-	C: ChainHead<B> + Send + Sync + 'static,
-	W: SlotWorker<B> + Send + Sync + 'static,
-	SO: SyncOracle + Send + Clone + 'static,
-	SC: SlotCompatible + 'static,
-	OnExit: Future<Item=(), Error=()> + Send + 'static
-{
-	use tokio::runtime::current_thread::Runtime;
-
-	let (result_sender, result_recv) = mpsc::channel();
-
-	thread::spawn(move || {
-		let mut runtime = match Runtime::new() {
-			Ok(r) => r,
-			Err(e) => {
-				warn!("Unable to start authorship: {:?}", e);
-				return;
-			}
-		};
-
-		let slot_worker_future = match start_slot_worker::<_, _, _, _, SC, _>(
-			slot_duration,
-			client,
-			worker,
-			sync_oracle,
-			on_exit,
-			inherent_data_providers,
-		) {
-			Ok(slot_worker_future) => {
-				result_sender
-					.send(Ok(()))
-					.expect("Receive is not dropped before receiving a result; qed");
-				slot_worker_future
-			},
-			Err(e) => {
-				result_sender
-					.send(Err(e))
-					.expect("Receive is not dropped before receiving a result; qed");
-				return;
-			}
-		};
-
-		let _ = runtime.block_on(slot_worker_future);
-	});
-
-	result_recv.recv().expect("Aura start thread result sender dropped")
-}
-
-/// Start a new slot worker.
-pub fn start_slot_worker<B, C, W, SO, SC, OnExit>(
-	slot_duration: SlotDuration,
-	client: Arc<C>,
-	worker: Arc<W>,
-	sync_oracle: SO,
-	on_exit: OnExit,
-	inherent_data_providers: InherentDataProviders,
-) -> Result<impl Future<Item=(), Error=()>, consensus_common::Error> where
-	B: Block,
-	C: ChainHead<B>,
-	W: SlotWorker<B>,
-	SO: SyncOracle + Send + Clone,
-	SC: SlotCompatible,
-	OnExit: Future<Item=(), Error=()>,
-{
-	worker.on_start(slot_duration.0)?;
-
-	let make_authorship = move || {
-		let client = client.clone();
-		let worker = worker.clone();
-		let sync_oracle = sync_oracle.clone();
-		let SlotDuration(slot_duration) = slot_duration;
-		let inherent_data_providers = inherent_data_providers.clone();
-
-		// rather than use a timer interval, we schedule our waits ourselves
-		Slots::<SC>::new(slot_duration, inherent_data_providers)
-			.map_err(|e| debug!(target: "aura", "Faulty timer: {:?}", e))
-			.for_each(move |slot_info| {
-				let client = client.clone();
-				let worker = worker.clone();
-				let sync_oracle = sync_oracle.clone();
-
-				// only propose when we are not syncing.
-				if sync_oracle.is_major_syncing() {
-					debug!(target: "aura", "Skipping proposal slot due to sync.");
-					return Either::B(future::ok(()));
-				}
-
-				let slot_num = slot_info.number;
-				let chain_head = match client.best_block_header() {
-					Ok(x) => x,
-					Err(e) => {
-						warn!(target: "aura", "Unable to author block in slot {}. \
-							no best block header: {:?}", slot_num, e);
-						return Either::B(future::ok(()))
-					}
-				};
-
-				Either::A(
-					worker.on_slot(chain_head, slot_info).into_future()
-						.map_err(|e| debug!(target: "aura", "Encountered aura error: {:?}", e))
-				)
-			})
-	};
-
-	let work = future::loop_fn((), move |()| {
-		let authorship_task = ::std::panic::AssertUnwindSafe(make_authorship());
-		authorship_task.catch_unwind().then(|res| {
-			match res {
-				Ok(Ok(())) => (),
-				Ok(Err(())) => warn!("Aura authorship task terminated unexpectedly. Restarting"),
-				Err(e) => {
-					if let Some(s) = e.downcast_ref::<&'static str>() {
-						warn!("Aura authorship task panicked at {:?}", s);
-					}
-
-					warn!("Restarting Aura authorship task");
-				}
-			}
-
-			Ok(future::Loop::Continue(()))
-		})
-	});
-
-	Ok(work.select(on_exit).then(|_| Ok(())))
-}
-
-/// A header which has been checked
-pub enum CheckedHeader<H, S> {
-	/// A header which has slot in the future. this is the full header (not stripped)
-	/// and the slot in which it should be processed.
-	Deferred(H, u64),
-	/// A header which is fully checked, including signature. This is the pre-header
-	/// accompanied by the seal components.
-	///
-	/// Includes the digest item that encoded the seal.
-	Checked(H, S),
-}
-
-/// A slot duration. Create with `get_or_compute`.
-// The internal member should stay private here.
-#[derive(Clone, Copy, Debug)]
-pub struct SlotDuration(u64);
-
-impl SlotDuration {
-	/// Either fetch the slot duration from disk or compute it from the genesis
-	/// state.
-	pub fn get_or_compute<B: Block, C>(client: &C) -> ::client::error::Result<Self> where
-		C: client::backend::AuxStore,
-		C: ProvideRuntimeApi,
-		C::Api: AuraApi<B>,
-	{
-		use codec::Decode;
-		const SLOT_KEY: &[u8] = b"aura_slot_duration";
-
-		match client.get_aux(SLOT_KEY)? {
-			Some(v) => u64::decode(&mut &v[..])
-				.map(SlotDuration)
-				.ok_or_else(|| ::client::error::Error::Backend(
-					format!("Aura slot duration kept in invalid format"),
-				).into()),
-			None => {
-				use runtime_primitives::traits::Zero;
-				let genesis_slot_duration = client.runtime_api()
-					.slot_duration(&BlockId::number(Zero::zero()))?;
-
-				info!(
-					"Loaded block-time = {:?} seconds from genesis on first-launch",
-					genesis_slot_duration
-				);
-
-				genesis_slot_duration.using_encoded(|s| {
-					client.insert_aux(&[(SLOT_KEY, &s[..])], &[])
-				})?;
-
-				Ok(SlotDuration(genesis_slot_duration))
-			}
-		}
-	}
-
-	/// Returns slot duration value.
-	pub fn get(&self) -> u64 {
-		self.0
-	}
-}

substrate/core/consensus/aura/slots/src/slots.rs

@@ -1,149 +0,0 @@
-// Copyright 2019 Parity Technologies (UK) Ltd.
-// This file is part of Substrate.
-
-// Substrate 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.
-
-// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
-
-//! Utility stream for yielding slots in a loop.
-//!
-//! This is used instead of `tokio_timer::Interval` because it was unreliable.
-
-use std::time::{Instant, Duration};
-use std::marker::PhantomData;
-use tokio::timer::Delay;
-use futures::prelude::*;
-use futures::try_ready;
-use log::warn;
-use inherents::{InherentDataProviders, InherentData};
-use consensus_common::{Error, ErrorKind};
-use crate::SlotCompatible;
-
-/// Returns current duration since unix epoch.
-pub fn duration_now() -> Option<Duration> {
-	use std::time::SystemTime;
-
-	let now = SystemTime::now();
-	now.duration_since(SystemTime::UNIX_EPOCH).map_err(|e| {
-		warn!("Current time {:?} is before unix epoch. Something is wrong: {:?}", now, e);
-	}).ok()
-}
-
-/// Returns the duration until the next slot, based on current duration since
-pub fn time_until_next(now: Duration, slot_duration: u64) -> Duration {
-	let remaining_full_secs = slot_duration - (now.as_secs() % slot_duration) - 1;
-	let remaining_nanos = 1_000_000_000 - now.subsec_nanos();
-	Duration::new(remaining_full_secs, remaining_nanos)
-}
-
-/// Information about a slot.
-pub struct SlotInfo {
-	/// The slot number.
-	pub number: u64,
-	/// Current timestamp.
-	pub timestamp: u64,
-	/// The instant at which the slot ends.
-	pub ends_at: Instant,
-	/// The inherent data.
-	pub inherent_data: InherentData,
-	/// Slot duration.
-	pub duration: u64,
-}
-
-impl SlotInfo {
-	/// Yields the remaining duration in the slot.
-	pub fn remaining_duration(&self) -> Duration {
-		let now = Instant::now();
-		if now < self.ends_at {
-			self.ends_at.duration_since(now)
-		} else {
-			Duration::from_secs(0)
-		}
-	}
-}
-
-/// A stream that returns every time there is a new slot.
-pub struct Slots<SC> {
-	last_slot: u64,
-	slot_duration: u64,
-	inner_delay: Option<Delay>,
-	inherent_data_providers: InherentDataProviders,
-	_marker: PhantomData<SC>,
-}
-
-impl<SC> Slots<SC> {
-	/// Create a new `Slots` stream.
-	pub fn new(slot_duration: u64, inherent_data_providers: InherentDataProviders) -> Self {
-		Slots {
-			last_slot: 0,
-			slot_duration,
-			inner_delay: None,
-			inherent_data_providers,
-			_marker: PhantomData,
-		}
-	}
-}
-
-impl<SC: SlotCompatible> Stream for Slots<SC> {
-	type Item = SlotInfo;
-	type Error = Error;
-
-	fn poll(&mut self) -> Poll<Option<SlotInfo>, Self::Error> {
-		let slot_duration = self.slot_duration;
-		self.inner_delay = match self.inner_delay.take() {
-			None => {
-				// schedule wait.
-				let wait_until = match duration_now() {
-					None => return Ok(Async::Ready(None)),
-					Some(now) => Instant::now() + time_until_next(now, slot_duration),
-				};
-
-				Some(Delay::new(wait_until))
-			}
-			Some(d) => Some(d),
-		};
-
-		if let Some(ref mut inner_delay) = self.inner_delay {
-			try_ready!(inner_delay.poll().map_err(|e| Error::from(ErrorKind::FaultyTimer(e))));
-		}
-
-		// timeout has fired.
-
-		let inherent_data = self.inherent_data_providers.create_inherent_data()
-			.map_err(crate::inherent_to_common_error)?;
-		let (timestamp, slot_num) = SC::extract_timestamp_and_slot(&inherent_data)?;
-
-		// reschedule delay for next slot.
-		let ends_at = Instant::now() + time_until_next(Duration::from_secs(timestamp), slot_duration);
-		self.inner_delay = Some(Delay::new(ends_at));
-
-		// never yield the same slot twice.
-		if slot_num > self.last_slot {
-			self.last_slot = slot_num;
-
-			Ok(
-				Async::Ready(
-					Some(SlotInfo {
-						number: slot_num,
-						duration: self.slot_duration,
-						timestamp,
-						ends_at,
-						inherent_data,
-					})
-				)
-			)
-		} else {
-			// re-poll until we get a new slot.
-			self.poll()
-		}
-	}
-}

substrate/core/consensus/aura/src/lib.rs

@@ -25,7 +25,8 @@
 //!
 //! Blocks from future steps will be either deferred or rejected depending on how
 //! far in the future they are.
-#![deny(deprecated)]
+#![deny(warnings)]
+#![forbid(missing_docs, unsafe_code)]
 use std::{sync::Arc, time::Duration, thread, marker::PhantomData, hash::Hash, fmt::Debug};
 
 use parity_codec::{Encode, Decode};
@@ -34,10 +35,14 @@ use consensus_common::{self, Authorities, BlockImport, Environment, Proposer,
 };
 use consensus_common::well_known_cache_keys;
 use consensus_common::import_queue::{Verifier, BasicQueue, SharedBlockImport, SharedJustificationImport};
-use client::ChainHead;
-use client::block_builder::api::BlockBuilder as BlockBuilderApi;
-use client::blockchain::ProvideCache;
-use client::runtime_api::{ApiExt, Core as CoreApi};
+use client::{
+	ChainHead,
+	block_builder::api::BlockBuilder as BlockBuilderApi,
+	blockchain::ProvideCache,
+	runtime_api::{ApiExt, Core as CoreApi},
+	error::Result as CResult,
+	backend::AuxStore,
+};
 use aura_primitives::AURA_ENGINE_ID;
 use runtime_primitives::{generic, generic::BlockId, Justification};
 use runtime_primitives::traits::{
@@ -47,7 +52,7 @@ use primitives::Pair;
 use inherents::{InherentDataProviders, InherentData, RuntimeString};
 use authorities::AuthoritiesApi;
 
-use futures::{Stream, Future, IntoFuture, future};
+use futures::{Future, IntoFuture, future, stream::Stream};
 use tokio::timer::Timeout;
 use log::{warn, debug, info, trace};
 
@@ -57,9 +62,8 @@ use srml_aura::{
 };
 use substrate_telemetry::{telemetry, CONSENSUS_TRACE, CONSENSUS_DEBUG, CONSENSUS_WARN, CONSENSUS_INFO};
 
-use aura_slots::{CheckedHeader, SlotWorker, SlotInfo, SlotCompatible};
+use slots::{CheckedHeader, SlotWorker, SlotInfo, SlotCompatible};
 
-pub use aura_slots::SlotDuration;
 pub use aura_primitives::*;
 pub use consensus_common::SyncOracle;
 
@@ -70,6 +74,10 @@ type Signature<P> = <P as Pair>::Signature;
 /// handle to a gossip service or similar.
 ///
 /// Intended to be a lightweight handle such as an `Arc`.
+#[deprecated(
+	since = "1.0.1",
+	note = "This is dead code and will be removed in a future release",
+)]
 pub trait Network: Clone {
 	/// A stream of input messages for a topic.
 	type In: Stream<Item=Vec<u8>,Error=()>;
@@ -78,6 +86,25 @@ pub trait Network: Clone {
 	fn send_message(&self, slot: u64, message: Vec<u8>);
 }
 
+/// A slot duration. Create with `get_or_compute`.
+pub struct SlotDuration(slots::SlotDuration<u64>);
+
+impl SlotDuration {
+	/// Either fetch the slot duration from disk or compute it from the genesis
+	/// state.
+	pub fn get_or_compute<B: Block, C>(client: &C) -> CResult<Self>
+	where
+		C: AuxStore, C: ProvideRuntimeApi, C::Api: AuraApi<B>,
+	{
+		slots::SlotDuration::get_or_compute(client, |a, b| a.slot_duration(b)).map(Self)
+	}
+
+	/// Get the slot duration in milliseconds.
+	pub fn get(&self) -> u64 {
+		self.0.get()
+	}
+}
+
 /// Get slot author for given block along with authorities.
 fn slot_author<P: Pair>(slot_num: u64, authorities: &[AuthorityId<P>]) -> Option<&AuthorityId<P>> {
 	if authorities.is_empty() { return None }
@@ -153,6 +180,7 @@ impl<P, Hash> CompatibleDigestItem<P> for generic::DigestItem<Hash, P::Public, P
 	}
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 struct AuraSlotCompatible;
 
 impl SlotCompatible for AuraSlotCompatible {
@@ -203,8 +231,8 @@ pub fn start_aura_thread<B, C, E, I, P, SO, Error, OnExit>(
 		force_authoring,
 	};
 
-	aura_slots::start_slot_worker_thread::<_, _, _, _, AuraSlotCompatible, _>(
-		slot_duration,
+	slots::start_slot_worker_thread::<_, _, _, _, AuraSlotCompatible, u64, _>(
+		slot_duration.0,
 		client,
 		Arc::new(worker),
 		sync_oracle,
@@ -249,8 +277,8 @@ pub fn start_aura<B, C, E, I, P, SO, Error, OnExit>(
 		sync_oracle: sync_oracle.clone(),
 		force_authoring,
 	};
-	aura_slots::start_slot_worker::<_, _, _, _, AuraSlotCompatible, _>(
-		slot_duration,
+	slots::start_slot_worker::<_, _, _, _, _, AuraSlotCompatible, _>(
+		slot_duration.0,
 		client,
 		Arc::new(worker),
 		sync_oracle,
@@ -803,9 +831,9 @@ mod tests {
 	use client::BlockchainEvents;
 	use test_client;
 
-	type Error = ::client::error::Error;
+	type Error = client::error::Error;
 
-	type TestClient = ::client::Client<test_client::Backend, test_client::Executor, TestBlock, test_client::runtime::RuntimeApi>;
+	type TestClient = client::Client<test_client::Backend, test_client::Executor, TestBlock, test_client::runtime::RuntimeApi>;
 
 	struct DummyFactory(Arc<TestClient>);
 	struct DummyProposer(u64, Arc<TestClient>);