Add Subscription RPC for Grandpa Finality (#5732)

* Rough skeleton for what I think the RPC should look like

* Create channel for sending justifications

Sends finalized header and justification from Grandpa to the
client. This lays the groundwork for hooking into the RPC module.

* WIP: Add subscribers for justifications to Grandpa

Adds the Sender end of a channel into Grandpa, through which notifications
about block finality events can be sent.

* WIP: Add a struct for managing subscriptions

Slightly different approach from the last commit, but same
basic idea. Still a rough sketch, very much doesn't compile yet.

* Make naming more clear and lock data in Arc

* Rough idea of what RPC would look like

* Remove code from previous approach

* Missed some things

* Update client/rpc-api/src/chain/mod.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Update client/rpc-api/src/chain/mod.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Split justification subscription into sender and receiver halves

* Replace RwLock with a Mutex

* Add sample usage from the Service's point of view

* Remove code that referred to "chain_" RPC

* Use the Justification sender/receivers from Grandpa LinkHalf

* Add some PubSub boilerplate

* Add guiding comments

* TMP: comment out to fix compilation

* Return MetaIoHandler from PubSubHandler in create_full

* Uncomment pubsub methods in rpc handler (fails to build)

* node/rpc: make Metadata concrete in create_full to fix compilation

* node: pass in SubscriptionManger to grandpa rpc handler

* grandpa-rpc: use SubscriptionManger to add subscriber

* grandpa-rpc: attempt at setting up the justification stream (fails to build)

* grandpa-rpc: fix compilation of connecting stream to sink

* grandpa-rpc: implement unsubscribe

* grandpa-rpc: update older tests

* grandpa-rpc: add full prefix to avoid confusing rust-analyzer

* grandpa-rpc: add test for pubsub not available

* grandpa-rpc: tidy up leftover code

* grandpa-rpc: add test for sub and unsub of justifications

* grandpa-rpc: minor stylistic changes

* grandpa-rpc: split unit test

* grandpa-rpc: minor stylistic changes in test

* grandpa-rpc: skip returning future when cancelling

* grandpa-rpc: reuse testing executor from sc-rpc

* grandpa-rpc: don't need to use PubSubHandler in tests

* node-rpc: use MetaIoHandler rather than PubSubHandler

* grandpa: log if getting header failed

* grandpa: move justification channel creation into factory function

* grandpa: make the justification sender optional

* grandpa: fix compilation warnings

* grandpa: move justification notification types to new file

* grandpa-rpc: move JustificationNotification to grandpa-rpc

* grandpa-rpc: move JustificationNotification to its own file

* grandpa: rename justification channel pairs

* grandpa: rename notifier types

* grandpa: pass justification as GrandpaJustification to the rpc module

* Move Metadata to sc-rpc-api

* grandpa-rpc: remove unsed error code

* grandpa: fix bug for checking if channel is closed before sendind

* grandpa-rpc: unit test for sending justifications

* grandpa-rpc: update comments for the pubsub test

* grandpa-rpc: update pubsub tests with more steps

* grandpa-rpc: fix pubsub test

* grandpa-rpc: minor indendation

* grandpa-rpc: decode instead of encode in test

* grandpa: fix review comments

* grandpa: remove unused serde dependency

Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com>
Co-authored-by: Jon Häggblad <jon.haggblad@gmail.com>
Co-authored-by: Tomasz Drwięga <tomasz@parity.io>

substrate/client/finality-grandpa/src/notification.rs

@@ -0,0 +1,102 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program 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.
+
+// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
+
+use std::sync::Arc;
+use parking_lot::Mutex;
+
+use sp_runtime::traits::Block as BlockT;
+use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedSender, TracingUnboundedReceiver};
+
+use crate::justification::GrandpaJustification;
+
+// Stream of justifications returned when subscribing.
+type JustificationStream<Block> = TracingUnboundedReceiver<GrandpaJustification<Block>>;
+
+// Sending endpoint for notifying about justifications.
+type JustificationSender<Block> = TracingUnboundedSender<GrandpaJustification<Block>>;
+
+// Collection of channel sending endpoints shared with the receiver side so they can register
+// themselves.
+type SharedJustificationSenders<Block> = Arc<Mutex<Vec<JustificationSender<Block>>>>;
+
+/// The sending half of the Grandpa justification channel(s).
+///
+/// Used to send notifications about justifications generated
+/// at the end of a Grandpa round.
+#[derive(Clone)]
+pub struct GrandpaJustificationSender<Block: BlockT> {
+	subscribers: SharedJustificationSenders<Block>
+}
+
+impl<Block: BlockT> GrandpaJustificationSender<Block> {
+	/// The `subscribers` should be shared with a corresponding
+	/// `GrandpaJustificationStream`.
+	fn new(subscribers: SharedJustificationSenders<Block>) -> Self {
+		Self {
+			subscribers,
+		}
+	}
+
+	/// Send out a notification to all subscribers that a new justification
+	/// is available for a block.
+	pub fn notify(&self, notification: GrandpaJustification<Block>) -> Result<(), ()> {
+		self.subscribers.lock().retain(|n| {
+			!n.is_closed() && n.unbounded_send(notification.clone()).is_ok()
+		});
+		Ok(())
+	}
+}
+
+/// The receiving half of the Grandpa justification channel.
+///
+/// Used to receive notifications about justifications generated
+/// at the end of a Grandpa round.
+/// The `GrandpaJustificationStream` entity stores the `SharedJustificationSenders`
+/// so it can be used to add more subscriptions.
+#[derive(Clone)]
+pub struct GrandpaJustificationStream<Block: BlockT> {
+	subscribers: SharedJustificationSenders<Block>
+}
+
+impl<Block: BlockT> GrandpaJustificationStream<Block> {
+	/// Creates a new pair of receiver and sender of justification notifications.
+	pub fn channel() -> (GrandpaJustificationSender<Block>, Self) {
+		let subscribers = Arc::new(Mutex::new(vec![]));
+		let receiver = GrandpaJustificationStream::new(subscribers.clone());
+		let sender = GrandpaJustificationSender::new(subscribers.clone());
+		(sender, receiver)
+	}
+
+	/// Create a new receiver of justification notifications.
+	///
+	/// The `subscribers` should be shared with a corresponding
+	/// `GrandpaJustificationSender`.
+	fn new(subscribers: SharedJustificationSenders<Block>) -> Self {
+		Self {
+			subscribers,
+		}
+	}
+
+	/// Subscribe to a channel through which justifications are sent
+	/// at the end of each Grandpa voting round.
+	pub fn subscribe(&self) -> JustificationStream<Block> {
+		let (sender, receiver) = tracing_unbounded("mpsc_justification_notification_stream");
+		self.subscribers.lock().push(sender);
+		receiver
+	}
+}