use std::sync::Arc;
use futures_util::{SinkExt, StreamExt};
use tokio::net::TcpStream;
use tokio_util::codec::Framed;
use tracing::trace;
use crate::connections::server::{Reply, ServerConn};
use crate::pool::PoolManager;
use crate::proto::backend::BackendMessage;
use crate::proto::codec::FrontendCodec;
use crate::proto::frontend::FrontendMessage;
use crate::proto::types::TransactionStatus;
use crate::proxy::intercept::{handle_close_intercept, handle_deallocate_intercept};
use crate::proxy::prepared::{ClientPrepared, PreparedGuard, rewrite_outbound};
pub async fn forward(
client: &mut Framed<TcpStream, FrontendCodec>,
server: &mut ServerConn,
pools: &Arc<PoolManager>,
) -> anyhow::Result<()> {
let mut client_prepared = PreparedGuard {
inner: ClientPrepared::new(),
pools: Arc::clone(pools),
};
forward_loop(client, server, pools, &mut client_prepared.inner).await
}
async fn forward_loop(
client: &mut Framed<TcpStream, FrontendCodec>,
server: &mut ServerConn,
pools: &Arc<PoolManager>,
client_prepared: &mut ClientPrepared,
) -> anyhow::Result<()> {
server.statements.reset_pending();
let mut last_status = TransactionStatus::Idle;
loop {
tokio::select! {
msg = client.next() => match msg.transpose()? {
Some(FrontendMessage::Terminate) => {
trace!("client sent Terminate");
return Ok(());
}
Some(msg) => {
if let Some(true) =
handle_close_intercept(&msg, client_prepared, client, pools).await?
{
continue;
}
if let Some(true) = handle_deallocate_intercept(
&msg,
client_prepared,
client,
pools,
last_status,
)
.await?
{
continue;
}
if let Some(msg) =
rewrite_outbound(msg, client_prepared, server, pools, client).await?
{
trace!(?msg, "client -> server");
server.framed.send(msg).await?;
}
}
None => return Ok(()),
},
msg = server.framed.next() => match msg.transpose()? {
Some(BackendMessage::ParseComplete) => match server.statements.next_parse_reply() {
Reply::Suppress => trace!("suppressing injected ParseComplete"),
Reply::Forward => client.send(BackendMessage::ParseComplete).await?,
},
Some(BackendMessage::CloseComplete) => match server.statements.next_close_reply() {
Reply::Suppress => trace!("suppressing injected CloseComplete"),
Reply::Forward => client.send(BackendMessage::CloseComplete).await?,
},
Some(BackendMessage::ReadyForQuery(status)) => {
last_status = status;
server.last_tx_status = status;
client.send(BackendMessage::ReadyForQuery(status)).await?;
}
Some(BackendMessage::ErrorResponse(ref err)) => {
server.statements.roll_back_after_error();
client
.send(BackendMessage::ErrorResponse(err.clone()))
.await?;
}
Some(msg) => {
trace!(?msg, "server -> client");
client.send(msg).await?;
}
None => anyhow::bail!("upstream server closed unexpectedly"),
},
}
}
}