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

* #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<[_]>
2026-04-29 04:27:57 +00:00 · 2022-02-28 23:51:35 +02:00
parent 89b5dafc29
commit 4009148889
19 changed files with 1609 additions and 677 deletions
@@ -0,0 +1,221 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-2022 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 super::*;
+
+use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper, H256 as Hash};
+use std::iter::{empty, Empty};
+
+type TestChangeSet = (
+	Vec<(StorageKey, Option<StorageData>)>,
+	Vec<(StorageKey, Vec<(StorageKey, Option<StorageData>)>)>,
+);
+
+impl From<TestChangeSet> for StorageChangeSet {
+	fn from(changes: TestChangeSet) -> Self {
+		// warning hardcoded child trie wildcard to test upon
+		let child_filters = Some(
+			[(StorageKey(vec![4]), None), (StorageKey(vec![5]), None)]
+				.iter()
+				.cloned()
+				.collect(),
+		);
+		StorageChangeSet {
+			changes: From::from(changes.0),
+			child_changes: From::from(changes.1),
+			filter: None,
+			child_filters,
+		}
+	}
+}
+
+impl PartialEq for StorageChangeSet {
+	fn eq(&self, other: &Self) -> bool {
+		self.iter().eq(other.iter())
+	}
+}
+
+type Block = RawBlock<ExtrinsicWrapper<Hash>>;
+
+#[test]
+fn triggering_change_should_notify_wildcard_listeners() {
+	// given
+	let notifications = StorageNotifications::<Block>::new(None);
+	let child_filter = [(StorageKey(vec![4]), None)];
+	let mut recv =
+		futures::executor::block_on_stream(notifications.listen(None, Some(&child_filter[..])));
+
+	// when
+	let changeset = vec![(vec![2], Some(vec![3])), (vec![3], None)];
+	let c_changeset_1 = vec![(vec![5], Some(vec![4])), (vec![6], None)];
+	let c_changeset = vec![(vec![4], c_changeset_1)];
+	notifications.trigger(
+		&Hash::from_low_u64_be(1),
+		changeset.into_iter(),
+		c_changeset.into_iter().map(|(a, b)| (a, b.into_iter())),
+	);
+
+	// then
+	assert_eq!(
+		recv.next().map(StorageNotification::into_fields).unwrap(),
+		(
+			Hash::from_low_u64_be(1),
+			(
+				vec![
+					(StorageKey(vec![2]), Some(StorageData(vec![3]))),
+					(StorageKey(vec![3]), None),
+				],
+				vec![(
+					StorageKey(vec![4]),
+					vec![
+						(StorageKey(vec![5]), Some(StorageData(vec![4]))),
+						(StorageKey(vec![6]), None),
+					]
+				)]
+			)
+				.into()
+		)
+	);
+}
+
+#[test]
+fn should_only_notify_interested_listeners() {
+	// given
+	let notifications = StorageNotifications::<Block>::new(None);
+	let child_filter = [(StorageKey(vec![4]), Some(vec![StorageKey(vec![5])]))];
+	let mut recv1 = futures::executor::block_on_stream(
+		notifications.listen(Some(&[StorageKey(vec![1])]), None),
+	);
+	let mut recv2 = futures::executor::block_on_stream(
+		notifications.listen(Some(&[StorageKey(vec![2])]), None),
+	);
+	let mut recv3 =
+		futures::executor::block_on_stream(notifications.listen(Some(&[]), Some(&child_filter)));
+
+	// when
+	let changeset = vec![(vec![2], Some(vec![3])), (vec![1], None)];
+	let c_changeset_1 = vec![(vec![5], Some(vec![4])), (vec![6], None)];
+
+	let c_changeset = vec![(vec![4], c_changeset_1)];
+	notifications.trigger(
+		&Hash::from_low_u64_be(1),
+		changeset.into_iter(),
+		c_changeset.into_iter().map(|(a, b)| (a, b.into_iter())),
+	);
+
+	// then
+	assert_eq!(
+		recv1.next().map(StorageNotification::into_fields).unwrap(),
+		(Hash::from_low_u64_be(1), (vec![(StorageKey(vec![1]), None),], vec![]).into())
+	);
+	assert_eq!(
+		recv2.next().map(StorageNotification::into_fields).unwrap(),
+		(
+			Hash::from_low_u64_be(1),
+			(vec![(StorageKey(vec![2]), Some(StorageData(vec![3]))),], vec![]).into()
+		)
+	);
+	assert_eq!(
+		recv3.next().map(StorageNotification::into_fields).unwrap(),
+		(
+			Hash::from_low_u64_be(1),
+			(
+				vec![],
+				vec![(
+					StorageKey(vec![4]),
+					vec![(StorageKey(vec![5]), Some(StorageData(vec![4])))]
+				),]
+			)
+				.into()
+		)
+	);
+}
+
+#[test]
+fn should_cleanup_subscribers_if_dropped() {
+	// given
+	let notifications = StorageNotifications::<Block>::new(None);
+	{
+		let child_filter = [(StorageKey(vec![4]), Some(vec![StorageKey(vec![5])]))];
+		let _recv1 = futures::executor::block_on_stream(
+			notifications.listen(Some(&[StorageKey(vec![1])]), None),
+		);
+		let _recv2 = futures::executor::block_on_stream(
+			notifications.listen(Some(&[StorageKey(vec![2])]), None),
+		);
+		let _recv3 = futures::executor::block_on_stream(notifications.listen(None, None));
+		let _recv4 =
+			futures::executor::block_on_stream(notifications.listen(None, Some(&child_filter)));
+		assert_eq!(notifications.map_registry(|r| r.listeners.len()), 2);
+		assert_eq!(notifications.map_registry(|r| r.wildcard_listeners.len()), 2);
+		assert_eq!(notifications.map_registry(|r| r.child_listeners.len()), 1);
+	}
+
+	// when
+	let changeset = vec![(vec![2], Some(vec![3])), (vec![1], None)];
+	let c_changeset = empty::<(_, Empty<_>)>();
+	notifications.trigger(&Hash::from_low_u64_be(1), changeset.into_iter(), c_changeset);
+
+	// then
+	assert_eq!(notifications.map_registry(|r| r.listeners.len()), 0);
+	assert_eq!(notifications.map_registry(|r| r.wildcard_listeners.len()), 0);
+	assert_eq!(notifications.map_registry(|r| r.child_listeners.len()), 0);
+}
+
+#[test]
+fn should_cleanup_subscriber_if_stream_is_dropped() {
+	let notifications = StorageNotifications::<Block>::new(None);
+	let stream = notifications.listen(None, None);
+	assert_eq!(notifications.map_registry(|r| r.sinks.len()), 1);
+	std::mem::drop(stream);
+	assert_eq!(notifications.map_registry(|r| r.sinks.len()), 0);
+}
+
+#[test]
+fn should_not_send_empty_notifications() {
+	// given
+	let mut recv = {
+		let notifications = StorageNotifications::<Block>::new(None);
+		let recv = futures::executor::block_on_stream(notifications.listen(None, None));
+
+		// when
+		let changeset = vec![];
+		let c_changeset = empty::<(_, Empty<_>)>();
+		notifications.trigger(&Hash::from_low_u64_be(1), changeset.into_iter(), c_changeset);
+		recv
+	};
+
+	// then
+	assert_eq!(recv.next().map(StorageNotification::into_fields), None);
+}
+
+impl<B: BlockT> StorageNotifications<B> {
+	fn map_registry<MapF, Ret>(&self, map: MapF) -> Ret
+	where
+		MapF: FnOnce(&Registry) -> Ret,
+	{
+		self.0.map_registry_for_tests(map)
+	}
+}
+
+impl<H> StorageNotification<H> {
+	fn into_fields(self) -> (H, StorageChangeSet) {
+		let Self { block, changes } = self;
+		(block, changes)
+	}
+}