use std::net::SocketAddr;
use std::time::{Duration, Instant};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::time::timeout;
use crate::error::{Aria2Error, RecoverableError, Result};
use crate::network::ConnectionContext;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ProxyInfo {
pub host: String,
pub port: u16,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ConnectionPoolKey {
pub target: String,
pub proxy: Option<ProxyInfo>,
}
#[derive(Debug)]
pub struct ActiveConnection {
pub id: u64,
pub stream: TcpStream,
pub host: String,
pub connection: ConnectionContext,
pub last_used: Instant,
pub pooled_at: Option<Instant>,
pub pool_key: ConnectionPoolKey,
}
impl ActiveConnection {
pub fn is_valid(&self) -> bool {
self.stream.peer_addr().is_ok() && self.stream.local_addr().is_ok()
}
pub fn touch(&mut self) {
self.last_used = Instant::now();
}
pub fn mark_pooled(&mut self) {
let now = Instant::now();
self.last_used = now;
self.pooled_at = Some(now);
}
pub fn mark_in_use(&mut self) {
self.pooled_at = None;
}
pub fn is_idle_timeout(&self, timeout: Duration) -> bool {
match self.pooled_at {
Some(t) => t.elapsed() >= timeout,
None => false,
}
}
pub async fn read_with_timeout(
&mut self,
buf: &mut [u8],
read_timeout: Duration,
) -> Result<usize> {
timeout(read_timeout, self.stream.read(buf))
.await
.map_err(|_| Aria2Error::Recoverable(RecoverableError::Timeout))?
.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("Read data failed: {}", e),
})
})
}
pub async fn write_with_timeout(
&mut self,
buf: &[u8],
write_timeout: Duration,
) -> Result<usize> {
timeout(write_timeout, self.stream.write(buf))
.await
.map_err(|_| Aria2Error::Recoverable(RecoverableError::Timeout))?
.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("Write data failed: {}", e),
})
})
}
pub async fn flush_with_timeout(&mut self, write_timeout: Duration) -> Result<()> {
timeout(write_timeout, self.stream.flush())
.await
.map_err(|_| Aria2Error::Recoverable(RecoverableError::Timeout))?
.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("Flush buffer failed: {}", e),
})
})
}
pub async fn shutdown(&mut self) -> Result<()> {
match self.stream.shutdown().await {
Ok(_) => Ok(()),
Err(e) => {
tracing::debug!("Failed to close connection: id={}, error={}", self.id, e);
Ok(())
}
}
}
pub fn connection_context(&self) -> &ConnectionContext {
&self.connection
}
pub fn is_proxied(&self) -> bool {
self.pool_key.proxy.is_some()
}
pub fn peer_addr(&self) -> Result<SocketAddr> {
self.stream.peer_addr().map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("Failed to get peer address: {}", e),
})
})
}
pub fn local_addr(&self) -> Result<SocketAddr> {
self.stream.local_addr().map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("Failed to get local address: {}", e),
})
})
}
}