jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 10:59:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore(deps): bump interprocess and others (#8982)

Browse Source
This commit is contained in:
DaniPopes
2024-06-20 17:37:35 +02:00
committed by GitHub
parent f571183d08
commit 55831500cf
11 changed files with 150 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/rpc/ipc/Cargo.toml
View File

@ -29,7 +29,7 @@ tracing.workspace = true
bytes.workspace = true
thiserror.workspace = true
futures-util = "0.3.30"
interprocess = { version = "1.2.1", features = ["tokio_support"] }
interprocess = { version = "2.2.0", features = ["tokio"] }
[dev-dependencies]
tokio-stream = { workspace = true, features = ["sync"] }

55
crates/rpc/ipc/src/client/mod.rs
View File

@ -1,23 +1,23 @@
//! [`jsonrpsee`] transport adapter implementation for IPC.
use crate::stream_codec::StreamCodec;
use futures::StreamExt;
use interprocess::local_socket::tokio::{LocalSocketStream, OwnedReadHalf, OwnedWriteHalf};
use futures::{StreamExt, TryFutureExt};
use interprocess::local_socket::{
tokio::{prelude::*, RecvHalf, SendHalf},
GenericFilePath,
};
use jsonrpsee::{
async_client::{Client, ClientBuilder},
core::client::{ReceivedMessage, TransportReceiverT, TransportSenderT},
};
use std::io;
use tokio::io::AsyncWriteExt;
use tokio_util::{
codec::FramedRead,
compat::{Compat, FuturesAsyncReadCompatExt, FuturesAsyncWriteCompatExt},
};
use tokio_util::codec::FramedRead;
/// Sending end of IPC transport.
#[derive(Debug)]
pub(crate) struct Sender {
inner: Compat<OwnedWriteHalf>,
inner: SendHalf,
}
#[async_trait::async_trait]
@ -44,7 +44,7 @@ impl TransportSenderT for Sender {
/// Receiving end of IPC transport.
#[derive(Debug)]
pub(crate) struct Receiver {
pub(crate) inner: FramedRead<Compat<OwnedReadHalf>, StreamCodec>,
pub(crate) inner: FramedRead<RecvHalf, StreamCodec>,
}
#[async_trait::async_trait]
@ -63,20 +63,17 @@ impl TransportReceiverT for Receiver {
pub(crate) struct IpcTransportClientBuilder;
impl IpcTransportClientBuilder {
pub(crate) async fn build(
self,
endpoint: impl AsRef<str>,
) -> Result<(Sender, Receiver), IpcError> {
let endpoint = endpoint.as_ref().to_string();
let conn = LocalSocketStream::connect(endpoint.clone())
pub(crate) async fn build(self, path: &str) -> Result<(Sender, Receiver), IpcError> {
let conn = async { path.to_fs_name::<GenericFilePath>() }
.and_then(LocalSocketStream::connect)
.await
.map_err(|err| IpcError::FailedToConnect { path: endpoint, err })?;
.map_err(|err| IpcError::FailedToConnect { path: path.to_string(), err })?;
let (rhlf, whlf) = conn.into_split();
let (recv, send) = conn.split();
Ok((
Sender { inner: whlf.compat_write() },
Receiver { inner: FramedRead::new(rhlf.compat(), StreamCodec::stream_incoming()) },
Sender { inner: send },
Receiver { inner: FramedRead::new(recv, StreamCodec::stream_incoming()) },
))
}
}
@ -92,14 +89,14 @@ impl IpcClientBuilder {
/// ```
/// use jsonrpsee::{core::client::ClientT, rpc_params};
/// use reth_ipc::client::IpcClientBuilder;
///
/// # async fn run_client() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
/// let client = IpcClientBuilder::default().build("/tmp/my-uds").await?;
/// let response: String = client.request("say_hello", rpc_params![]).await?;
/// # Ok(())
/// # }
/// # Ok(()) }
/// ```
pub async fn build(self, path: impl AsRef<str>) -> Result<Client, IpcError> {
let (tx, rx) = IpcTransportClientBuilder::default().build(path).await?;
pub async fn build(self, name: &str) -> Result<Client, IpcError> {
let (tx, rx) = IpcTransportClientBuilder::default().build(name).await?;
Ok(self.build_with_tokio(tx, rx))
}
@ -139,20 +136,24 @@ pub enum IpcError {
#[cfg(test)]
mod tests {
use crate::server::dummy_endpoint;
use interprocess::local_socket::tokio::LocalSocketListener;
use interprocess::local_socket::ListenerOptions;
use super::*;
use crate::server::dummy_name;
#[tokio::test]
async fn test_connect() {
let endpoint = dummy_endpoint();
let binding = LocalSocketListener::bind(endpoint.clone()).unwrap();
let name = &dummy_name();
let binding = ListenerOptions::new()
.name(name.as_str().to_fs_name::<GenericFilePath>().unwrap())
.create_tokio()
.unwrap();
tokio::spawn(async move {
let _x = binding.accept().await;
});
let (tx, rx) = IpcTransportClientBuilder::default().build(endpoint).await.unwrap();
let (tx, rx) = IpcTransportClientBuilder::default().build(name).await.unwrap();
let _ = IpcClientBuilder::default().build_with_tokio(tx, rx);
}
}

125
crates/rpc/ipc/src/server/mod.rs
View File

@ -5,8 +5,12 @@ use crate::server::{
future::StopHandle,
};
use futures::StreamExt;
use futures_util::{future::Either, AsyncWriteExt};
use interprocess::local_socket::tokio::{LocalSocketListener, LocalSocketStream};
use futures_util::future::Either;
use interprocess::local_socket::{
tokio::prelude::{LocalSocketListener, LocalSocketStream},
traits::tokio::{Listener, Stream},
GenericFilePath, ListenerOptions, ToFsName,
};
use jsonrpsee::{
core::TEN_MB_SIZE_BYTES,
server::{
@ -24,7 +28,7 @@ use std::{
task::{Context, Poll},
};
use tokio::{
io::{AsyncRead, AsyncWrite},
io::{AsyncRead, AsyncWrite, AsyncWriteExt},
sync::{oneshot, watch},
};
use tower::{layer::util::Identity, Layer, Service};
@ -39,7 +43,6 @@ use crate::{
};
use tokio::sync::mpsc;
use tokio_stream::wrappers::ReceiverStream;
use tokio_util::compat::FuturesAsyncReadCompatExt;
use tower::layer::{util::Stack, LayerFn};
mod connection;
@ -68,17 +71,17 @@ impl<HttpMiddleware, RpcMiddleware> IpcServer<HttpMiddleware, RpcMiddleware> {
impl<HttpMiddleware, RpcMiddleware> IpcServer<HttpMiddleware, RpcMiddleware>
where
RpcMiddleware: Layer<RpcService> + Clone + Send + 'static,
for<'a> <RpcMiddleware as Layer<RpcService>>::Service: RpcServiceT<'a>,
HttpMiddleware: Layer<TowerServiceNoHttp<RpcMiddleware>> + Send + 'static,
<HttpMiddleware as Layer<TowerServiceNoHttp<RpcMiddleware>>>::Service: Send
+ Service<
String,
Response = Option<String>,
Error = Box<dyn std::error::Error + Send + Sync + 'static>,
>,
<<HttpMiddleware as Layer<TowerServiceNoHttp<RpcMiddleware>>>::Service as Service<String>>::Future:
Send + Unpin,
RpcMiddleware: for<'a> Layer<RpcService, Service: RpcServiceT<'a>> + Clone + Send + 'static,
HttpMiddleware: Layer<
TowerServiceNoHttp<RpcMiddleware>,
Service: Service<
String,
Response = Option<String>,
Error = Box<dyn std::error::Error + Send + Sync + 'static>,
Future: Send + Unpin,
> + Send,
> + Send
+ 'static,
{
/// Start responding to connections requests.
///
@ -89,7 +92,7 @@ where
/// use jsonrpsee::RpcModule;
/// use reth_ipc::server::Builder;
/// async fn run_server() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
/// let server = Builder::default().build("/tmp/my-uds");
/// let server = Builder::default().build("/tmp/my-uds".into());
/// let mut module = RpcModule::new(());
/// module.register_method("say_hello", |_, _, _| "lo")?;
/// let handle = server.start(module).await?;
@ -137,15 +140,19 @@ where
}
}
let listener = match LocalSocketListener::bind(self.endpoint.clone()) {
let listener = match self
.endpoint
.as_str()
.to_fs_name::<GenericFilePath>()
.and_then(|name| ListenerOptions::new().name(name).create_tokio())
{
Ok(listener) => listener,
Err(err) => {
on_ready
.send(Err(IpcServerStartError { endpoint: self.endpoint.clone(), source: err }))
.ok();
return;
}
Ok(listener) => listener,
};
// signal that we're ready to accept connections
@ -164,9 +171,10 @@ where
match try_accept_conn(&listener, stopped).await {
AcceptConnection::Established { local_socket_stream, stop } => {
let Some(conn_permit) = connection_guard.try_acquire() else {
let (mut _reader, mut writer) = local_socket_stream.into_split();
let _ = writer.write_all(b"Too many connections. Please try again later.").await;
drop((_reader, writer));
let (_reader, mut writer) = local_socket_stream.split();
let _ = writer
.write_all(b"Too many connections. Please try again later.")
.await;
stopped = stop;
continue;
};
@ -177,7 +185,7 @@ where
let conn_permit = Arc::new(conn_permit);
process_connection(ProcessConnection{
process_connection(ProcessConnection {
http_middleware: &self.http_middleware,
rpc_middleware: self.rpc_middleware.clone(),
conn_permit,
@ -193,9 +201,11 @@ where
id = id.wrapping_add(1);
stopped = stop;
}
AcceptConnection::Shutdown => { break; }
AcceptConnection::Err((e, stop)) => {
tracing::error!("Error while awaiting a new IPC connection: {:?}", e);
AcceptConnection::Shutdown => {
break;
}
AcceptConnection::Err((err, stop)) => {
tracing::error!(%err, "Failed accepting a new IPC connection");
stopped = stop;
}
}
@ -204,7 +214,8 @@ where
// Drop the last Sender
drop(drop_on_completion);
// Once this channel is closed it is safe to assume that all connections have been gracefully shutdown
// Once this channel is closed it is safe to assume that all connections have been
// gracefully shutdown
while process_connection_awaiter.recv().await.is_some() {
// Generally, messages should not be sent across this channel,
// but we'll loop here to wait for `None` just to be on the safe side
@ -222,10 +233,7 @@ async fn try_accept_conn<S>(listener: &LocalSocketListener, stopped: S) -> Accep
where
S: Future + Unpin,
{
let accept = listener.accept();
let accept = pin!(accept);
match futures_util::future::select(accept, stopped).await {
match futures_util::future::select(pin!(listener.accept()), stopped).await {
Either::Left((res, stop)) => match res {
Ok(local_socket_stream) => AcceptConnection::Established { local_socket_stream, stop },
Err(e) => AcceptConnection::Err((e, stop)),
@ -459,7 +467,7 @@ fn process_connection<'b, RpcMiddleware, HttpMiddleware>(
let ipc = IpcConn(tokio_util::codec::Decoder::framed(
StreamCodec::stream_incoming(),
local_socket_stream.compat(),
local_socket_stream,
));
let (tx, rx) = mpsc::channel::<String>(server_cfg.message_buffer_capacity as usize);
@ -682,9 +690,9 @@ impl<HttpMiddleware, RpcMiddleware> Builder<HttpMiddleware, RpcMiddleware> {
/// #[tokio::main]
/// async fn main() {
/// let builder = tower::ServiceBuilder::new();
///
/// let server =
/// reth_ipc::server::Builder::default().set_http_middleware(builder).build("/tmp/my-uds");
/// let server = reth_ipc::server::Builder::default()
/// .set_http_middleware(builder)
/// .build("/tmp/my-uds".into());
/// }
/// ```
pub fn set_http_middleware<T>(
@ -776,9 +784,9 @@ impl<HttpMiddleware, RpcMiddleware> Builder<HttpMiddleware, RpcMiddleware> {
}
/// Finalize the configuration of the server. Consumes the [`Builder`].
pub fn build(self, endpoint: impl AsRef<str>) -> IpcServer<HttpMiddleware, RpcMiddleware> {
pub fn build(self, endpoint: String) -> IpcServer<HttpMiddleware, RpcMiddleware> {
IpcServer {
endpoint: endpoint.as_ref().to_string(),
endpoint,
cfg: self.settings,
id_provider: self.id_provider,
http_middleware: self.http_middleware,
@ -816,9 +824,8 @@ impl ServerHandle {
}
}
/// For testing/examples
#[cfg(test)]
pub fn dummy_endpoint() -> String {
pub fn dummy_name() -> String {
let num: u64 = rand::Rng::gen(&mut rand::thread_rng());
if cfg!(windows) {
format!(r"\\.\pipe\my-pipe-{}", num)
@ -893,8 +900,8 @@ mod tests {
#[tokio::test]
async fn can_set_the_max_response_body_size() {
// init_test_tracing();
let endpoint = dummy_endpoint();
let server = Builder::default().max_response_body_size(100).build(&endpoint);
let endpoint = &dummy_name();
let server = Builder::default().max_response_body_size(100).build(endpoint.clone());
let mut module = RpcModule::new(());
module.register_method("anything", |_, _, _| "a".repeat(101)).unwrap();
let handle = server.start(module).await.unwrap();
@ -908,8 +915,8 @@ mod tests {
#[tokio::test]
async fn can_set_the_max_request_body_size() {
init_test_tracing();
let endpoint = dummy_endpoint();
let server = Builder::default().max_request_body_size(100).build(&endpoint);
let endpoint = &dummy_name();
let server = Builder::default().max_request_body_size(100).build(endpoint.clone());
let mut module = RpcModule::new(());
module.register_method("anything", |_, _, _| "succeed").unwrap();
let handle = server.start(module).await.unwrap();
@ -936,16 +943,16 @@ mod tests {
async fn can_set_max_connections() {
init_test_tracing();
let endpoint = dummy_endpoint();
let server = Builder::default().max_connections(2).build(&endpoint);
let endpoint = &dummy_name();
let server = Builder::default().max_connections(2).build(endpoint.clone());
let mut module = RpcModule::new(());
module.register_method("anything", |_, _, _| "succeed").unwrap();
let handle = server.start(module).await.unwrap();
tokio::spawn(handle.stopped());
let client1 = IpcClientBuilder::default().build(endpoint.clone()).await.unwrap();
let client2 = IpcClientBuilder::default().build(endpoint.clone()).await.unwrap();
let client3 = IpcClientBuilder::default().build(endpoint.clone()).await.unwrap();
let client1 = IpcClientBuilder::default().build(endpoint).await.unwrap();
let client2 = IpcClientBuilder::default().build(endpoint).await.unwrap();
let client3 = IpcClientBuilder::default().build(endpoint).await.unwrap();
let response1: Result<String, Error> = client1.request("anything", rpc_params![]).await;
let response2: Result<String, Error> = client2.request("anything", rpc_params![]).await;
@ -961,7 +968,7 @@ mod tests {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
// Can connect again
let client4 = IpcClientBuilder::default().build(endpoint.clone()).await.unwrap();
let client4 = IpcClientBuilder::default().build(endpoint).await.unwrap();
let response4: Result<String, Error> = client4.request("anything", rpc_params![]).await;
assert!(response4.is_ok());
}
@ -969,8 +976,8 @@ mod tests {
#[tokio::test]
async fn test_rpc_request() {
init_test_tracing();
let endpoint = dummy_endpoint();
let server = Builder::default().build(&endpoint);
let endpoint = &dummy_name();
let server = Builder::default().build(endpoint.clone());
let mut module = RpcModule::new(());
let msg = r#"{"jsonrpc":"2.0","id":83,"result":"0x7a69"}"#;
module.register_method("eth_chainId", move |_, _, _| msg).unwrap();
@ -984,8 +991,8 @@ mod tests {
#[tokio::test]
async fn test_batch_request() {
let endpoint = dummy_endpoint();
let server = Builder::default().build(&endpoint);
let endpoint = &dummy_name();
let server = Builder::default().build(endpoint.clone());
let mut module = RpcModule::new(());
module.register_method("anything", |_, _, _| "ok").unwrap();
let handle = server.start(module).await.unwrap();
@ -1009,8 +1016,8 @@ mod tests {
#[tokio::test]
async fn test_ipc_modules() {
reth_tracing::init_test_tracing();
let endpoint = dummy_endpoint();
let server = Builder::default().build(&endpoint);
let endpoint = &dummy_name();
let server = Builder::default().build(endpoint.clone());
let mut module = RpcModule::new(());
let msg = r#"{"admin":"1.0","debug":"1.0","engine":"1.0","eth":"1.0","ethash":"1.0","miner":"1.0","net":"1.0","rpc":"1.0","txpool":"1.0","web3":"1.0"}"#;
module.register_method("rpc_modules", move |_, _, _| msg).unwrap();
@ -1024,8 +1031,8 @@ mod tests {
#[tokio::test(flavor = "multi_thread")]
async fn test_rpc_subscription() {
let endpoint = dummy_endpoint();
let server = Builder::default().build(&endpoint);
let endpoint = &dummy_name();
let server = Builder::default().build(endpoint.clone());
let (tx, _rx) = broadcast::channel::<usize>(16);
let mut module = RpcModule::new(tx.clone());
@ -1080,10 +1087,10 @@ mod tests {
}
reth_tracing::init_test_tracing();
let endpoint = dummy_endpoint();
let endpoint = &dummy_name();
let rpc_middleware = RpcServiceBuilder::new().layer_fn(ModifyRequestIf);
let server = Builder::default().set_rpc_middleware(rpc_middleware).build(&endpoint);
let server = Builder::default().set_rpc_middleware(rpc_middleware).build(endpoint.clone());
let mut module = RpcModule::new(());
let goodbye_msg = r#"{"jsonrpc":"2.0","id":1,"result":"goodbye"}"#;