#![cfg_attr(
feature = "stats",
doc = "- `stats` enables [`ClientStats`] and [`Client::stats`]. Byte counters include successful socket reads and writes even when the enclosing packet later fails; packet counters include only completed packets."
)]
#![cfg_attr(
not(feature = "stats"),
doc = "- `stats` enables `ClientStats` and `Client::stats`. Byte counters include successful socket reads and writes even when the enclosing packet later fails; packet counters include only completed packets."
)]
use std::{
io::{self, Write},
marker::PhantomData,
net::{Shutdown, SocketAddr, TcpStream, ToSocketAddrs},
time::Duration,
};
use socket2::{SockRef, TcpKeepalive};
#[cfg(feature = "stats")]
use std::io::Read;
use crate::packet::encode_bounded;
pub use crate::packet::{PacketIn, PacketOut};
pub const DEFAULT_OUTGOING_PACKET_LIMIT: usize = 1024 * 1024;
pub const DEFAULT_CLIENT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
pub const DEFAULT_CLIENT_KEEPALIVE_TIME: Duration = Duration::from_secs(60);
#[derive(Clone, Copy, Debug, PartialEq, Eq, better_default::Default)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "serde", serde(default))]
pub struct ClientConfig {
#[default(DEFAULT_OUTGOING_PACKET_LIMIT)]
pub outgoing_packet_limit: usize,
#[default(Some(DEFAULT_CLIENT_CONNECT_TIMEOUT))]
pub connect_timeout: Option<Duration>,
pub read_timeout: Option<Duration>,
pub write_timeout: Option<Duration>,
#[default(true)]
pub nodelay: bool,
#[default(Some(DEFAULT_CLIENT_KEEPALIVE_TIME))]
pub keepalive_time: Option<Duration>,
}
#[cfg(feature = "stats")]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ClientStats {
pub bytes_received: u64,
pub bytes_sent: u64,
pub packets_received: u64,
pub packets_sent: u64,
}
impl ClientConfig {
fn validate(self) -> io::Result<Self> {
if self.outgoing_packet_limit == 0 {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"outgoing_packet_limit must be greater than zero",
));
}
for (timeout, name) in [
(self.connect_timeout, "connect_timeout"),
(self.read_timeout, "read_timeout"),
(self.write_timeout, "write_timeout"),
(self.keepalive_time, "keepalive_time"),
] {
if timeout.is_some_and(|timeout| timeout.is_zero()) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("{name} must be greater than zero when enabled"),
));
}
}
Ok(self)
}
}
pub struct Client<I, O> {
stream: TcpStream,
config: ClientConfig,
usable: bool,
#[cfg(feature = "stats")]
stats: ClientStats,
packet_types: PhantomData<fn() -> (I, O)>,
}
impl<I, O> Client<I, O>
where
I: PacketIn,
O: PacketOut,
{
pub fn connect(addr: impl ToSocketAddrs) -> io::Result<Self> {
Self::connect_with_config(addr, ClientConfig::default())
}
pub fn connect_with_config(addr: impl ToSocketAddrs, config: ClientConfig) -> io::Result<Self> {
let config = config.validate()?;
let stream = connect_stream(addr, config.connect_timeout)?;
configure_stream(&stream, config)?;
Ok(Self {
stream,
config,
usable: true,
#[cfg(feature = "stats")]
stats: ClientStats::default(),
packet_types: PhantomData,
})
}
pub fn send(&mut self, packet: &O) -> io::Result<()> {
self.ensure_usable()?;
let encoded = encode_bounded(packet, self.config.outgoing_packet_limit)?;
#[cfg(feature = "stats")]
let result = {
let mut writer = CountingWriter::new(&mut self.stream);
let result = writer.write_all(&encoded);
self.stats.bytes_sent = self.stats.bytes_sent.saturating_add(writer.count);
result
};
#[cfg(not(feature = "stats"))]
let result = self.stream.write_all(&encoded);
if let Err(error) = result {
self.usable = false;
return Err(error);
}
#[cfg(feature = "stats")]
{
self.stats.packets_sent = self.stats.packets_sent.saturating_add(1);
}
Ok(())
}
pub fn receive(&mut self) -> io::Result<I> {
self.ensure_usable()?;
#[cfg(feature = "stats")]
let result = {
let mut reader = CountingReader::new(&mut self.stream);
let result = I::read(&mut reader);
self.stats.bytes_received = self.stats.bytes_received.saturating_add(reader.count);
result
};
#[cfg(not(feature = "stats"))]
let result = I::read(&mut self.stream);
match result {
Ok(packet) => {
#[cfg(feature = "stats")]
{
self.stats.packets_received = self.stats.packets_received.saturating_add(1);
}
Ok(packet)
}
Err(error) => {
self.usable = false;
Err(error)
}
}
}
pub fn shutdown(&self) -> io::Result<()> {
self.stream.shutdown(Shutdown::Both)
}
pub fn config(&self) -> ClientConfig {
self.config
}
pub fn is_usable(&self) -> bool {
self.usable
}
#[cfg(feature = "stats")]
pub fn stats(&self) -> ClientStats {
self.stats
}
pub fn local_addr(&self) -> io::Result<SocketAddr> {
self.stream.local_addr()
}
pub fn peer_addr(&self) -> io::Result<SocketAddr> {
self.stream.peer_addr()
}
pub fn into_stream(self) -> TcpStream {
self.stream
}
fn ensure_usable(&self) -> io::Result<()> {
if self.usable {
Ok(())
} else {
Err(io::Error::new(
io::ErrorKind::NotConnected,
"client is unusable after a previous packet I/O error",
))
}
}
}
fn connect_stream(addr: impl ToSocketAddrs, timeout: Option<Duration>) -> io::Result<TcpStream> {
if let Some(timeout) = timeout {
let mut last_error = None;
for addr in addr.to_socket_addrs()? {
match TcpStream::connect_timeout(&addr, timeout) {
Ok(stream) => return Ok(stream),
Err(error) => last_error = Some(error),
}
}
Err(last_error.unwrap_or_else(|| {
io::Error::new(io::ErrorKind::InvalidInput, "no socket addresses resolved")
}))
} else {
TcpStream::connect(addr)
}
}
fn configure_stream(stream: &TcpStream, config: ClientConfig) -> io::Result<()> {
stream.set_read_timeout(config.read_timeout)?;
stream.set_write_timeout(config.write_timeout)?;
if let Err(error) = stream.set_nodelay(config.nodelay)
&& !is_best_effort_socket_option_error(&error)
{
return Err(error);
}
let socket = SockRef::from(stream);
let keepalive_result = if let Some(time) = config.keepalive_time {
socket.set_tcp_keepalive(&TcpKeepalive::new().with_time(time))
} else {
socket.set_keepalive(false)
};
if let Err(error) = keepalive_result
&& !is_best_effort_socket_option_error(&error)
{
return Err(error);
}
Ok(())
}
fn is_best_effort_socket_option_error(error: &io::Error) -> bool {
matches!(
error.kind(),
io::ErrorKind::PermissionDenied | io::ErrorKind::Unsupported
)
}
#[cfg(feature = "stats")]
struct CountingReader<R> {
inner: R,
count: u64,
}
#[cfg(feature = "stats")]
impl<R> CountingReader<R> {
fn new(inner: R) -> Self {
Self { inner, count: 0 }
}
}
#[cfg(feature = "stats")]
impl<R: Read> Read for CountingReader<R> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let read = self.inner.read(buf)?;
self.count = self.count.saturating_add(read as u64);
Ok(read)
}
}
#[cfg(feature = "stats")]
struct CountingWriter<W> {
inner: W,
count: u64,
}
#[cfg(feature = "stats")]
impl<W> CountingWriter<W> {
fn new(inner: W) -> Self {
Self { inner, count: 0 }
}
}
#[cfg(feature = "stats")]
impl<W: Write> Write for CountingWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
let written = self.inner.write(buf)?;
self.count = self.count.saturating_add(written as u64);
Ok(written)
}
fn flush(&mut self) -> io::Result<()> {
self.inner.flush()
}
}