use std::collections::HashMap;
use std::io::{self, IoSlice};
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use rustorb_cdr::ByteOrder;
use rustorb_giop::{Message, MessageEncoder, OutMessage, Version};
use tokio::io::AsyncWriteExt;
use tokio::net::TcpSocket;
use tokio::net::tcp::OwnedWriteHalf;
use tokio::sync::oneshot;
use crate::tls::{self, Tls};
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,
}
pub(crate) type EndpointKey = (String, u16, bool);
pub(crate) type Delivery = Result<Message, Closed>;
#[derive(Debug)]
struct Pending {
waiters: HashMap<u32, oneshot::Sender<Delivery>>,
closed: Option<Closed>,
}
#[derive(Debug)]
pub(crate) struct Connection {
endpoint: EndpointKey,
inbound: Inbound,
writer: tokio::sync::Mutex<OwnedWriteHalf>,
tls: Option<Arc<Tls>>,
pending: Mutex<Pending>,
next_request_id: AtomicU32,
code_sets: Mutex<Option<CodeSets>>,
closing: AtomicBool,
}
impl Connection {
pub(crate) async fn connect(
host: &str,
port: u16,
tls: Option<Arc<rustls::ClientConfig>>,
options: &OrbOptions,
) -> 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) => last = e,
}
}
let stream = connected.ok_or(last)?;
stream.set_nodelay(true)?;
let session = match tls {
Some(config) => Some(tls::connect(&stream, config, host).await?),
None => None,
};
let (reader, writer) = stream.into_split();
let conn = Arc::new(Connection {
endpoint: (host.to_owned(), port, session.is_some()),
inbound: Inbound::new(reader, session.clone(), max_message_size),
writer: 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),
});
tokio::spawn(read_loop(Arc::clone(&conn)));
Ok(conn)
}
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(1, 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());
}
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>> {
{
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);
}
pub(crate) async fn send(
&self,
msg: &OutMessage,
deadline: Option<Instant>,
) -> Result<(), SendError> {
let mut writer = match deadline {
Some(at) => match tokio::time::timeout_at(at.into(), self.writer.lock()).await {
Ok(writer) => writer,
Err(_) => return Err(SendError::TimedOut),
},
None => self.writer.lock().await,
};
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(())
}
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, version: Version, order: ByteOrder) {
self.closing.store(true, Ordering::Release);
if let Ok(msg) = MessageEncoder::close_connection(version, order) {
let _ = tokio::time::timeout(CLOSE_TIME, async {
let mut writer = self.writer.lock().await;
match &self.tls {
Some(tls) => {
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 => {
let _ = writer.write_all(&msg).await;
}
}
let _ = writer.shutdown().await;
})
.await;
}
}
fn fail(&self, why: Closed) {
let waiters = {
let mut pending = self.pending.lock().unwrap();
if pending.closed.is_none() {
pending.closed = Some(why.clone());
}
std::mem::take(&mut pending.waiters)
};
self.inbound.shutdown();
for (_, tx) in waiters {
let _ = tx.send(Err(why.clone()));
}
}
fn deliver(&self, request_id: u32, msg: Message) {
let tx = self.pending.lock().unwrap().waiters.remove(&request_id);
if let Some(tx) = tx {
let _ = tx.send(Ok(msg));
}
}
}
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);
let _ = conn.writer.lock().await.shutdown().await;
}
async fn read_messages(conn: &Connection) -> Result<Closed, String> {
loop {
let (_, 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 { .. }
| Message::LocateRequest(_)
| Message::CancelRequest(_)
| Message::Fragment { .. } => {}
}
}
}