rpc: backpressured RPC server (bump jsonrpsee 0.20) (#1313)

This is a rather big change in jsonrpsee, the major things in this bump are: - Server backpressure (the subscription impls are modified to deal with that) - Allow custom error types / return types (remove jsonrpsee::core::Error and jsonrpee::core::CallError) - Bug fixes (graceful shutdown in particular not used by substrate anyway) - Less dependencies for the clients in particular - Return type requires Clone in method call responses - Moved to tokio channels - Async subscription API (not used in this PR) Major changes in this PR: - The subscriptions are now bounded and if subscription can't keep up with the server it is dropped - CLI: add parameter to configure the jsonrpc server bounded message buffer (default is 64) - Add our own subscription helper to deal with the unbounded streams in substrate The most important things in this PR to review is the added helpers functions in `substrate/client/rpc/src/utils.rs` and the rest is pretty much chore. Regarding the "bounded buffer limit" it may cause the server to handle the JSON-RPC calls slower than before. The message size limit is bounded by "--rpc-response-size" thus "by default 10MB * 64 = 640MB" but the subscription message size is not covered by this limit and could be capped as well. Hopefully the last release prior to 1.0, sorry in advance for a big PR Previous attempt: https://github.com/paritytech/substrate/pull/13992 Resolves https://github.com/paritytech/polkadot-sdk/issues/748, resolves https://github.com/paritytech/polkadot-sdk/issues/627
2026-06-12 21:41:12 +00:00 · 2024-01-23 09:55:13 +01:00
parent 76c37c930b
commit e16ef0861f
117 changed files with 1245 additions and 1090 deletions
@@ -22,17 +22,12 @@
 mod tests;

 use futures::channel::oneshot;
-use jsonrpsee::{
-	core::{async_trait, error::Error as JsonRpseeError, JsonValue, RpcResult},
-	types::error::{CallError, ErrorCode, ErrorObject},
-};
+use jsonrpsee::core::{async_trait, JsonValue};
 use sc_rpc_api::DenyUnsafe;
 use sc_tracing::logging;
 use sc_utils::mpsc::TracingUnboundedSender;
 use sp_runtime::traits::{self, Header as HeaderT};

-use self::error::Result;
-
 pub use self::helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo};
 pub use sc_rpc_api::system::*;

@@ -57,9 +52,9 @@ pub enum Request<B: traits::Block> {
 	/// Must return the state of the network.
 	NetworkState(oneshot::Sender<serde_json::Value>),
 	/// Must return any potential parse error.
-	NetworkAddReservedPeer(String, oneshot::Sender<Result<()>>),
+	NetworkAddReservedPeer(String, oneshot::Sender<error::Result<()>>),
 	/// Must return any potential parse error.
-	NetworkRemoveReservedPeer(String, oneshot::Sender<Result<()>>),
+	NetworkRemoveReservedPeer(String, oneshot::Sender<error::Result<()>>),
 	/// Must return the list of reserved peers
 	NetworkReservedPeers(oneshot::Sender<Vec<String>>),
 	/// Must return the node role.
@@ -84,121 +79,109 @@ impl<B: traits::Block> System<B> {

 #[async_trait]
 impl<B: traits::Block> SystemApiServer<B::Hash, <B::Header as HeaderT>::Number> for System<B> {
-	fn system_name(&self) -> RpcResult<String> {
+	fn system_name(&self) -> Result<String, Error> {
 		Ok(self.info.impl_name.clone())
 	}

-	fn system_version(&self) -> RpcResult<String> {
+	fn system_version(&self) -> Result<String, Error> {
 		Ok(self.info.impl_version.clone())
 	}

-	fn system_chain(&self) -> RpcResult<String> {
+	fn system_chain(&self) -> Result<String, Error> {
 		Ok(self.info.chain_name.clone())
 	}

-	fn system_type(&self) -> RpcResult<sc_chain_spec::ChainType> {
+	fn system_type(&self) -> Result<sc_chain_spec::ChainType, Error> {
 		Ok(self.info.chain_type.clone())
 	}

-	fn system_properties(&self) -> RpcResult<sc_chain_spec::Properties> {
+	fn system_properties(&self) -> Result<sc_chain_spec::Properties, Error> {
 		Ok(self.info.properties.clone())
 	}

-	async fn system_health(&self) -> RpcResult<Health> {
+	async fn system_health(&self) -> Result<Health, Error> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::Health(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

-	async fn system_local_peer_id(&self) -> RpcResult<String> {
+	async fn system_local_peer_id(&self) -> Result<String, Error> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::LocalPeerId(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

-	async fn system_local_listen_addresses(&self) -> RpcResult<Vec<String>> {
+	async fn system_local_listen_addresses(&self) -> Result<Vec<String>, Error> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::LocalListenAddresses(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

 	async fn system_peers(
 		&self,
-	) -> RpcResult<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>> {
+	) -> Result<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>, Error> {
 		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::Peers(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

-	async fn system_network_state(&self) -> RpcResult<JsonValue> {
+	async fn system_network_state(&self) -> Result<JsonValue, Error> {
 		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkState(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

-	async fn system_add_reserved_peer(&self, peer: String) -> RpcResult<()> {
+	async fn system_add_reserved_peer(&self, peer: String) -> Result<(), Error> {
 		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkAddReservedPeer(peer, tx));
 		match rx.await {
 			Ok(Ok(())) => Ok(()),
-			Ok(Err(e)) => Err(JsonRpseeError::from(e)),
-			Err(e) => Err(JsonRpseeError::to_call_error(e)),
+			Ok(Err(e)) => Err(e),
+			Err(e) => Err(Error::Internal(e.to_string())),
 		}
 	}

-	async fn system_remove_reserved_peer(&self, peer: String) -> RpcResult<()> {
+	async fn system_remove_reserved_peer(&self, peer: String) -> Result<(), Error> {
 		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkRemoveReservedPeer(peer, tx));
 		match rx.await {
 			Ok(Ok(())) => Ok(()),
-			Ok(Err(e)) => Err(JsonRpseeError::from(e)),
-			Err(e) => Err(JsonRpseeError::to_call_error(e)),
+			Ok(Err(e)) => Err(e),
+			Err(e) => Err(Error::Internal(e.to_string())),
 		}
 	}

-	async fn system_reserved_peers(&self) -> RpcResult<Vec<String>> {
+	async fn system_reserved_peers(&self) -> Result<Vec<String>, Error> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkReservedPeers(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

-	async fn system_node_roles(&self) -> RpcResult<Vec<NodeRole>> {
+	async fn system_node_roles(&self) -> Result<Vec<NodeRole>, Error> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NodeRoles(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

-	async fn system_sync_state(&self) -> RpcResult<SyncState<<B::Header as HeaderT>::Number>> {
+	async fn system_sync_state(&self) -> Result<SyncState<<B::Header as HeaderT>::Number>, Error> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::SyncState(tx));
-		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
 	}

-	fn system_add_log_filter(&self, directives: String) -> RpcResult<()> {
+	fn system_add_log_filter(&self, directives: String) -> Result<(), Error> {
 		self.deny_unsafe.check_if_safe()?;

 		logging::add_directives(&directives);
-		logging::reload_filter().map_err(|e| {
-			JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
-				ErrorCode::InternalError.code(),
-				e,
-				None::<()>,
-			)))
-		})
+		logging::reload_filter().map_err(|e| Error::Internal(e))
 	}

-	fn system_reset_log_filter(&self) -> RpcResult<()> {
+	fn system_reset_log_filter(&self) -> Result<(), Error> {
 		self.deny_unsafe.check_if_safe()?;
-		logging::reset_log_filter().map_err(|e| {
-			JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
-				ErrorCode::InternalError.code(),
-				e,
-				None::<()>,
-			)))
-		})
+		logging::reset_log_filter().map_err(|e| Error::Internal(e))
 	}
 }
@@ -20,8 +20,7 @@ use super::{helpers::SyncState, *};
 use assert_matches::assert_matches;
 use futures::prelude::*;
 use jsonrpsee::{
-	core::Error as RpcError,
-	types::{error::CallError, EmptyServerParams as EmptyParams},
+	core::{EmptyServerParams as EmptyParams, Error as RpcError},
 	RpcModule,
 };
 use sc_network::{self, config::Role, PeerId};
@@ -312,7 +311,7 @@ async fn system_network_add_reserved() {
 	let bad_peer_id = ["/ip4/198.51.100.19/tcp/30333"];
 	assert_matches!(
 		api(None).call::<_, ()>("system_addReservedPeer", bad_peer_id).await,
-		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Peer id is missing from the address")
+		Err(RpcError::Call(err)) if err.message().contains("Peer id is missing from the address")
 	);
 }

@@ -328,7 +327,7 @@ async fn system_network_remove_reserved() {

 	assert_matches!(
 		api(None).call::<_, String>("system_removeReservedPeer", bad_peer_id).await,
-		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("base-58 decode error: provided string contained invalid character '/' at byte 0")
+		Err(RpcError::Call(err)) if err.message().contains("base-58 decode error: provided string contained invalid character '/' at byte 0")
 	);
 }
 #[tokio::test]