tpu quic proxy as module and lite-rpc switch #164
Conversation
… into groovie/tpu-proxy-as-module
| @@ -29,4 +29,6 @@ pub struct Args { | |||
| pub maximum_retries_per_tx: usize, | |||
| #[arg(long, default_value_t = DEFAULT_RETRY_TIMEOUT)] | |||
| pub transaction_retry_after_secs: u64, | |||
| #[arg(long)] | |||
| pub experimental_quic_proxy_addr: Option<String>, | |||
There was a problem hiding this comment.
should be quic_proxy_addr instead.
| None => TpuConnectionPath::QuicDirectPath, | ||
| Some(prox_address) => TpuConnectionPath::QuicForwardProxyPath { | ||
| // e.g. "127.0.0.1:11111" | ||
| forward_proxy_address: prox_address.parse().unwrap(), |
There was a problem hiding this comment.
use expect instead of unwrap with a message, failed to parse proxy address.
|
|
||
| pub async fn listen( | ||
| &self, | ||
| exit_signal: Arc<AtomicBool>, |
There was a problem hiding this comment.
avoid using exit_signal, we can do everything without exit_signals, using tokio tasks.
| let exit_signal = exit_signal.clone(); | ||
| let forwarder_channel_copy = forwarder_channel.clone(); | ||
| tokio::spawn(async move { | ||
| let connection = connecting.await.context("handshake").unwrap(); |
There was a problem hiding this comment.
avoid using unwrap. The proxy will crash if connecting returns an error, we should continue on error instead of panicing.
| loop { | ||
| let maybe_stream = client_connection.accept_uni().await; | ||
| match maybe_stream { | ||
| Err(quinn::ConnectionError::ApplicationClosed(reason)) => { |
There was a problem hiding this comment.
usually errors are after Ok
| pub agent_exit_signal: Arc<AtomicBool>, | ||
| pub created_at: Instant, | ||
| // relative to start | ||
| pub age_ms: AtomicU64, |
There was a problem hiding this comment.
why do you need age_ms and touch we can always calculate age of handle by a simple function. This may add additional complexity if the touch is not correctly called the age will be wrong and handle will live forever.
There was a problem hiding this comment.
i k .. that's bad. will fix that. the issue was that I could not easily have an AtomicTimestamp.
| ConnectionState::NotConnected => { | ||
| match self.create_connection().await { | ||
| Some(new_connection) => { | ||
| *lock = ConnectionState::Connection(new_connection.clone()); |
There was a problem hiding this comment.
Duplicate code as above
There was a problem hiding this comment.
what do you mean?
| } | ||
|
|
||
| async fn create_connection(&self) -> Option<Connection> { | ||
| let connection = self |
There was a problem hiding this comment.
No implementation of rtt0 type of connection.
There was a problem hiding this comment.
are you sure that we want that? the connection handling is optimized to keep actions active and does not suffer so much from high connection cost - WDYT
| tokio::time::timeout(FALLBACK_TIMEOUT, future) | ||
| } | ||
|
|
||
| // note this is duplicated from lite-rpc module |
There was a problem hiding this comment.
should move the code where both of the libraries can use.
There was a problem hiding this comment.
yes but where - new crate?
| use std::fmt; | ||
| use std::net::SocketAddr; | ||
| use std::time::Duration; | ||
| use tokio::sync::RwLock; |
There was a problem hiding this comment.
Seems similar code, should be benchmarked with existing code, I prefer only to have one way that we connect and maintain connection with TPU client. Could you compare the results of existing implementation and this implementation. You can also refactor original implementation so that it reflects the changes you want to do.
godmodegalactus
deleted the
groovie/tpu-proxy-as-module-with-integration-test
branch
Basic implementation of #142
adds the "Quic-proxy" service (a standalone network service) which accepts transaction batches via a simple wire protocol from lite-rpc and forwards them to the designated TPU (identified by address in wire protocol).
the connection between client and proxy is also QUIC
the proxy optionally takes a validator identity keypair to boost the connection to TPU, i.e. turns it into a Staked connection
instructions how to start locally are documented in README
architecture
the proxy consists of an inbound and an outbound part. inbound manages the connects from proxy client (lite-rpc in this case); outbound manages the connections to TPU.