Make everything compile again

cumulus/collator/src/lib.rs

@@ -16,7 +16,7 @@
 
 //! Cumulus Collator implementation for Substrate.
 
-use runtime_primitives::{traits::Block as BlockT, ed25519};
+use runtime_primitives::traits::Block as BlockT;
 use consensus_common::{Environment, Proposer};
 use inherents::InherentDataProviders;
 
@@ -24,15 +24,24 @@ use polkadot_collator::{
 	InvalidHead, ParachainContext, BuildParachainContext, Network as CollatorNetwork, VersionInfo,
 };
 use polkadot_primitives::{
-	Hash, parachain::{self, BlockData, Message, Id as ParaId, Extrinsic, Status as ParachainStatus}
+	Hash,
+	parachain::{
+		self, BlockData, Message, Id as ParaId, OutgoingMessages, Status as ParachainStatus,
+		CollatorPair,
+	}
 };
 
 use codec::{Decode, Encode};
+
 use log::error;
+
+use futures03::TryFutureExt;
 use futures::{Future, future::IntoFuture};
 
 use std::{sync::Arc, marker::PhantomData, time::Duration};
 
+use parking_lot::Mutex;
+
 /// The head data of the parachain, stored in the relay chain.
 #[derive(Decode, Encode, Debug)]
 struct HeadData<Block: BlockT> {
@@ -41,7 +50,7 @@ struct HeadData<Block: BlockT> {
 
 /// The implementation of the Cumulus `Collator`.
 pub struct Collator<Block, PF> {
-	proposer_factory: Arc<PF>,
+	proposer_factory: Arc<Mutex<PF>>,
 	_phantom: PhantomData<Block>,
 	inherent_data_providers: InherentDataProviders,
 	collator_network: Arc<dyn CollatorNetwork>,
@@ -50,12 +59,12 @@ pub struct Collator<Block, PF> {
 impl<Block: BlockT, PF: Environment<Block>> Collator<Block, PF> {
 	/// Create a new instance.
 	fn new(
-		proposer_factory: Arc<PF>,
+		proposer_factory: PF,
 		inherent_data_providers: InherentDataProviders,
 		collator_network: Arc<dyn CollatorNetwork>,
 	) -> Self {
 		Self {
-			proposer_factory,
+			proposer_factory: Arc::new(Mutex::new(proposer_factory)),
 			inherent_data_providers,
 			_phantom: PhantomData,
 			collator_network,
@@ -76,15 +85,18 @@ impl<Block, PF> Clone for Collator<Block, PF> {
 
 impl<Block, PF> ParachainContext for Collator<Block, PF> where
 	Block: BlockT,
-	PF: Environment<Block> + 'static,
+	PF: Environment<Block> + 'static + Send + Sync,
 	PF::Error: std::fmt::Debug,
+	PF::Proposer: Send + Sync,
+	<PF::Proposer as Proposer<Block>>::Create: Unpin + Send + Sync,
 {
 	type ProduceCandidate = Box<
-		dyn Future<Item=(BlockData, parachain::HeadData, Extrinsic), Error=InvalidHead>
+		dyn Future<Item=(BlockData, parachain::HeadData, OutgoingMessages), Error=InvalidHead>
+			+ Send + Sync
 	>;
 
 	fn produce_candidate<I: IntoIterator<Item=(ParaId, Message)>>(
-		&self,
+		&mut self,
 		_relay_chain_parent: Hash,
 		status: ParachainStatus,
 		_: I,
@@ -93,13 +105,16 @@ impl<Block, PF> ParachainContext for Collator<Block, PF> where
 		let inherent_providers = self.inherent_data_providers.clone();
 
 		let res = HeadData::<Block>::decode(&mut &status.head_data.0[..])
-			.ok_or_else(|| InvalidHead).into_future()
+			.map_err(|_| InvalidHead)
+			.into_future()
 			.and_then(move |last_head|
-				factory.init(&last_head.header).map_err(|e| {
-					//TODO: Do we want to return the real error?
-					error!("Could not create proposer: {:?}", e);
-					InvalidHead
-				})
+				factory.lock()
+					.init(&last_head.header)
+					.map_err(|e| {
+						//TODO: Do we want to return the real error?
+						error!("Could not create proposer: {:?}", e);
+						InvalidHead
+					})
 			)
 			.and_then(move |proposer|
 				inherent_providers.create_inherent_data()
@@ -109,25 +124,25 @@ impl<Block, PF> ParachainContext for Collator<Block, PF> where
 						InvalidHead
 					})
 			)
-			.and_then(|(proposer, inherent_data)| {
+			.and_then(|(mut proposer, inherent_data)| {
 				proposer.propose(
 					inherent_data,
 					Default::default(),
 					//TODO: Fix this.
 					Duration::from_secs(6),
 				)
-				.into_future()
 				.map_err(|e| {
 					error!("Proposing failed: {:?}", e);
 					InvalidHead
 				})
+				.compat()
 			})
 			.map(|b| {
 				let block_data = BlockData(b.encode());
 				let head_data = HeadData::<Block> { header: b.deconstruct().0 };
-				let extrinsic = Extrinsic { outgoing_messages: Vec::new() };
+				let messages = OutgoingMessages { outgoing_messages: Vec::new() };
 
-				(block_data, parachain::HeadData(head_data.encode()), extrinsic)
+				(block_data, parachain::HeadData(head_data.encode()), messages)
 			});
 
 		Box::new(res)
@@ -137,13 +152,13 @@ impl<Block, PF> ParachainContext for Collator<Block, PF> where
 /// Implements `BuildParachainContext` to build a collator instance.
 struct CollatorBuilder<Block, PF> {
 	inherent_data_providers: InherentDataProviders,
-	proposer_factory: Arc<PF>,
+	proposer_factory: PF,
 	_phantom: PhantomData<Block>,
 }
 
 impl<Block, PF> CollatorBuilder<Block, PF> {
 	/// Create a new instance of self.
-	fn new(proposer_factory: Arc<PF>, inherent_data_providers: InherentDataProviders) -> Self {
+	fn new(proposer_factory: PF, inherent_data_providers: InherentDataProviders) -> Self {
 		Self {
 			inherent_data_providers,
 			proposer_factory,
@@ -154,8 +169,10 @@ impl<Block, PF> CollatorBuilder<Block, PF> {
 
 impl<Block, PF> BuildParachainContext for CollatorBuilder<Block, PF> where
 	Block: BlockT,
-	PF: Environment<Block> + 'static,
+	PF: Environment<Block> + 'static + Send + Sync,
 	PF::Error: std::fmt::Debug,
+	PF::Proposer: Send + Sync,
+	<PF::Proposer as Proposer<Block>>::Create: Unpin + Send + Sync,
 {
 	type ParachainContext = Collator<Block, PF>;
 
@@ -166,19 +183,22 @@ impl<Block, PF> BuildParachainContext for CollatorBuilder<Block, PF> where
 
 /// Run a collator with the given proposer factory.
 pub fn run_collator<Block, PF, E, I>(
-	proposer_factory: Arc<PF>,
+	proposer_factory: PF,
 	inherent_data_providers: InherentDataProviders,
 	para_id: ParaId,
 	exit: E,
-	key: Arc<ed25519::Pair>,
-	args: I,
+	key: Arc<CollatorPair>,
 	version: VersionInfo,
 ) -> Result<(), cli::error::Error>
 where
 	Block: BlockT,
-	PF: Environment<Block> + 'static + Send,
-	PF::Error: std::fmt::Debug
+	PF: Environment<Block> + 'static + Send + Sync,
+	PF::Error: std::fmt::Debug,
+	PF::Proposer: Send + Sync,
+	<PF::Proposer as Proposer<Block>>::Create: Unpin + Send + Sync,
+	E: IntoFuture<Item=(), Error=()>,
+	E::Future: Send + Clone + Sync + 'static,
 {
 	let builder = CollatorBuilder::new(proposer_factory, inherent_data_providers);
-	polkadot_collator::run_collator(builder, para_id, exit, key, args, version)
-}
+	polkadot_collator::run_collator(builder, para_id, exit, key, version)
+}