use std::collections::HashMap;
use std::io::{self, IoSlice};
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::{Arc, Mutex, OnceLock, Weak};
use std::time::{Duration, Instant};
use rustorb_cdr::ByteOrder;
use rustorb_giop::{Message, MessageEncoder, OutMessage, ServiceContext, Version};
use tokio::io::AsyncWriteExt;
use tokio::net::TcpSocket;
use tokio::net::tcp::OwnedWriteHalf;
use tokio::sync::oneshot;
use crate::idle::Stamp;
use crate::server::{Outbox, Server, ServerConn};
use crate::tls::{self, Tls};
use crate::trace;
use crate::wire::{Here, Inbound, ReadError};
use crate::{CodeSets, OrbOptions};
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum Closed {
Orderly,
Failed(String),
}
const MAX_SLICES: usize = 64;
const CLOSE_TIME: Duration = Duration::from_secs(2);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum SendError {
TimedOut,
Failed,
Closing,
}
pub(crate) type EndpointKey = (String, u16, bool);
pub(crate) type ConnectionPool = Mutex<HashMap<EndpointKey, Arc<Connection>>>;
pub(crate) type Delivery = Result<Message, Closed>;
#[derive(Debug)]
struct Pending {
waiters: HashMap<u32, oneshot::Sender<Delivery>>,
closed: Option<Closed>,
}
enum Writer {
Stream(tokio::sync::Mutex<OwnedWriteHalf>),
Outbox(Arc<Outbox>),
}
impl std::fmt::Debug for Writer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Writer::Stream(_) => "Stream",
Writer::Outbox(_) => "Outbox",
})
}
}
pub(crate) struct Serving {
pub(crate) server: Weak<Server>,
pub(crate) conn: Arc<ServerConn>,
context: ServiceContext,
}
impl std::fmt::Debug for Serving {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Serving").finish_non_exhaustive()
}
}
#[derive(Debug)]
pub(crate) struct Connection {
endpoint: EndpointKey,
inbound: Arc<Inbound>,
writer: Writer,
tls: Option<Arc<Tls>>,
pending: Mutex<Pending>,
next_request_id: AtomicU32,
code_sets: Mutex<Option<CodeSets>>,
closing: AtomicBool,
last_used: Stamp,
pool: Weak<ConnectionPool>,
serving: OnceLock<Serving>,
offered: AtomicBool,
}
impl Connection {
pub(crate) async fn connect(
host: &str,
port: u16,
tls: Option<Arc<rustls::ClientConfig>>,
options: &OrbOptions,
pool: Weak<ConnectionPool>,
) -> io::Result<Arc<Connection>> {
let max_message_size = options.max_message_size;
let mut last = io::Error::new(io::ErrorKind::NotFound, "no address");
let mut connected = None;
for addr in tokio::net::lookup_host((host, port)).await? {
let socket = if addr.is_ipv4() {
TcpSocket::new_v4()?
} else {
TcpSocket::new_v6()?
};
if let Some(size) = options.socket_send_buffer {
socket.set_send_buffer_size(u32::try_from(size).unwrap_or(u32::MAX))?;
}
if let Some(size) = options.socket_receive_buffer {
socket.set_recv_buffer_size(u32::try_from(size).unwrap_or(u32::MAX))?;
}
match socket.connect(addr).await {
Ok(stream) => {
connected = Some(stream);
break;
}
Err(e) => {
trace::info!("could not connect to {addr} ({host}:{port}): {e}");
last = e;
}
}
}
let stream = connected.ok_or(last)?;
stream.set_nodelay(true)?;
let session = match tls {
Some(config) => match tls::connect(&stream, config, host).await {
Ok(session) => Some(session),
Err(e) => {
trace::info!("TLS handshake with {host}:{port} failed: {e}");
return Err(e);
}
},
None => None,
};
trace::info!(
"connected to {host}:{port}{}",
if session.is_some() { " with TLS" } else { "" }
);
let (reader, writer) = stream.into_split();
let conn = Arc::new(Connection {
endpoint: (host.to_owned(), port, session.is_some()),
inbound: Arc::new(Inbound::new(reader, session.clone(), max_message_size)),
writer: Writer::Stream(tokio::sync::Mutex::new(writer)),
tls: session,
pending: Mutex::new(Pending {
waiters: HashMap::new(),
closed: None,
}),
next_request_id: AtomicU32::new(0),
code_sets: Mutex::new(None),
closing: AtomicBool::new(false),
last_used: Stamp::new(),
pool,
serving: OnceLock::new(),
offered: AtomicBool::new(false),
});
tokio::spawn(read_loop(Arc::clone(&conn)));
Ok(conn)
}
pub(crate) fn accepted(
endpoint: EndpointKey,
inbound: Arc<Inbound>,
out: Arc<Outbox>,
pool: Weak<ConnectionPool>,
) -> Arc<Connection> {
Arc::new(Connection {
endpoint,
inbound,
writer: Writer::Outbox(out),
tls: None,
pending: Mutex::new(Pending {
waiters: HashMap::new(),
closed: None,
}),
next_request_id: AtomicU32::new(1),
code_sets: Mutex::new(None),
closing: AtomicBool::new(false),
last_used: Stamp::new(),
pool,
serving: OnceLock::new(),
offered: AtomicBool::new(false),
})
}
pub(crate) fn is_accepted(&self) -> bool {
matches!(self.writer, Writer::Outbox(_))
}
pub(crate) fn serve(
&self,
server: Weak<Server>,
conn: Arc<ServerConn>,
context: ServiceContext,
) {
let _ = self.serving.set(Serving {
server,
conn,
context,
});
}
pub(crate) fn bidir_context(&self) -> Option<&ServiceContext> {
let serving = self.serving.get()?;
(!self.offered.load(Ordering::Relaxed)).then_some(&serving.context)
}
pub(crate) fn offered(&self) {
if !self.offered.swap(true, Ordering::Relaxed) {
trace::info!(
"offered the connection to {} for bidirectional GIOP",
self.peer()
);
}
}
pub(crate) fn inbound(&self) -> Arc<Inbound> {
Arc::clone(&self.inbound)
}
pub(crate) fn endpoint(&self) -> &EndpointKey {
&self.endpoint
}
pub(crate) fn is_usable(&self) -> bool {
!self.closing.load(Ordering::Acquire) && self.pending.lock().unwrap().closed.is_none()
}
pub(crate) fn next_request_id(&self) -> u32 {
self.next_request_id.fetch_add(2, Ordering::Relaxed)
}
pub(crate) fn code_sets(&self) -> Option<CodeSets> {
*self.code_sets.lock().unwrap()
}
pub(crate) fn claim_code_sets(&self, proposed: CodeSets) -> CodeSets {
*self.code_sets.lock().unwrap().get_or_insert(proposed)
}
pub(crate) fn expect_reply(
&self,
request_id: u32,
) -> Result<oneshot::Receiver<Delivery>, Closed> {
let mut pending = self.pending.lock().unwrap();
if let Some(closed) = &pending.closed {
return Err(closed.clone());
}
if self.closing.load(Ordering::Acquire) {
return Err(Closed::Orderly);
}
self.last_used.touch();
let (tx, rx) = oneshot::channel();
pending.waiters.insert(request_id, tx);
Ok(rx)
}
pub(crate) fn read_reply_here(
&self,
request_id: u32,
deadline: Option<Instant>,
) -> Option<Option<Message>> {
if self.is_accepted() {
return None;
}
{
let pending = self.pending.lock().unwrap();
if pending.closed.is_some()
|| pending.waiters.len() != 1
|| !pending.waiters.contains_key(&request_id)
{
return None;
}
}
if !self.inbound.claim() {
return None;
}
if !self
.pending
.lock()
.unwrap()
.waiters
.contains_key(&request_id)
{
self.inbound.release();
return None;
}
loop {
let (version, message) = match self.inbound.read_here(deadline) {
Here::Message(version, message) => (version, message),
Here::TimedOut => return Some(None),
Here::HandedBack => return None,
};
let id = match &message {
Message::Reply { header, .. } => header.request_id,
Message::LocateReply { header, .. } => header.request_id,
_ => {
self.inbound.give_back(version, message);
return None;
}
};
if id == request_id {
self.inbound.release();
self.forget(request_id);
return Some(Some(message));
}
self.deliver(id, message);
}
}
pub(crate) fn forget(&self, request_id: u32) {
self.pending.lock().unwrap().waiters.remove(&request_id);
self.last_used.touch();
}
pub(crate) fn choose_idle(&self, timeout: Duration) -> bool {
if self.is_accepted() {
return false;
}
let pending = self.pending.lock().unwrap();
if pending.closed.is_some()
|| !pending.waiters.is_empty()
|| self.closing.load(Ordering::Acquire)
|| self.last_used.idle_for() < timeout
|| self.inbound.mid_message()
{
return false;
}
if let Some(serving) = self.serving.get() {
if !serving.conn.choose_idle(Some(timeout)) {
return false;
}
}
self.closing.store(true, Ordering::Release);
true
}
pub(crate) fn choose_close(&self, timeout: Option<Duration>) -> bool {
let pending = self.pending.lock().unwrap();
if pending.closed.is_some() || self.closing.load(Ordering::Acquire) {
return true;
}
if !pending.waiters.is_empty() || timeout.is_some_and(|t| self.last_used.idle_for() < t) {
return false;
}
self.closing.store(true, Ordering::Release);
true
}
pub(crate) fn awaits_nothing(&self) -> bool {
self.pending.lock().unwrap().waiters.is_empty()
}
pub(crate) fn idle_for(&self) -> Duration {
self.last_used.idle_for()
}
pub(crate) async fn close_idle(&self, order: ByteOrder) {
let close_connection = self
.offered
.load(Ordering::Relaxed)
.then_some((Version::V1_2, order));
self.close(close_connection).await;
}
pub(crate) async fn send(
&self,
msg: &OutMessage,
deadline: Option<Instant>,
) -> Result<(), SendError> {
let writer = match &self.writer {
Writer::Stream(writer) => writer,
Writer::Outbox(out) => return self.send_outbox(out, msg),
};
let mut writer = match deadline {
Some(at) => match tokio::time::timeout_at(at.into(), writer.lock()).await {
Ok(writer) => writer,
Err(_) => return Err(SendError::TimedOut),
},
None => writer.lock().await,
};
if self.closing.load(Ordering::Acquire) {
return Err(SendError::Closing);
}
self.last_used.touch();
trace::trace!("sent {} to {}", summary(msg), self.peer());
if let Some(tls) = &self.tls {
return self.send_tls(tls, &writer, msg, deadline).await;
}
let mut written = 0;
while written < msg.len() {
let (one, many);
let slices: &[IoSlice<'_>] = match msg.as_single() {
Some(bytes) => {
one = [IoSlice::new(&bytes[written..])];
&one
}
None => {
many = msg.slices_from(written, MAX_SLICES);
&many
}
};
let write = writer.write_vectored(slices);
let result = match deadline {
Some(at) => match tokio::time::timeout_at(at.into(), write).await {
Ok(result) => result,
Err(_) if written == 0 => return Err(SendError::TimedOut),
Err(_) => {
let _ = writer.shutdown().await;
drop(writer);
self.fail(Closed::Failed("write timed out".into()));
return Err(SendError::TimedOut);
}
},
None => write.await,
};
match result {
Ok(0) => {
drop(writer);
self.fail(Closed::Failed("write failed: stream closed".into()));
return Err(SendError::Failed);
}
Ok(n) => written += n,
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
Err(e) => {
drop(writer);
self.fail(Closed::Failed(format!("write failed: {e}")));
return Err(SendError::Failed);
}
}
}
Ok(())
}
fn send_outbox(&self, out: &Outbox, msg: &OutMessage) -> Result<(), SendError> {
if self.closing.load(Ordering::Acquire) {
return Err(SendError::Closing);
}
self.last_used.touch();
trace::trace!("sent {} to {}", summary(msg), self.peer());
if out.send(msg.clone()) {
Ok(())
} else {
self.fail(Closed::Failed("the connection is closed".into()));
Err(SendError::Failed)
}
}
async fn send_tls(
&self,
tls: &Tls,
writer: &OwnedWriteHalf,
msg: &OutMessage,
deadline: Option<Instant>,
) -> Result<(), SendError> {
tls.encrypt(msg, 0);
loop {
match tls.flush(|bytes| writer.try_write(bytes)) {
Ok(true) => return Ok(()),
Ok(false) => {}
Err(e) => {
self.fail(Closed::Failed(format!("write failed: {e}")));
return Err(SendError::Failed);
}
}
let writable = match deadline {
Some(at) => match tokio::time::timeout_at(at.into(), writer.writable()).await {
Ok(result) => result,
Err(_) => {
self.fail(Closed::Failed("write timed out".into()));
return Err(SendError::TimedOut);
}
},
None => writer.writable().await,
};
if let Err(e) = writable {
self.fail(Closed::Failed(format!("write failed: {e}")));
return Err(SendError::Failed);
}
}
}
pub(crate) async fn close(&self, close_connection: Option<(Version, ByteOrder)>) {
self.closing.store(true, Ordering::Release);
let writer = match &self.writer {
Writer::Stream(writer) => writer,
Writer::Outbox(_) => return,
};
trace::info!("closing the connection to {}", self.peer());
let msg = match close_connection {
Some((version, order)) => match MessageEncoder::close_connection(version, order) {
Ok(msg) => Some(msg),
Err(_) => return,
},
None => None,
};
let _ = tokio::time::timeout(CLOSE_TIME, async {
let mut writer = writer.lock().await;
match &self.tls {
Some(tls) => {
if let Some(msg) = msg {
tls.encrypt(&msg.into(), 0);
}
tls.close_notify();
while let Ok(false) = tls.flush(|bytes| writer.try_write(bytes)) {
if writer.writable().await.is_err() {
break;
}
}
}
None => {
if let Some(msg) = msg {
let _ = writer.write_all(&msg).await;
}
}
}
let _ = writer.shutdown().await;
})
.await;
}
pub(crate) fn fail(&self, why: Closed) {
let waiters = {
let mut pending = self.pending.lock().unwrap();
if pending.closed.is_none() {
pending.closed = Some(why.clone());
match &why {
_ if self.closing.load(Ordering::Acquire) => {
trace::info!("connection to {} closed", self.peer());
}
Closed::Orderly => {
trace::info!("{} closed the connection (CloseConnection)", self.peer())
}
Closed::Failed(e) => trace::info!("connection to {} lost: {e}", self.peer()),
}
}
std::mem::take(&mut pending.waiters)
};
if !self.is_accepted() {
self.inbound.shutdown();
}
for (_, tx) in waiters {
let _ = tx.send(Err(why.clone()));
}
}
fn peer(&self) -> Peer<'_> {
Peer(&self.endpoint)
}
pub(crate) fn deliver(&self, request_id: u32, msg: Message) {
self.last_used.touch();
let tx = self.pending.lock().unwrap().waiters.remove(&request_id);
if let Some(tx) = tx {
let _ = tx.send(Ok(msg));
}
}
}
struct Peer<'a>(&'a EndpointKey);
impl std::fmt::Display for Peer<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let (host, port, _) = self.0;
write!(f, "{host}:{port}")
}
}
pub(crate) fn summary(msg: &OutMessage) -> trace::MessageSummary<'_> {
let head = msg.pieces().next().unwrap_or(&[]);
trace::MessageSummary(head, msg.len())
}
async fn read_loop(conn: Arc<Connection>) {
let why = match read_messages(&conn).await {
Ok(why) => why,
Err(e) => Closed::Failed(e),
};
conn.fail(why);
if let Writer::Stream(writer) = &conn.writer {
let _ = writer.lock().await.shutdown().await;
}
conn.leave_pool();
}
impl Connection {
pub(crate) fn leave_pool(self: &Arc<Self>) {
if let Some(pool) = self.pool.upgrade() {
pool.lock().unwrap().retain(|_, c| !Arc::ptr_eq(c, self));
}
}
}
async fn read_messages(conn: &Connection) -> Result<Closed, String> {
loop {
let (version, message) = match conn.inbound.next().await {
Ok(read) => read,
Err(ReadError::Closed(e)) if e.kind() == io::ErrorKind::UnexpectedEof => {
return Err("connection closed by the server".into());
}
Err(ReadError::Closed(e) | ReadError::Truncated(e)) => {
return Err(format!("read failed: {e}"));
}
Err(ReadError::BadHeader(e) | ReadError::Malformed(_, e)) => return Err(e),
Err(ReadError::TooLarge(total, _)) => {
return Err(format!("message of {total} bytes exceeds the limit"));
}
};
match message {
Message::Reply { ref header, .. } => conn.deliver(header.request_id, message),
Message::LocateReply { ref header, .. } => conn.deliver(header.request_id, message),
Message::CloseConnection => return Ok(Closed::Orderly),
Message::MessageError => return Err("the server sent MessageError".into()),
Message::Request { header, body } => {
if let Some(serving) = conn.serving.get() {
if let Some(server) = serving.server.upgrade() {
server.on_request_detached(&serving.conn, version, header, body);
}
}
}
Message::LocateRequest(header) => {
if let Some(serving) = conn.serving.get() {
if let Some(server) = serving.server.upgrade() {
server.on_locate_request(&serving.conn, version, &header);
}
}
}
Message::CancelRequest(header) => {
if let Some(serving) = conn.serving.get() {
serving.conn.cancel_request(header.request_id);
}
}
Message::Fragment { .. } => {}
}
}
}