Hook RPC extrinsic import into propagation (#158)

* call `on_new_transactions` when we import

* fix trace

* pass correct bytes to network

* clean up

* cull before repropagating; repropagate on timer

* add a little tracing

substrate/substrate/network/src/protocol.rs

@@ -434,7 +434,7 @@ impl Protocol {
 			trace!(target: "sync", "{} Ignoring transactions while syncing", peer_id);
 			return;
 		}
-		trace!(target: "sync", "Received {} transactions from {}", peer_id, transactions.len());
+		trace!(target: "sync", "Received {} transactions from {}", transactions.len(), peer_id);
 		let mut peers = self.peers.write();
 		if let Some(ref mut peer) = peers.get_mut(&peer_id) {
 			for t in transactions {
@@ -445,12 +445,17 @@ impl Protocol {
 		}
 	}
 
-	/// Called when peer sends us new transactions
-	pub fn propagate_transactions(&self, io: &mut SyncIo, transactions: &[(ExtrinsicHash, Vec<u8>)]) {
+	/// Called when we propagate ready transactions to peers.
+	pub fn propagate_transactions(&self, io: &mut SyncIo) {
+		debug!(target: "sync", "Propagating transactions");
+
 		// Accept transactions only when fully synced
 		if self.sync.read().status().state != SyncState::Idle {
 			return;
 		}
+
+		let transactions = self.transaction_pool.transactions();
+
 		let mut peers = self.peers.write();
 		for (peer_id, ref mut peer) in peers.iter_mut() {
 			let to_send: Vec<_> = transactions.iter().filter_map(|&(hash, ref t)|

substrate/substrate/network/src/service.rs

@@ -17,6 +17,7 @@
 use std::sync::Arc;
 use std::collections::{BTreeMap};
 use std::io;
+use std::time::Duration;
 use futures::sync::{oneshot, mpsc};
 use network::{NetworkProtocolHandler, NetworkContext, HostInfo, PeerId, ProtocolId,
 NetworkConfiguration , NonReservedPeerMode, ErrorKind};
@@ -41,6 +42,12 @@ pub type StatementStream = mpsc::UnboundedReceiver<Statement>;
 /// Type that represents bft messages stream.
 pub type BftMessageStream = mpsc::UnboundedReceiver<LocalizedBftMessage>;
 
+const TICK_TOKEN: TimerToken = 0;
+const TICK_TIMEOUT: Duration = Duration::from_millis(1000);
+
+const PROPAGATE_TOKEN: TimerToken = 1;
+const PROPAGATE_TIMEOUT: Duration = Duration::from_millis(5000);
+
 bitflags! {
 	/// Node roles bitmask.
 	pub struct Role: u32 {
@@ -162,9 +169,9 @@ impl Service {
 	}
 
 	/// Called when new transactons are imported by the client.
-	pub fn on_new_transactions(&self, transactions: &[(ExtrinsicHash, Vec<u8>)]) {
+	pub fn trigger_repropagate(&self) {
 		self.network.with_context(DOT_PROTOCOL_ID, |context| {
-			self.handler.protocol.propagate_transactions(&mut NetSyncIo::new(context), transactions);
+			self.handler.protocol.propagate_transactions(&mut NetSyncIo::new(context));
 		});
 	}
 
@@ -268,7 +275,11 @@ impl ConsensusService for Service {
 
 impl NetworkProtocolHandler for ProtocolHandler {
 	fn initialize(&self, io: &NetworkContext, _host_info: &HostInfo) {
-		io.register_timer(0, ::std::time::Duration::from_millis(1000)).expect("Error registering sync timer");
+		io.register_timer(TICK_TOKEN, TICK_TIMEOUT)
+			.expect("Error registering sync timer");
+
+		io.register_timer(PROPAGATE_TOKEN, PROPAGATE_TIMEOUT)
+			.expect("Error registering transaction propagation timer");
 	}
 
 	fn read(&self, io: &NetworkContext, peer: &PeerId, _packet_id: u8, data: &[u8]) {
@@ -283,8 +294,12 @@ impl NetworkProtocolHandler for ProtocolHandler {
 		self.protocol.on_peer_disconnected(&mut NetSyncIo::new(io), *peer);
 	}
 
-	fn timeout(&self, io: &NetworkContext, _timer: TimerToken) {
-		self.protocol.tick(&mut NetSyncIo::new(io));
+	fn timeout(&self, io: &NetworkContext, timer: TimerToken) {
+		match timer {
+			TICK_TOKEN => self.protocol.tick(&mut NetSyncIo::new(io)),
+			PROPAGATE_TOKEN => self.protocol.propagate_transactions(&mut NetSyncIo::new(io)),
+			_ => {}
+		}
 	}
 }
 

substrate/substrate/rpc/src/author/mod.rs

@@ -16,8 +16,6 @@
 
 //! Substrate block-author/full-node API.
 
-use std::sync::Arc;
-use parking_lot::Mutex;
 use primitives::block::Extrinsic;
 
 pub mod error;
@@ -35,15 +33,3 @@ build_rpc_trait! {
 		fn submit_extrinsic(&self, Extrinsic) -> Result<()>;
 	}
 }
-
-/// Variant of the AuthorApi that doesn't need to be Sync + Send + 'static.
-pub trait AsyncAuthorApi: Send + 'static {
-	/// Submit extrinsic for inclusion in block.
-	fn submit_extrinsic(&mut self, Extrinsic) -> Result<()>;
-}
-
-impl<T: AsyncAuthorApi> AuthorApi for Arc<Mutex<T>> {
-	fn submit_extrinsic(&self, xt: Extrinsic) -> Result<()> {
-		self.as_ref().lock().submit_extrinsic(xt)
-	}
-}

substrate/substrate/rpc/src/author/tests.rs

@@ -14,20 +14,24 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
-use primitives::block;
 use super::*;
 use super::error::*;
 
+use std::sync::Arc;
+use parking_lot::Mutex;
+use primitives::block;
+
 #[derive(Default)]
 struct DummyTxPool {
 	submitted: Vec<block::Extrinsic>,
 }
 
-impl AsyncAuthorApi for DummyTxPool {
+impl AuthorApi for Arc<Mutex<DummyTxPool>> {
 	/// Submit extrinsic for inclusion in block.
-	fn submit_extrinsic(&mut self, xt: Extrinsic) -> Result<()> {
-		if self.submitted.len() < 1 {
-			self.submitted.push(xt);
+	fn submit_extrinsic(&self, xt: Extrinsic) -> Result<()> {
+		let mut s = self.lock();
+		if s.submitted.len() < 1 {
+			s.submitted.push(xt);
 			Ok(())
 		} else {
 			Err(ErrorKind::PoolError.into())