mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-11-17 16:16:09 +00:00
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
148 lines
4.5 KiB
Rust
148 lines
4.5 KiB
Rust
// This file is part of Substrate.
|
|
|
|
// Copyright (C) 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/>.
|
|
|
|
//! Blockchain API backend for full nodes.
|
|
|
|
use super::{client_err, ChainBackend, Error};
|
|
use crate::{
|
|
utils::{pipe_from_stream, spawn_subscription_task},
|
|
SubscriptionTaskExecutor,
|
|
};
|
|
use std::{marker::PhantomData, sync::Arc};
|
|
|
|
use futures::{
|
|
future::{self},
|
|
stream::{self, Stream, StreamExt},
|
|
};
|
|
use jsonrpsee::{core::async_trait, PendingSubscriptionSink};
|
|
use sc_client_api::{BlockBackend, BlockchainEvents};
|
|
use sp_blockchain::HeaderBackend;
|
|
use sp_runtime::{generic::SignedBlock, traits::Block as BlockT};
|
|
|
|
/// Blockchain API backend for full nodes. Reads all the data from local database.
|
|
pub struct FullChain<Block: BlockT, Client> {
|
|
/// Substrate client.
|
|
client: Arc<Client>,
|
|
/// phantom member to pin the block type
|
|
_phantom: PhantomData<Block>,
|
|
/// Subscription executor.
|
|
executor: SubscriptionTaskExecutor,
|
|
}
|
|
|
|
impl<Block: BlockT, Client> FullChain<Block, Client> {
|
|
/// Create new Chain API RPC handler.
|
|
pub fn new(client: Arc<Client>, executor: SubscriptionTaskExecutor) -> Self {
|
|
Self { client, executor, _phantom: PhantomData }
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl<Block, Client> ChainBackend<Client, Block> for FullChain<Block, Client>
|
|
where
|
|
Block: BlockT + 'static,
|
|
Block::Header: Unpin,
|
|
Client: BlockBackend<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
|
|
{
|
|
fn client(&self) -> &Arc<Client> {
|
|
&self.client
|
|
}
|
|
|
|
fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error> {
|
|
self.client.header(self.unwrap_or_best(hash)).map_err(client_err)
|
|
}
|
|
|
|
fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error> {
|
|
self.client.block(self.unwrap_or_best(hash)).map_err(client_err)
|
|
}
|
|
|
|
fn subscribe_all_heads(&self, pending: PendingSubscriptionSink) {
|
|
subscribe_headers(
|
|
&self.client,
|
|
&self.executor,
|
|
pending,
|
|
|| self.client().info().best_hash,
|
|
|| {
|
|
self.client()
|
|
.import_notification_stream()
|
|
.map(|notification| notification.header)
|
|
},
|
|
)
|
|
}
|
|
|
|
fn subscribe_new_heads(&self, pending: PendingSubscriptionSink) {
|
|
subscribe_headers(
|
|
&self.client,
|
|
&self.executor,
|
|
pending,
|
|
|| self.client().info().best_hash,
|
|
|| {
|
|
self.client()
|
|
.import_notification_stream()
|
|
.filter(|notification| future::ready(notification.is_new_best))
|
|
.map(|notification| notification.header)
|
|
},
|
|
)
|
|
}
|
|
|
|
fn subscribe_finalized_heads(&self, pending: PendingSubscriptionSink) {
|
|
subscribe_headers(
|
|
&self.client,
|
|
&self.executor,
|
|
pending,
|
|
|| self.client().info().finalized_hash,
|
|
|| {
|
|
self.client()
|
|
.finality_notification_stream()
|
|
.map(|notification| notification.header)
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Subscribe to new headers.
|
|
fn subscribe_headers<Block, Client, F, G, S>(
|
|
client: &Arc<Client>,
|
|
executor: &SubscriptionTaskExecutor,
|
|
pending: PendingSubscriptionSink,
|
|
best_block_hash: G,
|
|
stream: F,
|
|
) where
|
|
Block: BlockT + 'static,
|
|
Block::Header: Unpin,
|
|
Client: HeaderBackend<Block> + 'static,
|
|
F: FnOnce() -> S,
|
|
G: FnOnce() -> Block::Hash,
|
|
S: Stream<Item = Block::Header> + Send + Unpin + 'static,
|
|
{
|
|
// send current head right at the start.
|
|
let maybe_header = client
|
|
.header(best_block_hash())
|
|
.map_err(client_err)
|
|
.and_then(|header| header.ok_or_else(|| Error::Other("Best header missing.".into())))
|
|
.map_err(|e| log::warn!("Best header error {:?}", e))
|
|
.ok();
|
|
|
|
// NOTE: by the time we set up the stream there might be a new best block and so there is a risk
|
|
// that the stream has a hole in it. The alternative would be to look up the best block *after*
|
|
// we set up the stream and chain it to the stream. Consuming code would need to handle
|
|
// duplicates at the beginning of the stream though.
|
|
let stream = stream::iter(maybe_header).chain(stream());
|
|
|
|
spawn_subscription_task(executor, pipe_from_stream(pending, stream));
|
|
}
|