use std::sync::{Arc, Mutex};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConnectionState {
Unknown,
Discovering,
Ready(u32),
Dead(u32),
Reconnecting,
}
pub fn is_valid_transition(from: ConnectionState, to: ConnectionState) -> bool {
match (from, to) {
(ConnectionState::Unknown, ConnectionState::Discovering) => true,
(ConnectionState::Dead(_), ConnectionState::Discovering) => true,
(ConnectionState::Reconnecting, ConnectionState::Discovering) => true,
(ConnectionState::Discovering, ConnectionState::Ready(_)) => true,
(ConnectionState::Discovering, ConnectionState::Dead(_)) => true,
(ConnectionState::Ready(_), ConnectionState::Dead(_)) => true,
(ConnectionState::Dead(_), ConnectionState::Reconnecting) => true,
(ConnectionState::Reconnecting, ConnectionState::Ready(_)) => true,
(ConnectionState::Reconnecting, ConnectionState::Dead(_)) => true,
(ConnectionState::Ready(a), ConnectionState::Ready(b)) => a == b,
_ => false,
}
}
pub struct ClientCore {
reconnect_cb: Arc<dyn Fn(u32) + Send + Sync>,
state: Arc<Mutex<ConnectionState>>,
subscription: Mutex<Option<crate::node_supervisor::Subscription>>,
}
impl ClientCore {
pub fn new(service_name: &'static str) -> Self {
let state = Arc::new(Mutex::new(ConnectionState::Unknown));
let reconnect_cb = build_reconnect_cb(service_name, state.clone());
Self {
reconnect_cb,
state,
subscription: Mutex::new(None),
}
}
pub fn subscribe(&self, node_id: u32) {
let mut subscription = self
.subscription
.lock()
.expect("client core subscription lock poisoning");
if let Some(existing) = subscription.as_ref() {
if existing.node_id() == node_id {
return;
}
}
let cb = self.reconnect_cb.clone();
*subscription =
Some(crate::node_supervisor::NodeSupervisor::global().subscribe(node_id, cb));
}
pub fn cached_target_node(&self) -> u64 {
match *self.state.lock().expect("client core state lock poisoning") {
ConnectionState::Ready(n) => n as u64,
_ => 0,
}
}
pub fn start_discovery(&self) -> bool {
transition(&self.state, ConnectionState::Discovering)
}
pub fn store_target_node(&self, node_id: u32) -> bool {
transition(&self.state, ConnectionState::Ready(node_id))
}
pub fn mark_dead(&self, node_id: u32) -> bool {
transition(&self.state, ConnectionState::Dead(node_id))
}
pub fn mark_reconnecting(&self) -> bool {
transition(&self.state, ConnectionState::Reconnecting)
}
pub fn state(&self) -> ConnectionState {
*self.state.lock().expect("client core state lock poisoning")
}
pub async fn init(&self, service_name: &'static str) -> bool {
match crate::ServiceLocator::global().get_node_sync() {
Ok(_) => {}
Err(e) => {
log::error!("[{}Client] get_node failed: {}", service_name, e);
return false;
}
};
{
let locator = crate::ServiceLocator::global();
let _ = crate::rt::spawn_blocking(move || {
locator.start_discovery();
})
.await;
}
self.start_discovery();
let discovery = crate::ServiceLocator::global().node_discovery();
let target_node = match discovery.locate_service(service_name) {
Some(n) => n,
None => {
log::warn!(
"[{}Client] Service '{}' not detected yet (empty cache+Blackboard).",
service_name,
service_name
);
return false;
}
};
{
let locator = crate::ServiceLocator::global();
let _ = crate::rt::spawn_blocking(move || {
locator.start_dispatch_if_needed();
})
.await;
}
let result = crate::rt::spawn_blocking_value(move || {
crate::ServiceLocator::global()
.hub()
.ensure_publishers(target_node)
})
.await;
match result {
Ok(()) => {}
Err(e) => {
log::error!("[{}Client] ensure_publishers failed: {}", service_name, e);
return false;
}
}
self.store_target_node(target_node.0);
self.subscribe(target_node.0);
log::info!(
"[{}Client] Ready (publishers pre-created, centralized hub).",
service_name
);
true
}
}
fn transition(state: &Mutex<ConnectionState>, to: ConnectionState) -> bool {
let mut guard = state.lock().expect("client core state lock poisoning");
if is_valid_transition(*guard, to) {
*guard = to;
true
} else {
false
}
}
fn build_reconnect_cb(
service_name: &'static str,
state: Arc<Mutex<ConnectionState>>,
) -> Arc<dyn Fn(u32) + Send + Sync> {
let pending = Arc::new(crate::reconnect_manager::PendingService::new(
service_name,
state.clone(),
));
Arc::new(move |dead_node_id: u32| {
{
let mut guard = state.lock().expect("client core state lock poisoning");
if !is_valid_transition(*guard, ConnectionState::Dead(dead_node_id)) {
return;
}
*guard = ConnectionState::Dead(dead_node_id);
}
log::warn!(
"[{}Client] Node {} detected dead — reconnecting",
service_name,
dead_node_id
);
{
let mut guard = state.lock().expect("client core state lock poisoning");
if is_valid_transition(*guard, ConnectionState::Reconnecting) {
*guard = ConnectionState::Reconnecting;
}
}
crate::reconnect_manager::ReconnectManager::global().schedule(dead_node_id, pending.clone());
})
}
#[cfg(test)]
mod tests {
use super::*;
use ConnectionState::*;
#[test]
fn valid_transition_path() {
assert!(is_valid_transition(Unknown, Discovering));
assert!(is_valid_transition(Discovering, Ready(1)));
assert!(is_valid_transition(Ready(1), Dead(1)));
assert!(is_valid_transition(Dead(1), Reconnecting));
assert!(is_valid_transition(Reconnecting, Ready(2)));
}
#[test]
fn invalid_transitions() {
assert!(!is_valid_transition(Dead(1), Ready(2)));
assert!(!is_valid_transition(Unknown, Ready(1)));
assert!(!is_valid_transition(Ready(1), Ready(2)));
assert!(!is_valid_transition(Discovering, Discovering));
}
#[test]
fn client_core_rejects_ready_without_discovery() {
let core = ClientCore::new("svc");
assert_eq!(core.state(), Unknown);
assert!(!core.store_target_node(1));
assert!(core.start_discovery());
assert!(core.store_target_node(1));
assert_eq!(core.state(), Ready(1));
}
#[test]
fn client_core_rejects_dead_to_ready_directly() {
let core = ClientCore::new("svc");
core.start_discovery();
core.store_target_node(1);
core.mark_dead(1);
assert_eq!(core.state(), Dead(1));
assert!(!core.store_target_node(2));
assert!(core.mark_reconnecting());
assert!(core.store_target_node(2));
assert_eq!(core.state(), Ready(2));
}
}