use std::collections::{HashMap, HashSet};
use std::fmt;
use std::sync::Arc;
use tokio::sync::Mutex;
use crate::error::{Result, SerialError};
use super::config::{ConnectionConfig, ConnectionState, ConnectionSummary};
use super::connection::SerialConnection;
#[async_trait::async_trait]
pub trait ConnectionOpener: Send + Sync {
async fn open(&self, config: ConnectionConfig) -> Result<SerialConnection>;
}
#[derive(Debug)]
struct SystemConnectionOpener;
#[async_trait::async_trait]
impl ConnectionOpener for SystemConnectionOpener {
async fn open(&self, config: ConnectionConfig) -> Result<SerialConnection> {
SerialConnection::open(config).await
}
}
pub struct ConnectionManager {
opener: Arc<dyn ConnectionOpener>,
state: Arc<Mutex<ConnectionRegistry>>,
}
impl fmt::Debug for ConnectionManager {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ConnectionManager")
.field("opener", &"<dyn ConnectionOpener>")
.field("state", &self.state)
.finish()
}
}
impl Default for ConnectionManager {
fn default() -> Self {
Self::new()
}
}
struct OpeningReservationGuard {
state: Arc<Mutex<ConnectionRegistry>>,
port: String,
active: bool,
}
impl OpeningReservationGuard {
fn new(state: Arc<Mutex<ConnectionRegistry>>, port: String) -> Self {
Self {
state,
port,
active: true,
}
}
fn clear(&mut self) {
self.active = false;
}
}
impl Drop for OpeningReservationGuard {
fn drop(&mut self) {
if !self.active {
return;
}
match self.state.try_lock() {
Ok(mut state) => {
state.opening_ports.remove(&self.port);
}
Err(_) => {
let state = Arc::clone(&self.state);
let port = self.port.clone();
if let Ok(handle) = tokio::runtime::Handle::try_current() {
std::mem::drop(handle.spawn(async move {
state.lock().await.opening_ports.remove(&port);
}));
} else {
self.state.blocking_lock().opening_ports.remove(&self.port);
}
}
}
}
}
#[derive(Debug, Default)]
struct ConnectionRegistry {
connections: HashMap<String, Arc<SerialConnection>>,
opening_ports: HashSet<String>,
closing_ports: HashSet<String>,
reconnect_tasks: HashMap<String, tokio::task::JoinHandle<()>>,
}
impl ConnectionManager {
pub fn new() -> Self {
Self::with_opener(Arc::new(SystemConnectionOpener))
}
pub fn with_opener(opener: Arc<dyn ConnectionOpener>) -> Self {
Self {
opener,
state: Arc::new(Mutex::new(ConnectionRegistry::default())),
}
}
pub async fn open(&self, config: ConnectionConfig) -> Result<String> {
let port = config.port.clone();
let mut guard = {
let mut state = self.state.lock().await;
if let Some(connection) = find_connection_by_port(&state.connections, &port) {
return Err(SerialError::PortAlreadyOpen {
port,
connection_id: Some(connection.id().to_string()),
name: connection.name().map(str::to_string),
});
}
if state.opening_ports.contains(&port) || state.closing_ports.contains(&port) {
return Err(SerialError::PortAlreadyOpening(port));
}
state.opening_ports.insert(port.clone());
OpeningReservationGuard::new(Arc::clone(&self.state), port.clone())
};
let opened = self.opener.open(config).await;
let mut state = self.state.lock().await;
let connection = Arc::new(opened?);
let id = connection.id().to_string();
state.opening_ports.remove(&port);
state.connections.insert(id.clone(), connection);
guard.clear();
Ok(id)
}
pub async fn insert(&self, connection: SerialConnection) -> Result<String> {
let mut state = self.state.lock().await;
if let Some(existing) = find_connection_by_port(&state.connections, connection.port()) {
return Err(SerialError::PortAlreadyOpen {
port: connection.port().to_string(),
connection_id: Some(existing.id().to_string()),
name: existing.name().map(str::to_string),
});
}
if state.opening_ports.contains(connection.port())
|| state.closing_ports.contains(connection.port())
{
return Err(SerialError::PortAlreadyOpening(
connection.port().to_string(),
));
}
let id = connection.id().to_string();
state.connections.insert(id.clone(), Arc::new(connection));
Ok(id)
}
pub async fn close(&self, id: &str) -> Result<()> {
let connection = {
let mut state = self.state.lock().await;
let connection = state
.connections
.remove(id)
.ok_or_else(|| SerialError::ConnectionNotFound(id.to_string()))?;
state.closing_ports.insert(connection.port().to_string());
connection
};
let port = connection.port().to_string();
{
let mut state = self.state.lock().await;
if let Some(handle) = state.reconnect_tasks.remove(id) {
handle.abort();
}
}
connection.log().closed();
let result = connection.close().await;
self.state.lock().await.closing_ports.remove(&port);
result
}
pub async fn get(&self, id: &str) -> Result<Arc<SerialConnection>> {
self.state
.lock()
.await
.connections
.get(id)
.cloned()
.ok_or_else(|| SerialError::ConnectionNotFound(id.to_string()))
}
pub async fn list_all(&self) -> Vec<(String, Arc<SerialConnection>)> {
self.state
.lock()
.await
.connections
.iter()
.map(|(k, v)| (k.clone(), Arc::clone(v)))
.collect()
}
pub async fn start_reconnect(
&self,
id: &str,
rx_sessions: Arc<crate::rx_session::RxSessionManager>,
) {
let conn = match self.get(id).await {
Ok(c) => c,
Err(_) => return,
};
let policy = conn.reconnect_policy.lock().expect("poisoned").clone();
if !policy.enabled {
return;
}
{
let mut state = self.state.lock().await;
state.reconnect_tasks.retain(|_, h| !h.is_finished());
if state.reconnect_tasks.contains_key(id) {
return;
}
}
let id_owned = id.to_string();
let conn_clone = Arc::clone(&conn);
let handle = tokio::spawn(async move {
let mut delay_ms = policy.initial_delay_ms;
let mut attempts: u32 = 0;
loop {
let state = conn_clone.state();
if state == ConnectionState::Open || state == ConnectionState::Closed {
break;
}
tokio::time::sleep(std::time::Duration::from_millis(delay_ms)).await;
match conn_clone.reconnect().await {
Ok(()) => {
conn_clone.reset_reconnect_attempts();
if let Some(session) = rx_sessions.get(&id_owned).await {
session.ensure_pump_running();
}
break;
}
Err(_e) => {
attempts += 1;
if policy.max_attempts > 0 && attempts >= policy.max_attempts {
conn_clone
.log()
.record(None, crate::log_buffer::LogEvent::ReconnectExhausted);
break;
}
delay_ms = ((delay_ms as f64) * policy.backoff_multiplier)
.min(policy.max_delay_ms as f64)
as u64;
}
}
}
});
let mut state = self.state.lock().await;
state.reconnect_tasks.insert(id.to_string(), handle);
}
pub async fn cancel_reconnect(&self, id: &str) {
let mut state = self.state.lock().await;
if let Some(handle) = state.reconnect_tasks.remove(id) {
handle.abort();
}
}
pub async fn count(&self) -> usize {
self.state.lock().await.connections.len()
}
pub async fn list_open(&self) -> Vec<ConnectionSummary> {
self.state
.lock()
.await
.connections
.values()
.map(|c| c.summary())
.collect()
}
}
fn find_connection_by_port<'a>(
connections: &'a HashMap<String, Arc<SerialConnection>>,
port: &str,
) -> Option<&'a Arc<SerialConnection>> {
connections.values().find(|c| c.port() == port)
}
#[cfg(test)]
mod tests {
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use tokio::sync::{watch, Notify};
use super::*;
use crate::serial::test_support::{loopback_connection, loopback_connection_with_config};
use crate::serial::{DataBits, FlowControl, Parity, StopBits};
fn test_config(port: &str) -> ConnectionConfig {
ConnectionConfig {
port: port.into(),
name: Some("opener-test".into()),
baud_rate: 9600,
data_bits: DataBits::Eight,
stop_bits: StopBits::One,
parity: Parity::None,
flow_control: FlowControl::None,
port_info: None,
log_capacity: 1024,
log_enabled: true,
tx_framing: None,
rx_framing: None,
rx_parser: None,
protocol: None,
rx_buffer_size: 8192,
max_buffered_bytes: 4096,
}
}
#[tokio::test]
async fn manager_rejects_duplicate_port() {
let mgr = ConnectionManager::new();
let (c1, _p1) = loopback_connection("port-a");
mgr.insert(c1).await.unwrap();
let (c2, _p2) = loopback_connection("port-a");
let err = mgr.insert(c2).await.unwrap_err();
assert!(matches!(err, SerialError::PortAlreadyOpen { .. }));
}
#[tokio::test]
async fn manager_duplicate_port_error_includes_owner_metadata() {
let mgr = ConnectionManager::new();
let (c1, _peer_a) = loopback_connection_with_config(ConnectionConfig {
port: "port-owner".into(),
name: Some("console".into()),
baud_rate: 115200,
data_bits: DataBits::Eight,
stop_bits: StopBits::One,
parity: Parity::None,
flow_control: FlowControl::None,
port_info: None,
log_capacity: 1024,
log_enabled: true,
tx_framing: None,
rx_framing: None,
rx_parser: None,
protocol: None,
rx_buffer_size: crate::limits::DEFAULT_RX_BUFFER_SIZE,
max_buffered_bytes: 32768,
});
let owner_id = mgr.insert(c1).await.unwrap();
let (c2, _p2) = loopback_connection("port-owner");
let err = mgr.insert(c2).await.unwrap_err();
match err {
SerialError::PortAlreadyOpen {
port,
connection_id,
name,
} => {
assert_eq!(port, "port-owner");
assert_eq!(connection_id.as_deref(), Some(owner_id.as_str()));
assert_eq!(name.as_deref(), Some("console"));
}
other => panic!("unexpected error: {other:?}"),
}
}
#[tokio::test]
async fn manager_close_then_get_returns_connection_not_found() {
let mgr = ConnectionManager::new();
let (c, _p) = loopback_connection("port-z");
let id = mgr.insert(c).await.unwrap();
mgr.close(&id).await.unwrap();
let err = mgr.get(&id).await.unwrap_err();
assert!(matches!(err, SerialError::ConnectionNotFound(_)));
}
#[tokio::test]
async fn manager_get_unknown_id_returns_connection_not_found() {
let mgr = ConnectionManager::new();
let err = mgr.get("does-not-exist").await.unwrap_err();
assert!(matches!(err, SerialError::ConnectionNotFound(_)));
}
#[tokio::test]
async fn injected_opener_receives_requested_config_and_open_is_retrievable() {
struct RecordingOpener {
configs: std::sync::Mutex<Vec<ConnectionConfig>>,
}
#[async_trait::async_trait]
impl ConnectionOpener for RecordingOpener {
async fn open(&self, config: ConnectionConfig) -> Result<SerialConnection> {
self.configs
.lock()
.expect("opener configs poisoned")
.push(config.clone());
let (conn, _peer) = loopback_connection_with_config(config);
Ok(conn)
}
}
let opener = Arc::new(RecordingOpener {
configs: std::sync::Mutex::new(Vec::new()),
});
let mgr = ConnectionManager::with_opener(opener.clone());
let config = test_config("opener-port");
let id = mgr.open(config.clone()).await.unwrap();
let received = opener
.configs
.lock()
.expect("opener configs poisoned")
.clone();
assert_eq!(received.len(), 1, "opener invoked exactly once");
let received_cfg = &received[0];
assert_eq!(received_cfg.port, "opener-port");
assert_eq!(received_cfg.name.as_deref(), Some("opener-test"));
assert_eq!(received_cfg.baud_rate, 9600);
assert_eq!(received_cfg.rx_buffer_size, 8192);
assert_eq!(received_cfg.max_buffered_bytes, 4096);
let conn = mgr.get(&id).await.unwrap();
assert_eq!(conn.port(), "opener-port");
assert_eq!(conn.name(), Some("opener-test"));
assert_eq!(conn.baud_rate(), 9600);
}
#[tokio::test]
async fn opener_failure_releases_opening_reservation_for_later_open() {
struct FailFirstOpener {
failures: AtomicUsize,
}
#[async_trait::async_trait]
impl ConnectionOpener for FailFirstOpener {
async fn open(&self, config: ConnectionConfig) -> Result<SerialConnection> {
if self.failures.swap(0, Ordering::SeqCst) > 0 {
return Err(SerialError::IoError(std::io::Error::other(
"injected opener failure",
)));
}
let (conn, _peer) = loopback_connection_with_config(config);
Ok(conn)
}
}
let mgr = ConnectionManager::with_opener(Arc::new(FailFirstOpener {
failures: AtomicUsize::new(1),
}));
let config = test_config("reservation-port");
let first = mgr.open(config.clone()).await;
assert!(
matches!(first, Err(SerialError::IoError(_))),
"first open fails through the opener: {first:?}"
);
let id = mgr
.open(config)
.await
.expect("opening reservation released after opener failure");
let conn = mgr.get(&id).await.unwrap();
assert_eq!(conn.port(), "reservation-port");
}
#[tokio::test]
async fn concurrent_same_port_open_reserves_port_and_second_open_is_rejected() {
struct GatedOpener {
entered: watch::Sender<bool>,
release: Arc<Notify>,
invocations: AtomicUsize,
}
#[async_trait::async_trait]
impl ConnectionOpener for GatedOpener {
async fn open(&self, config: ConnectionConfig) -> Result<SerialConnection> {
self.invocations.fetch_add(1, Ordering::SeqCst);
let _ = self.entered.send(true);
self.release.notified().await;
let (conn, _peer) = loopback_connection_with_config(config);
Ok(conn)
}
}
let (entered_tx, mut entered_rx) = watch::channel(false);
let release = Arc::new(Notify::new());
let opener = Arc::new(GatedOpener {
entered: entered_tx,
release: Arc::clone(&release),
invocations: AtomicUsize::new(0),
});
let mgr = Arc::new(ConnectionManager::with_opener(opener.clone()));
let config = test_config("concurrent-port");
let mgr_for_task = Arc::clone(&mgr);
let config_for_task = config.clone();
let first_task = tokio::spawn(async move { mgr_for_task.open(config_for_task).await });
tokio::time::timeout(
std::time::Duration::from_secs(5),
entered_rx.wait_for(|e| *e),
)
.await
.expect("first open reached the opener within the hang guard")
.expect("opener signalled entry");
let second = mgr.open(config).await.unwrap_err();
assert!(
matches!(second, SerialError::PortAlreadyOpening(ref port) if port == "concurrent-port"),
"concurrent same-port open rejected while opening: {second:?}"
);
assert_eq!(
opener.invocations.load(Ordering::SeqCst),
1,
"the reservation prevents a second opener invocation"
);
release.notify_one();
let first_id = first_task
.await
.expect("first open task")
.expect("first open succeeds after release");
let conn = mgr.get(&first_id).await.unwrap();
assert_eq!(conn.port(), "concurrent-port");
assert_eq!(mgr.count().await, 1, "exactly one connection registered");
}
#[tokio::test]
async fn cancelled_open_releases_opening_reservation_for_later_open() {
struct CancelGatedOpener {
entered: watch::Sender<bool>,
invocations: AtomicUsize,
}
#[async_trait::async_trait]
impl ConnectionOpener for CancelGatedOpener {
async fn open(&self, config: ConnectionConfig) -> Result<SerialConnection> {
if self.invocations.fetch_add(1, Ordering::SeqCst) == 0 {
let _ = self.entered.send(true);
std::future::pending::<()>().await;
unreachable!("aborted before pending resolves");
}
let (conn, _peer) = loopback_connection_with_config(config);
Ok(conn)
}
}
let (entered_tx, mut entered_rx) = watch::channel(false);
let opener = Arc::new(CancelGatedOpener {
entered: entered_tx,
invocations: AtomicUsize::new(0),
});
let mgr = Arc::new(ConnectionManager::with_opener(opener.clone()));
let config = test_config("cancel-port");
let mgr_for_task = Arc::clone(&mgr);
let config_for_task = config.clone();
let task = tokio::spawn(async move { mgr_for_task.open(config_for_task).await });
tokio::time::timeout(
std::time::Duration::from_secs(5),
entered_rx.wait_for(|e| *e),
)
.await
.expect("hang guard: first open reached the opener")
.expect("opener signalled entry");
task.abort();
let join = tokio::time::timeout(std::time::Duration::from_secs(5), task)
.await
.expect("hang guard: cancelled open task joined");
assert!(
join.is_err(),
"open task was aborted, not completed: {join:?}"
);
let id = tokio::time::timeout(std::time::Duration::from_secs(5), mgr.open(config))
.await
.expect("hang guard: second open after cancellation")
.expect("second open succeeds after cancellation cleanup");
let conn = mgr.get(&id).await.unwrap();
assert_eq!(conn.port(), "cancel-port");
assert_eq!(mgr.count().await, 1, "exactly one connection registered");
assert_eq!(
opener.invocations.load(Ordering::SeqCst),
2,
"the retry invoked the opener again"
);
}
}