use crate::bytes_helper::u16_from_le_bytes;
use log::trace;
use std::{
io::{BufReader, Read, Result, Write},
net::{SocketAddr, TcpStream},
time::{Duration, Instant},
};
#[macro_use]
#[cfg(test)]
pub(crate) mod tests;
#[cfg(test)]
mod resilience_tests;
#[cfg(test)]
mod deadline_tests;
mod basic;
pub use basic::*;
pub mod helper;
pub mod ip;
pub mod stock;
pub type BufTcp = BufReader<TcpStream>;
#[derive(Debug, Clone)]
pub struct TcpConfig {
pub timeout: Duration,
pub ip: Option<SocketAddr>,
pub auto_reconnect: usize,
pub retry_delay_ms: u64,
pub recheck_empty: bool,
}
impl Default for TcpConfig {
fn default() -> Self {
Self {
timeout: TIMEOUT,
ip: None,
auto_reconnect: 2,
retry_delay_ms: 0,
recheck_empty: false,
}
}
}
impl TcpConfig {
pub fn with_index(index: usize, timeout: Duration) -> Self {
Self {
timeout,
ip: Some(ip::STOCK_IP.get(index).copied().unwrap_or(ip::STOCK_IP[0])),
..Default::default()
}
}
}
#[derive(Debug)]
pub struct Tcp {
stream: TcpStream,
buffer: BufTcp,
recv: [u8; RECV_SIZE],
config: TcpConfig,
servers: Vec<SocketAddr>,
deadline: Option<Instant>,
needs_reconnect: bool,
}
impl Tcp {
pub fn new() -> Result<Self> {
Self::with_config(&TcpConfig::default())
}
pub fn with_config(config: &TcpConfig) -> Result<Self> {
Self::with_config_inner(config, None)
}
pub fn with_config_until(config: &TcpConfig, deadline: Instant) -> Result<Self> {
Self::with_config_inner(config, Some(deadline))
}
fn with_config_inner(config: &TcpConfig, deadline: Option<Instant>) -> Result<Self> {
match config.ip {
Some(addr) => Self::connect_addr(&addr, config, deadline),
None => Self::with_servers_inner(config, &ip::STOCK_IP, deadline),
}
}
pub fn with_servers(config: &TcpConfig, servers: &[SocketAddr]) -> Result<Self> {
Self::with_servers_inner(config, servers, None)
}
pub fn with_servers_until(
config: &TcpConfig,
servers: &[SocketAddr],
deadline: Instant,
) -> Result<Self> {
Self::with_servers_inner(config, servers, Some(deadline))
}
fn with_servers_inner(
config: &TcpConfig,
servers: &[SocketAddr],
deadline: Option<Instant>,
) -> Result<Self> {
let mut last_err = None;
for addr in servers {
operation_timeout(config.timeout, deadline)?;
let mut candidate = config.clone();
candidate.ip = Some(*addr);
match Self::connect_addr(addr, &candidate, deadline) {
Ok(mut tcp) => {
tcp.servers = servers.to_vec();
return Ok(tcp);
}
Err(e) => last_err = Some(e),
}
}
operation_timeout(config.timeout, deadline)?;
Err(last_err.unwrap_or_else(|| {
std::io::Error::new(std::io::ErrorKind::InvalidInput, "empty server pool")
}))
}
fn connect_addr(
addr: &SocketAddr,
config: &TcpConfig,
deadline: Option<Instant>,
) -> Result<Self> {
let timeout = operation_timeout(config.timeout, deadline)?;
let (stream, buffer, recv) = tcpstream_ip_with_timeout(addr, timeout)?;
let mut tcp = Self {
stream,
buffer,
recv,
config: config.clone(),
servers: Vec::new(),
deadline,
needs_reconnect: false,
};
tcp.config.auto_reconnect = 0;
send_packs(&mut tcp, false)?;
tcp.config = config.clone();
tcp.check_deadline()?;
Ok(tcp)
}
pub fn set_deadline(&mut self, deadline: Option<Instant>) {
self.deadline = deadline;
}
fn invalidate(&mut self) {
self.needs_reconnect = true;
let _ = self.stream.shutdown(std::net::Shutdown::Both);
}
fn check_deadline(&mut self) -> Result<()> {
if self.deadline.is_some_and(|at| Instant::now() >= at) {
self.invalidate();
return Err(deadline_error());
}
Ok(())
}
fn io_timeout(&mut self) -> Result<Duration> {
self.check_deadline()?;
operation_timeout(self.config.timeout, self.deadline)
}
pub(crate) fn sleep_with_deadline(&mut self, duration: Duration) -> Result<()> {
self.check_deadline()?;
let sleep = self
.deadline
.map(|at| duration.min(at.saturating_duration_since(Instant::now())))
.unwrap_or(duration);
std::thread::sleep(sleep);
self.check_deadline()
}
fn read_exact_until(&mut self, output: &mut [u8]) -> Result<()> {
let result = (|| {
let mut offset = 0;
while offset < output.len() {
let timeout = self.io_timeout()?;
self.buffer.get_ref().set_read_timeout(Some(timeout))?;
match self.buffer.read(&mut output[offset..]) {
Ok(0) => {
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"TDX response closed",
));
}
Ok(n) => offset += n,
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
Err(e) => return Err(e),
}
}
self.check_deadline()
})();
if result.is_err() {
self.invalidate();
}
result
}
fn write_all_until(&mut self, input: &[u8]) -> Result<()> {
let result = (|| {
let mut offset = 0;
while offset < input.len() {
let timeout = self.io_timeout()?;
self.stream.set_write_timeout(Some(timeout))?;
match self.stream.write(&input[offset..]) {
Ok(0) => {
return Err(std::io::Error::new(
std::io::ErrorKind::WriteZero,
"TDX request write returned zero",
));
}
Ok(n) => offset += n,
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
Err(e) => return Err(e),
}
}
self.check_deadline()
})();
if result.is_err() {
self.invalidate();
}
result
}
pub fn config(&self) -> &TcpConfig {
&self.config
}
pub fn reconnect(&mut self) -> Result<()> {
self.check_deadline()?;
if self.servers.is_empty() {
*self = Self::with_config_inner(&self.config, self.deadline)?;
} else {
let mut servers = self.servers.clone();
if let Some(index) = servers
.iter()
.position(|addr| Some(*addr) == self.config.ip)
{
let len = servers.len();
servers.rotate_left((index + 1) % len);
}
*self = Self::with_servers_inner(&self.config, &servers, self.deadline)?;
}
Ok(())
}
pub fn heartbeat(&mut self) -> Result<u16> {
let mut hb = SecurityCount::new(0);
Ok(*hb.recv_parsed(self)?)
}
pub fn retry<T>(
&mut self,
mut f: impl FnMut(&mut Tcp) -> Result<T>,
attempts: usize,
) -> Result<T> {
if attempts == 0 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"attempts must be positive",
));
}
let mut last_err = None;
for attempt in 0..attempts {
self.check_deadline()?;
match f(self) {
Ok(v) => return Ok(v),
Err(e) => {
if attempt + 1 < attempts {
self.backoff(attempt as u64 + 1)?;
self.reconnect()?;
}
last_err = Some(e);
}
}
}
Err(last_err.unwrap())
}
fn without_auto_retry<T>(&mut self, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
let configured = self.config.auto_reconnect;
self.config.auto_reconnect = 0;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| f(self)));
self.config.auto_reconnect = configured;
match result {
Ok(result) => result,
Err(payload) => std::panic::resume_unwind(payload),
}
}
fn backoff(&mut self, failed: u64) -> Result<()> {
self.sleep_with_deadline(Duration::from_millis(
self.config.retry_delay_ms.saturating_mul(failed),
))
}
pub fn send_recv(&mut self, send: &[u8]) -> Result<(usize, usize)> {
let attempts = self.config.auto_reconnect.max(1);
self.retry(|tcp| tcp.send_recv_once(send), attempts)
}
fn send_recv_once(&mut self, send: &[u8]) -> Result<(usize, usize)> {
self.check_deadline()?;
if self.needs_reconnect {
self.reconnect()?;
}
self.write_all_until(send)?;
let mut header = [0; RECV_SIZE];
self.read_exact_until(&mut header)?;
self.recv = header;
trace!("send: {:?}\nrecv[16B]: {:?}", send, self);
Ok((send.len(), RECV_SIZE))
}
pub fn into_inner(self) -> (TcpStream, BufTcp, [u8; RECV_SIZE]) {
(self.stream, self.buffer, self.recv)
}
pub fn get_ref(&self) -> (&TcpStream, &BufTcp, &[u8]) {
(&self.stream, &self.buffer, &self.recv)
}
pub fn get_ref_recv(&self) -> &[u8] {
&self.recv
}
}
pub trait Tdx {
const SEND: &'static [u8];
const TAG: &'static str;
const LEN: usize = Self::SEND.len();
type Item: ?Sized;
fn send(&mut self) -> &[u8];
fn recv(&mut self, tcp: &mut Tcp) -> Result<Vec<u8>> {
send_recv_decompress(tcp, self.send(), Self::TAG)
}
fn parse(&mut self, response: Vec<u8>);
fn recv_parsed(&mut self, tcp: &mut Tcp) -> Result<&Self::Item> {
let attempts = tcp.config.auto_reconnect.max(1);
tcp.retry(
|tcp| {
tcp.without_auto_retry(|tcp| {
let response = self.recv(tcp)?;
self.try_parse(response)?;
tcp.check_deadline()
})
},
attempts,
)?;
Ok(self.result())
}
fn try_parse(&mut self, response: Vec<u8>) -> Result<()> {
self.parse(response);
Ok(())
}
fn result(&self) -> &Self::Item;
}
pub fn send_recv_decompress(tcp: &mut Tcp, send: &[u8], tag: &str) -> Result<Vec<u8>> {
let attempts = tcp.config.auto_reconnect.max(1);
tcp.retry(
|tcp| {
let (buf, deflate_size, inflate_size) = read_response_once(tcp, send, tag)?;
let decoded = decode_response(buf, deflate_size, inflate_size)?;
tcp.check_deadline()?;
Ok(decoded)
},
attempts,
)
}
fn decode_response(buf: Vec<u8>, deflate_size: u16, inflate_size: u16) -> Result<Vec<u8>> {
let invalid = |message| std::io::Error::new(std::io::ErrorKind::InvalidData, message);
let decoded = if deflate_size != inflate_size {
miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(&buf, inflate_size as usize)
.map_err(|_| invalid("invalid or oversized compressed TDX response"))?
} else {
buf
};
if decoded.len() != inflate_size as usize {
return Err(invalid("TDX response length mismatch"));
}
Ok(decoded)
}
pub fn send_recv(tcp: &mut Tcp, send: &[u8], tag: &str) -> Result<(Vec<u8>, u16, u16)> {
let attempts = tcp.config.auto_reconnect.max(1);
tcp.retry(|tcp| read_response_once(tcp, send, tag), attempts)
}
fn read_response_once(tcp: &mut Tcp, send: &[u8], tag: &str) -> Result<(Vec<u8>, u16, u16)> {
tcp.send_recv_once(send)?;
trace!("{tag}\nsend: {:?}\nrecv[16B]: {:?}", send, tcp);
let deflate_size = u16_from_le_bytes(&tcp.recv, 12); let mut buf = vec![0; deflate_size as usize];
tcp.read_exact_until(&mut buf)?;
let inflate_size = u16_from_le_bytes(&tcp.recv, 14); #[rustfmt::skip]
trace!("\n解压前:#{:?}# -> {},解压后:#{:?}# -> {}\n剩余数据(即解压前):{:x?}\n",
&tcp.recv[12..14], deflate_size, &tcp.recv[14..16], inflate_size, buf);
Ok((buf, deflate_size, inflate_size))
}
fn deadline_error() -> std::io::Error {
std::io::Error::new(
std::io::ErrorKind::TimedOut,
"TDX operation deadline exceeded",
)
}
fn operation_timeout(timeout: Duration, deadline: Option<Instant>) -> Result<Duration> {
if timeout.is_zero() {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"timeout must be positive",
));
}
match deadline {
Some(at) => {
let remaining = at.saturating_duration_since(Instant::now());
if remaining.is_zero() {
Err(deadline_error())
} else {
Ok(timeout.min(remaining))
}
}
None => Ok(timeout),
}
}
pub const TIMEOUT: Duration = Duration::from_secs(5);
pub fn tcpstream() -> Result<(TcpStream, BufTcp, [u8; RECV_SIZE])> {
tcpstream_with_timeout(TIMEOUT)
}
pub fn tcpstream_with_timeout(timeout: Duration) -> Result<(TcpStream, BufTcp, [u8; RECV_SIZE])> {
let mut last_err = None;
for addr in ip::STOCK_IP.iter() {
match tcpstream_ip_with_timeout(addr, timeout) {
Ok(x) => return Ok(x),
Err(e) => last_err = Some((addr, e)),
}
}
let (addr, err) = last_err.expect("服务器列表不能为空");
log::warn!("所有行情服务器连接失败,最后尝试: {addr}");
Err(err)
}
pub fn tcpstream_ip(ip: &SocketAddr) -> Result<(TcpStream, BufTcp, [u8; RECV_SIZE])> {
tcpstream_ip_with_timeout(ip, TIMEOUT)
}
pub fn tcpstream_ip_with_timeout(
ip: &SocketAddr,
timeout: Duration,
) -> Result<(TcpStream, BufTcp, [u8; RECV_SIZE])> {
let stream = TcpStream::connect_timeout(ip, timeout)?;
stream.set_read_timeout(Some(timeout))?;
stream.set_write_timeout(Some(timeout))?;
let recv = [0; RECV_SIZE];
let buffer = BufReader::new(stream.try_clone()?);
Ok((stream, buffer, recv))
}