use crate::error::CoreError;
use crate::service::{ServiceBuilder, ServiceConfig, ServiceInfo};
use crate::webhook_service::BoxedWebhookSender;
use rustc_hash::FxHashMap;
use std::sync::Arc;
#[derive(Default, Clone)]
pub struct WebhookRegistry {
services: Arc<FxHashMap<String, Arc<ServiceInfo>>>,
builders: Arc<FxHashMap<String, Arc<dyn ServiceBuilder + Send + Sync>>>,
}
impl WebhookRegistry {
pub fn new() -> Self {
Self::default()
}
pub fn register<S>(&mut self, builder: S)
where
S: ServiceBuilder + Send + Sync + 'static,
{
let info = builder.info();
let name = info.name.clone();
let mut services = match Arc::try_unwrap(std::mem::take(&mut self.services)) {
Ok(map) => map,
Err(arc) => (*arc).clone(),
};
let mut builders = match Arc::try_unwrap(std::mem::take(&mut self.builders)) {
Ok(map) => map,
Err(arc) => (*arc).clone(),
};
services.insert(name.clone(), info);
builders.insert(name, Arc::new(builder));
self.services = Arc::new(services);
self.builders = Arc::new(builders);
}
pub fn get_service_info(&self, name: &str) -> Option<Arc<ServiceInfo>> {
self.services.get(name).cloned()
}
pub fn list_services(&self) -> Vec<Arc<ServiceInfo>> {
self.services.values().cloned().collect()
}
pub fn create_sender(
&self,
service_name: &str,
config: ServiceConfig,
) -> Result<BoxedWebhookSender, CoreError> {
let builder = self
.builders
.get(service_name)
.ok_or_else(|| CoreError::ServiceNotFound(service_name.to_string()))?;
builder
.build(config)
.map_err(|e| CoreError::ServiceCreationFailed(e.to_string()))
}
pub fn has_service(&self, name: &str) -> bool {
self.services.contains_key(name)
}
}