blockworks-foundation
/
lite-rpc
mirror of https://github.com/blockworks-foundation/lite-rpc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add error context

This commit is contained in:
GroovieGermanikus 2023-07-31 14:22:56 +02:00
parent 62a2f76c93
commit 4844844e21
4 changed files with 35 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
quic-forward-proxy/README.md
View File

@ -24,7 +24,7 @@ RUST_LOG="error,solana_streamer::nonblocking::quic=debug" solana-test-validator
```
3. run quic proxy
```bash
RUST_LOG=debug cargo run --bin solana-lite-rpc-quic-forward-proxy -- --proxy-rpc-addr 0.0.0.0:11111 --identity-keypair /pathto-test-ledger/validator-keypair.json
RUST_LOG=debug cargo run --bin solana-lite-rpc-quic-forward-proxy -- --proxy-listen-addr 0.0.0.0:11111 --identity-keypair /pathto-test-ledger/validator-keypair.json
```
2. run lite-rpc
```bash

10
quic-forward-proxy/src/inbound/proxy_listener.rs
View File

@ -41,12 +41,14 @@ impl ProxyListener {
let forwarder_channel_copy = forwarder_channel.clone();
tokio::spawn(async move {
let connection = connecting.await.context("handshake").unwrap();
match Self::accept_client_connection(connection, forwarder_channel_copy,
exit_signal)
match Self::accept_client_connection(
connection, forwarder_channel_copy, exit_signal)
.await {
Ok(()) => {}
Ok(()) => {
debug!("connection handles correctly");
}
Err(err) => {
error!("setup connection failed: {reason}", reason = err);
error!("failed to accect connection from client: {reason} - skip", reason = err);
}
}
});

9
quic-forward-proxy/src/outbound/tx_forward.rs
View File

@ -78,7 +78,7 @@ pub async fn tx_forwarder(validator_identity: ValidatorIdentity, mut transaction
debug!("forwarding transaction batch of size {} to address {}", transactions_batch.len(), packet.tpu_address);
let result = timeout_fallback(send_tx_batch_to_tpu(&auto_connection, &transactions_batch)).await
.context("send txs to tpu");
.context(format!("send txs to tpu node {}", auto_connection.target_address));
if result.is_err() {
warn!("got send_txs_to_tpu_static error {:?} - loop over errors", result);
@ -101,9 +101,10 @@ pub async fn tx_forwarder(validator_identity: ValidatorIdentity, mut transaction
let agent_channel = agents.get(&tpu_address).unwrap();
agent_channel.send(forward_packet).await.unwrap();
timeout_fallback(agent_channel.send(forward_packet)).await
.context("send to agent channel")??;
} // -- loop over transactions from ustream channels
} // -- loop over transactions from upstream channels
// not reachable
}
@ -174,7 +175,7 @@ async fn send_tx_batch_to_tpu(
tx_raw
})
.map(|tx_raw| {
auto_connection.send(tx_raw) // ignores error
auto_connection.send_uni(tx_raw) // ignores error
});
join_all(all_send_fns).await;

62
quic-forward-proxy/src/quinn_auto_reconnect.rs
View File

@ -2,15 +2,18 @@
use std::fmt;
use std::net::SocketAddr;
use std::sync::atomic::{AtomicU32, Ordering};
use anyhow::Context;
use log::warn;
use tracing::{debug, info};
use quinn::{Connection, Endpoint};
use tokio::sync::{RwLock};
use crate::util::timeout_fallback;
pub struct AutoReconnect {
// endoint should be configures with keep-alive and idle timeout
endpoint: Endpoint,
// note: no read lock is used ATM
current: RwLock<Option<Connection>>,
target_address: SocketAddr,
pub target_address: SocketAddr,
reconnect_count: AtomicU32,
}
@ -24,25 +27,12 @@ impl AutoReconnect {
}
}
pub async fn roundtrip(&self, payload: Vec<u8>) -> anyhow::Result<Vec<u8>> {
pub async fn send_uni(&self, payload: Vec<u8>) -> anyhow::Result<()> {
// TOOD do smart error handling + reconnect
// self.refresh().await.open_bi().await.unwrap()
let (mut send_stream, recv_stream) = self.refresh().await.open_bi().await?;
let mut send_stream = timeout_fallback(self.refresh().await.open_uni()).await
.context("open uni stream for sending")??;
send_stream.write_all(payload.as_slice()).await?;
send_stream.finish().await?;
let answer = recv_stream.reread_to_end(64 * 1024).await?;
Ok(answer)
}
pub async fn send(&self, payload: Vec<u8>) -> anyhow::Result<()> {
// TOOD do smart error handling + reconnect
let mut send_stream = self.refresh().await.open_uni().await?;
send_stream.write_all(payload.as_slice()).await?;
send_stream.finish().await?;
Ok(())
}
@ -50,52 +40,46 @@ impl AutoReconnect {
pub async fn refresh(&self) -> Connection {
{
let lock = self.current.read().await;
let maybe_conn: &Option<Connection> = &*lock;
if maybe_conn.as_ref().filter(|conn| conn.close_reason().is_none()).is_some() {
// let reuse = lock.unwrap().clone();
let reuse = maybe_conn.as_ref().unwrap();
let maybe_conn = lock.as_ref();
if maybe_conn.filter(|conn| conn.close_reason().is_none()).is_some() {
let reuse = maybe_conn.unwrap();
debug!("Reuse connection {}", reuse.stable_id());
return reuse.clone();
}
}
let mut lock = self.current.write().await;
match &*lock {
let maybe_conn = lock.as_ref();
return match maybe_conn {
Some(current) => {
if current.close_reason().is_some() {
info!("Connection is closed for reason: {:?}", current.close_reason());
// TODO log
let old_stable_id = current.stable_id();
warn!("Connection {} is closed for reason: {:?}", old_stable_id, current.close_reason());
let new_connection = self.create_connection().await;
*lock = Some(new_connection.clone());
// let old_conn = lock.replace(new_connection.clone());
self.reconnect_count.fetch_add(1, Ordering::SeqCst);
// debug!("Replace closed connection {} with {} (retry {})",
// old_conn.map(|c| c.stable_id().to_string()).unwrap_or("none".to_string()),
// new_connection.stable_id(),
// self.reconnect_count.load(Ordering::SeqCst));
// TODO log old vs new stable_id
debug!("Replace closed connection {} with {} (retry {})",
old_stable_id,
new_connection.stable_id(),
self.reconnect_count.load(Ordering::SeqCst));
return new_connection.clone();
new_connection.clone()
} else {
debug!("Reuse connection {} with write-lock", current.stable_id());
return current.clone();
current.clone()
}
}
None => {
let new_connection = self.create_connection().await;
// let old_conn = lock.replace(new_connection.clone());
// assert!(old_conn.is_none(), "old connection should be None");
assert!(lock.is_none(), "old connection must be None");
*lock = Some(new_connection.clone());
// let old_conn = foo.replace(Some(new_connection.clone()));
// TODO log old vs new stable_id
debug!("Create initial connection {}", new_connection.stable_id());
return new_connection.clone();
new_connection.clone()
}
}
}