use crate::backend::Backend;
use crate::types::ConnectionConfig;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
#[derive(Debug, Clone, PartialEq)]
pub enum ConnectionStatus {
Disconnected,
Connecting,
Connected,
Error(String),
}
pub struct ConnectionManager {
connections: HashMap<String, Arc<RwLock<Box<dyn Backend>>>>,
configs: HashMap<String, ConnectionConfig>,
statuses: HashMap<String, ConnectionStatus>,
active_id: Option<String>,
}
impl ConnectionManager {
pub fn new() -> Self {
Self {
connections: HashMap::new(),
configs: HashMap::new(),
statuses: HashMap::new(),
active_id: None,
}
}
pub fn add_connection(&mut self, config: ConnectionConfig) {
let id = config.id.clone();
self.statuses
.insert(id.clone(), ConnectionStatus::Disconnected);
self.configs.insert(id, config);
}
pub fn get_configs(&self) -> Vec<&ConnectionConfig> {
let mut configs: Vec<_> = self.configs.values().collect();
configs.sort_by(|a, b| a.name.cmp(&b.name));
configs
}
pub fn get_all_configs(&self) -> Vec<ConnectionConfig> {
let mut configs: Vec<_> = self.configs.values().cloned().collect();
configs.sort_by(|a, b| a.name.cmp(&b.name));
configs
}
pub fn load_configs(&mut self, configs: Vec<ConnectionConfig>) {
self.configs.clear();
self.statuses.clear();
for config in configs {
let id = config.id.clone();
self.statuses
.insert(id.clone(), ConnectionStatus::Disconnected);
self.configs.insert(id, config);
}
}
pub fn get_config(&self, id: &str) -> Option<&ConnectionConfig> {
self.configs.get(id)
}
pub fn set_status(&mut self, id: &str, status: ConnectionStatus) {
self.statuses.insert(id.to_string(), status);
}
pub fn register_connection(&mut self, id: &str, backend: Arc<RwLock<Box<dyn Backend>>>) {
self.connections.insert(id.to_string(), backend);
self.active_id = Some(id.to_string());
self.statuses
.insert(id.to_string(), ConnectionStatus::Connected);
}
pub async fn disconnect(&mut self, id: &str) -> Result<(), Box<dyn std::error::Error>> {
if let Some(backend_arc) = self.connections.remove(id) {
let mut backend = backend_arc.write().await;
backend.disconnect().await?;
}
self.statuses
.insert(id.to_string(), ConnectionStatus::Disconnected);
Ok(())
}
pub fn get_active_backend_handle(&self) -> Option<Arc<RwLock<Box<dyn Backend>>>> {
self.active_id
.as_ref()
.and_then(|id| self.connections.get(id))
.cloned()
}
pub fn get_active_id(&self) -> Option<&str> {
self.active_id.as_deref()
}
pub fn set_active(&mut self, id: &str) -> bool {
if self.configs.contains_key(id) {
self.active_id = Some(id.to_string());
true
} else {
false
}
}
pub fn is_connected(&self, id: &str) -> bool {
self.connections.contains_key(id)
}
pub fn remove_config(&mut self, id: &str) {
self.configs.remove(id);
self.connections.remove(id);
self.statuses.remove(id);
if self.active_id.as_deref() == Some(id) {
self.active_id = None;
}
}
pub fn get_status(&self, id: &str) -> ConnectionStatus {
self.statuses
.get(id)
.cloned()
.unwrap_or(ConnectionStatus::Disconnected)
}
pub fn get_statuses(&self) -> &HashMap<String, ConnectionStatus> {
&self.statuses
}
pub fn get_active_status(&self) -> Option<ConnectionStatus> {
self.active_id.as_ref().map(|id| self.get_status(id))
}
}
impl Default for ConnectionManager {
fn default() -> Self {
Self::new()
}
}