use std::any::Any;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use async_lock::RwLock;
use crate::global::Global;
use crate::service_traits::{ServiceConsumer, ServiceInit, ServiceLifecycle, ServiceNamed};
#[derive(Clone)]
struct ServiceEntry {
instance: Arc<dyn Any + Send + Sync>,
lifecycle: Arc<dyn ServiceLifecycle>,
init: Arc<dyn ServiceInit>,
}
pub struct ServiceLocator {
entries: RwLock<HashMap<&'static str, ServiceEntry>>,
lazy_cache: RwLock<HashMap<&'static str, Arc<dyn Any + Send + Sync>>>,
shutdown_registry: crate::shutdown::ShutdownRegistry,
}
impl ServiceLocator {
pub fn global() -> &'static Self {
static INSTANCE: Global<ServiceLocator> = Global::new();
INSTANCE.get_or_init(|| Self {
entries: RwLock::new(HashMap::new()),
lazy_cache: RwLock::new(HashMap::new()),
shutdown_registry: crate::shutdown::ShutdownRegistry::new(),
})
}
pub fn service_count(&self) -> u8 {
self.entries.try_read().map(|e| e.len() as u8).unwrap_or(0)
}
pub fn service_names(&self) -> Vec<&'static str> {
self.entries
.try_read()
.map(|e| e.keys().copied().collect())
.unwrap_or_default()
}
pub fn register_shutdown_handle(&self, handle: crate::rt::BlockingHandle) {
self.shutdown_registry.register(handle);
}
pub fn register_shutdown_thread(&self, handle: std::thread::JoinHandle<()>) {
self.shutdown_registry.register_thread(handle);
}
pub async fn release_node(&self) {
self.shutdown_registry.join_all().await;
}
pub fn release_node_blocking(&self) {
crate::rt::block_on(self.release_node());
}
pub async fn get<T: ServiceConsumer>(&self) -> Option<Arc<T>> {
let name = T::SERVICE_NAME;
{
let entries = self.entries.read().await;
if let Some(entry) = entries.get(name) {
return entry.instance.clone().downcast::<T>().ok();
}
}
{
let cache = self.lazy_cache.read().await;
if let Some(instance) = cache.get(name) {
return instance.clone().downcast::<T>().ok();
}
}
let proxy: Arc<T> = T::consume_proxy();
self.lazy_cache
.write()
.await
.entry(name)
.or_insert_with(|| proxy.clone() as Arc<dyn Any + Send + Sync>);
Some(proxy)
}
pub fn get_blocking<T: ServiceConsumer>(&self) -> Option<Arc<T>> {
let name = T::SERVICE_NAME;
{
let entries = self.entries.read_blocking();
if let Some(entry) = entries.get(name) {
return entry.instance.clone().downcast::<T>().ok();
}
}
{
let cache = self.lazy_cache.read_blocking();
if let Some(instance) = cache.get(name) {
return instance.clone().downcast::<T>().ok();
}
}
let proxy: Arc<T> = T::consume_proxy();
self.lazy_cache
.write_blocking()
.entry(name)
.or_insert_with(|| proxy.clone() as Arc<dyn Any + Send + Sync>);
Some(proxy)
}
pub async fn register<T>(&self, service: Arc<T>)
where
T: ServiceLifecycle + ServiceNamed + ServiceInit + Any + Send + Sync + 'static,
{
let name: &'static str = T::SERVICE_NAME;
let instance = service.clone() as Arc<dyn Any + Send + Sync>;
let init = service.clone() as Arc<dyn ServiceInit>;
let lifecycle = service as Arc<dyn ServiceLifecycle>;
self.entries.write().await.insert(
name,
ServiceEntry {
instance,
lifecycle,
init,
},
);
}
pub async fn initialize_all(&self) -> Result<(), String> {
let snapshot: Vec<(&'static str, Arc<dyn ServiceLifecycle>, Vec<&'static str>)> = {
let entries = self.entries.read().await;
entries
.iter()
.map(|(name, entry)| (*name, entry.lifecycle.clone(), entry.init.dependencies()))
.collect()
};
let names: Vec<&'static str> = snapshot.iter().map(|(name, _, _)| *name).collect();
let deps: Vec<Vec<&'static str>> =
snapshot.iter().map(|(_, _, deps)| deps.clone()).collect();
for i in topological_order(&names, &deps) {
let (name, lifecycle, _) = &snapshot[i];
if !lifecycle.init().await {
log::error!("[ServiceLocator] service '{name}' failed to initialize");
return Err(format!("service '{name}' failed to initialize"));
}
}
crate::transport::start_registered_channels();
Ok(())
}
}
fn topological_order(names: &[&'static str], deps: &[Vec<&'static str>]) -> Vec<usize> {
let registered: HashSet<&'static str> = names.iter().copied().collect();
let mut remaining: Vec<usize> = (0..names.len()).collect();
let mut done: HashSet<&'static str> = HashSet::with_capacity(names.len());
let mut order: Vec<usize> = Vec::with_capacity(names.len());
while !remaining.is_empty() {
let mut next_remaining = Vec::new();
let mut progressed = false;
for &i in &remaining {
let ready = deps[i]
.iter()
.all(|dep| done.contains(dep) || !registered.contains(dep));
if ready {
order.push(i);
done.insert(names[i]);
progressed = true;
} else {
next_remaining.push(i);
}
}
remaining = next_remaining;
if !progressed {
log::warn!(
"[ServiceLocator] dependency cycle among {:?}; using registration order",
remaining.iter().map(|&i| names[i]).collect::<Vec<_>>()
);
order.append(&mut remaining);
}
}
order
}
#[cfg(test)]
mod tests {
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
use super::*;
fn locator_lock() -> &'static Mutex<()> {
static LOCK: Mutex<()> = Mutex::new(());
&LOCK
}
struct MockState {
init_result: bool,
dependencies: Vec<&'static str>,
init_calls: Arc<AtomicUsize>,
init_order: Arc<Mutex<Vec<&'static str>>>,
}
impl Default for MockState {
fn default() -> Self {
Self {
init_result: true,
dependencies: Vec::new(),
init_calls: Arc::new(AtomicUsize::new(0)),
init_order: Arc::new(Mutex::new(Vec::new())),
}
}
}
macro_rules! provider_mock {
($name:ident, $service:literal) => {
struct $name(MockState);
impl ServiceNamed for $name {
const SERVICE_NAME: &'static str = $service;
}
#[async_trait::async_trait]
impl ServiceInit for $name {
fn dependencies(&self) -> Vec<&'static str> {
self.0.dependencies.clone()
}
}
#[async_trait::async_trait]
impl ServiceLifecycle for $name {
async fn init(&self) -> bool {
self.0.init_calls.fetch_add(1, Ordering::Relaxed);
if let Ok(mut order) = self.0.init_order.lock() {
order.push($service);
}
self.0.init_result
}
}
};
}
provider_mock!(EchoService, "LocatorEcho");
static ECHO_PROXY_CREATIONS: AtomicUsize = AtomicUsize::new(0);
impl ServiceConsumer for EchoService {
fn consume_proxy() -> Arc<Self> {
ECHO_PROXY_CREATIONS.fetch_add(1, Ordering::Relaxed);
Arc::new(EchoService(MockState::default()))
}
}
static CONFIG_PROXY_CREATIONS: AtomicUsize = AtomicUsize::new(0);
struct ConfigService;
impl ServiceNamed for ConfigService {
const SERVICE_NAME: &'static str = "LocatorConfig";
}
impl ServiceConsumer for ConfigService {
fn consume_proxy() -> Arc<Self> {
CONFIG_PROXY_CREATIONS.fetch_add(1, Ordering::Relaxed);
Arc::new(ConfigService)
}
}
provider_mock!(NamesakeProvider, "LocatorNamesake");
struct NamesakeConsumer;
impl ServiceNamed for NamesakeConsumer {
const SERVICE_NAME: &'static str = "LocatorNamesake";
}
impl ServiceConsumer for NamesakeConsumer {
fn consume_proxy() -> Arc<Self> {
Arc::new(NamesakeConsumer)
}
}
provider_mock!(FirstService, "LocatorFirst");
provider_mock!(SecondService, "LocatorSecond");
provider_mock!(BrokenService, "LocatorBroken");
#[test]
fn a_registered_provider_is_handed_back_without_a_proxy() {
let _guard = locator_lock().lock().unwrap_or_else(|e| e.into_inner());
let locator = ServiceLocator::global();
let state = MockState {
init_result: true,
..MockState::default()
};
let init_calls = state.init_calls.clone();
let provider = Arc::new(EchoService(state));
let before = locator.service_count();
pollster::block_on(locator.register(provider.clone()));
assert_eq!(locator.service_count(), before + 1);
assert!(locator.service_names().contains(&"LocatorEcho"));
let fetched = pollster::block_on(locator.get::<EchoService>())
.expect("a registered provider is returned");
assert!(
Arc::ptr_eq(&fetched, &provider),
"the very same instance must come back"
);
assert_eq!(
ECHO_PROXY_CREATIONS.load(Ordering::Relaxed),
0,
"the registered path must not build a proxy"
);
assert_eq!(
init_calls.load(Ordering::Relaxed),
0,
"registering a service runs no initialization hook"
);
}
#[test]
fn an_unregistered_service_is_built_once_and_cached() {
let _guard = locator_lock().lock().unwrap_or_else(|e| e.into_inner());
let locator = ServiceLocator::global();
let first = pollster::block_on(locator.get::<ConfigService>()).expect("a proxy is built");
let second = pollster::block_on(locator.get::<ConfigService>()).expect("the cache answers");
assert!(Arc::ptr_eq(&first, &second), "the cached proxy is reused");
assert_eq!(first.service_name(), "LocatorConfig");
assert_eq!(CONFIG_PROXY_CREATIONS.load(Ordering::Relaxed), 1);
assert!(!locator.service_names().contains(&"LocatorConfig"));
}
#[test]
fn a_name_registered_under_another_type_is_not_returned() {
let _guard = locator_lock().lock().unwrap_or_else(|e| e.into_inner());
let locator = ServiceLocator::global();
pollster::block_on(locator.register(Arc::new(NamesakeProvider(MockState::default()))));
assert!(pollster::block_on(locator.get::<NamesakeConsumer>()).is_none());
}
#[test]
fn initialize_all_orders_dependencies_and_reports_a_failure() {
let _guard = locator_lock().lock().unwrap_or_else(|e| e.into_inner());
let locator = ServiceLocator::global();
let init_order: Arc<Mutex<Vec<&'static str>>> = Arc::new(Mutex::new(Vec::new()));
let second = Arc::new(SecondService(MockState {
init_order: init_order.clone(),
..MockState::default()
}));
let first = Arc::new(FirstService(MockState {
dependencies: vec!["LocatorSecond"],
init_order: init_order.clone(),
..MockState::default()
}));
pollster::block_on(locator.register(first.clone()));
pollster::block_on(locator.register(second.clone()));
pollster::block_on(locator.initialize_all()).expect("every service initializes");
let recorded = init_order.lock().expect("init order").clone();
let first_at = recorded
.iter()
.position(|name| *name == "LocatorFirst")
.expect("First was initialized");
let second_at = recorded
.iter()
.position(|name| *name == "LocatorSecond")
.expect("Second was initialized");
assert!(
second_at < first_at,
"a dependency must initialize first: {recorded:?}"
);
assert_eq!(first.0.init_calls.load(Ordering::Relaxed), 1);
assert_eq!(second.0.init_calls.load(Ordering::Relaxed), 1);
let broken = Arc::new(BrokenService(MockState {
init_result: false,
..MockState::default()
}));
pollster::block_on(locator.register(broken));
let error = pollster::block_on(locator.initialize_all()).expect_err("the pass fails");
assert!(error.contains("LocatorBroken"), "{error}");
}
#[test]
fn shutdown_handles_are_registered_on_the_locator() {
let _guard = locator_lock().lock().unwrap_or_else(|e| e.into_inner());
let locator = ServiceLocator::global();
locator.register_shutdown_handle(crate::rt::spawn_blocking(|| {}));
locator.register_shutdown_thread(std::thread::spawn(|| {}));
}
#[test]
fn dependencies_come_first() {
let names = ["DatabaseService", "ConfigService"];
let deps = [vec!["ConfigService"], vec![]];
assert_eq!(topological_order(&names, &deps), vec![1, 0]);
}
#[test]
fn independent_services_keep_the_registration_order() {
let names = ["A", "B", "C"];
let deps = [vec![], vec![], vec![]];
assert_eq!(topological_order(&names, &deps), vec![0, 1, 2]);
}
#[test]
fn external_dependencies_do_not_block() {
let names = ["A"];
let deps = [vec!["RemoteService"]];
assert_eq!(topological_order(&names, &deps), vec![0]);
}
#[test]
fn a_cycle_falls_back_to_the_registration_order() {
let names = ["A", "B"];
let deps = [vec!["B"], vec!["A"]];
let order = topological_order(&names, &deps);
assert_eq!(order.len(), 2);
assert!(order.contains(&0) && order.contains(&1));
}
#[test]
fn chained_dependencies_are_fully_ordered() {
let names = ["C", "B", "A"];
let deps = [vec!["B"], vec!["A"], vec![]];
assert_eq!(topological_order(&names, &deps), vec![2, 1, 0]);
}
#[test]
fn a_dependency_registered_by_another_process_is_external() {
let names = ["LocatorFirst"];
let deps = [vec!["LocatorSecond"]];
assert_eq!(topological_order(&names, &deps), vec![0]);
}
#[test]
fn a_self_dependency_is_a_cycle() {
let names = ["A"];
let deps = [vec!["A"]];
assert_eq!(topological_order(&names, &deps), vec![0]);
}
#[test]
fn an_empty_registry_orders_nothing() {
assert!(topological_order(&[], &[]).is_empty());
}
#[test]
fn get_blocking_hands_back_the_registered_provider() {
let _guard = locator_lock().lock().unwrap_or_else(|e| e.into_inner());
let locator = ServiceLocator::global();
let provider = Arc::new(EchoService(MockState::default()));
pollster::block_on(locator.register(provider.clone()));
let fetched = locator
.get_blocking::<EchoService>()
.expect("a registered provider is returned");
assert!(Arc::ptr_eq(&fetched, &provider));
}
#[test]
fn get_blocking_builds_and_caches_a_consumer_proxy() {
let _guard = locator_lock().lock().unwrap_or_else(|e| e.into_inner());
let locator = ServiceLocator::global();
let first = locator
.get_blocking::<ConfigService>()
.expect("a proxy is built");
let second = locator
.get_blocking::<ConfigService>()
.expect("the cache answers");
assert!(Arc::ptr_eq(&first, &second), "the cached proxy is reused");
assert_eq!(first.service_name(), "LocatorConfig");
assert!(!locator.service_names().contains(&"LocatorConfig"));
}
}