pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-27 05:47:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

#10576: generic utility to unsubscribe from broadcast upon drop of the rx-side. (#10708)

Browse Source 
* #10576: refactor `sc-utils::notification` and `sc-client-api::notifications`, so that they use common subscribe/unsubscribe routines

* Add some docs. Reorganise `sc-utils::notification`

* `sc-clent-api::notifications` and `sc-utils::notification` — ensure the SubscriptionGuard is dropped before the Rx-channel

* `sc-utils::pubsub::SubscriptionGuard` make it a bit more ergonomic.

Let the `Rx` to be put inside of the `SubscriptionGuard`, so that the latter shall guarantee the order:
- first unsubscribe;
- then drop the `Rx`.

* Being less zealous with splitting the modules into little pieces

* rework pubsub: the concrete usage should only define a good registry type

* sc-client-api::notifications: make it comply with the reworked pubsub

* cargo fmt

* make sc-client-api tests work

* Address the review notes

* cargo fmt

* Describe the behaviour of pubsub registry

* Doc-comments for module `sc-utils::pubsub`

* Fix: it used to send notifications regardless of the filter setup during subscription

* `sc-client-api::StorageNotifications` the API does not have to require mut-self-reference.

As a result `sc-service::Client` does not have to wrap its `storage_notifications` into a Mutex.

* cargo fmt

* Several changes addressing the notes by @bckhr.

- Remove the `impl Default for StorageNotifications<Block>`;
- no need for groupping the `remove_from` and `listen_from` into a separate `helpers` module;
- remove unnecessary import `use registry::SubscribeOp`.

* Add a doc-comment to the `sc-client::notifications::SubscribeOp`

* As per @bkchr note on the unproven assertion: behave gracefully upon receiving a duplicate subscription-ID.

* sc-utils::pubsub: log when a registry yields an ID that does point to an existing sink

* `sc-utils::notifications`: payload materialized lazily

* Update Cargo.lock (after adding `log` as a dependency to the `sc-utils`)

* `sc-client-api::notifications`: introduce a struct (instead of a type def) for the notification message

* Get rid of `sc-utils::pubsub::Channel` trait (instead just use the `sc-utils::mpsc`)

* The SubsID is no more generic: the fact it is a `Copy` is known — no need to pass it by ref

* sc-utils::pubsub internals do not have to be generic over the channel type

* Rename Hub::dispatch into Hub::send

* That method was unnecessary (`SubscriberSink::render_notification`)

* cargo fmt

* No need for a separate UnsubscribeGuard type

* Ditch the type-def of SubsID in the sc-utils::pubsub, instead — just use the crate::id_sequence::SeqID

* Return the <Registry as Dispatch>::Ret when sending an item

* Make the `Hub<M, R>::lock_registry(...)` method more ergonomic

* cargo doc links

* cargo doc links

* Use a simpler name for the type

* cargo doc links

* Derive `Default` rather than implement it

* Derive `Default` rather than implement it

* Remove an unnecessary usage of type_name

* Define a more cautious order between sinks.remove->registry.unsubscribe and registry.subscribe->sinks.insert

* Hub: lock_registry_for_tests->map_registry_for_tests — a safer choice for a public API

* Replace Mutex over the shared Registry with a ReentrableMutex+RefCell

* sc-utils::pubsub: add tests for a panicking registry

* Add the missing copyright headers

* Arc<Vec<_>> -> Arc<[_]>
This commit is contained in:
Roman Gafiyatullin
2022-02-28 23:51:35 +02:00
committed by GitHub
parent 89b5dafc29
commit 4009148889
19 changed files with 1609 additions and 677 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/utils/src/notification.rs
+61 -90
View File
@@ -26,15 +26,19 @@
//!
//! See [`sc-service::builder::RpcExtensionBuilder`] for more details.
use std::{marker::PhantomData, sync::Arc};
use futures::stream::{FusedStream, Stream};
use std::{
pin::Pin,
task::{Context, Poll},
};
use crate::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use crate::pubsub::{Hub, Receiver};
use parking_lot::Mutex;
mod registry;
use registry::Registry;
/// Collection of channel sending endpoints shared with the receiver side
/// so they can register themselves.
type SharedSenders<Payload> = Arc<Mutex<Vec<TracingUnboundedSender<Payload>>>>;
#[cfg(test)]
mod tests;
/// Trait used to define the "tracing key" string used to tag
/// and identify the mpsc channels.
@@ -44,108 +48,75 @@ pub trait TracingKeyStr {
const TRACING_KEY: &'static str;
}
/// The sending half of the notifications channel(s).
/// The receiving half of the notifications channel.
///
/// Used to send notifications from the BEEFY gadget side.
/// The [`NotificationStream`] entity stores the [`Hub`] so it can be
/// used to add more subscriptions.
#[derive(Clone)]
pub struct NotificationSender<Payload: Clone> {
subscribers: SharedSenders<Payload>,
pub struct NotificationStream<Payload, TK: TracingKeyStr> {
hub: Hub<Payload, Registry>,
_pd: std::marker::PhantomData<TK>,
}
impl<Payload: Clone> NotificationSender<Payload> {
/// The `subscribers` should be shared with a corresponding `NotificationStream`.
fn new(subscribers: SharedSenders<Payload>) -> Self {
Self { subscribers }
/// The receiving half of the notifications channel(s).
#[derive(Debug)]
pub struct NotificationReceiver<Payload> {
receiver: Receiver<Payload, Registry>,
}
/// The sending half of the notifications channel(s).
pub struct NotificationSender<Payload> {
hub: Hub<Payload, Registry>,
}
impl<Payload, TK: TracingKeyStr> NotificationStream<Payload, TK> {
/// Creates a new pair of receiver and sender of `Payload` notifications.
pub fn channel() -> (NotificationSender<Payload>, Self) {
let hub = Hub::new(TK::TRACING_KEY);
let sender = NotificationSender { hub: hub.clone() };
let receiver = NotificationStream { hub, _pd: Default::default() };
(sender, receiver)
}
/// Subscribe to a channel through which the generic payload can be received.
pub fn subscribe(&self) -> NotificationReceiver<Payload> {
let receiver = self.hub.subscribe(());
NotificationReceiver { receiver }
}
}
impl<Payload> NotificationSender<Payload> {
/// Send out a notification to all subscribers that a new payload is available for a
/// block.
pub fn notify<Error>(
&self,
payload: impl FnOnce() -> Result<Payload, Error>,
) -> Result<(), Error> {
let mut subscribers = self.subscribers.lock();
// do an initial prune on closed subscriptions
subscribers.retain(|n| !n.is_closed());
if !subscribers.is_empty() {
let payload = payload()?;
subscribers.retain(|n| n.unbounded_send(payload.clone()).is_ok());
}
Ok(())
) -> Result<(), Error>
where
Payload: Clone,
{
self.hub.send(payload)
}
}
/// The receiving half of the notifications channel.
///
/// The `NotificationStream` entity stores the `SharedSenders` so it can be
/// used to add more subscriptions.
#[derive(Clone)]
pub struct NotificationStream<Payload: Clone, TK: TracingKeyStr> {
subscribers: SharedSenders<Payload>,
_trace_key: PhantomData<TK>,
}
impl<Payload: Clone, TK: TracingKeyStr> NotificationStream<Payload, TK> {
/// Creates a new pair of receiver and sender of `Payload` notifications.
pub fn channel() -> (NotificationSender<Payload>, Self) {
let subscribers = Arc::new(Mutex::new(vec![]));
let receiver = NotificationStream::new(subscribers.clone());
let sender = NotificationSender::new(subscribers);
(sender, receiver)
}
/// Create a new receiver of `Payload` notifications.
///
/// The `subscribers` should be shared with a corresponding `NotificationSender`.
fn new(subscribers: SharedSenders<Payload>) -> Self {
Self { subscribers, _trace_key: PhantomData }
}
/// Subscribe to a channel through which the generic payload can be received.
pub fn subscribe(&self) -> TracingUnboundedReceiver<Payload> {
let (sender, receiver) = tracing_unbounded(TK::TRACING_KEY);
self.subscribers.lock().push(sender);
receiver
impl<Payload> Clone for NotificationSender<Payload> {
fn clone(&self) -> Self {
Self { hub: self.hub.clone() }
}
}
#[cfg(test)]
mod tests {
use super::*;
use futures::StreamExt;
impl<Payload> Unpin for NotificationReceiver<Payload> {}
#[derive(Clone)]
pub struct DummyTracingKey;
impl TracingKeyStr for DummyTracingKey {
const TRACING_KEY: &'static str = "test_notification_stream";
}
impl<Payload> Stream for NotificationReceiver<Payload> {
type Item = Payload;
type StringStream = NotificationStream<String, DummyTracingKey>;
#[test]
fn notification_channel_simple() {
let (sender, stream) = StringStream::channel();
let test_payload = String::from("test payload");
let closure_payload = test_payload.clone();
// Create a future to receive a single notification
// from the stream and verify its payload.
let future = stream.subscribe().take(1).for_each(move |payload| {
let test_payload = closure_payload.clone();
async move {
assert_eq!(payload, test_payload);
}
});
// Send notification.
let r: std::result::Result<(), ()> = sender.notify(|| Ok(test_payload));
r.unwrap();
// Run receiver future.
tokio_test::block_on(future);
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Payload>> {
Pin::new(&mut self.get_mut().receiver).poll_next(cx)
}
}
impl<Payload> FusedStream for NotificationReceiver<Payload> {
fn is_terminated(&self) -> bool {
self.receiver.is_terminated()
}
}