use std::sync::{Arc, Mutex};
use crate::futures::FutureExt;
#[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 async fn resolve_target(
&self,
service_name: &str,
timeout_secs: u64,
) -> Result<crate::NodeId, crate::RpcError> {
let cached = self.cached_target_node();
if cached != 0 {
let node_id = cached as u32;
self.subscribe(node_id);
return Ok(crate::NodeId(node_id));
}
self.start_discovery();
let discovery = crate::ServiceLocator::global().node_discovery();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs);
let mut node = discovery.locate_service(service_name);
while node.is_none() && std::time::Instant::now() < deadline {
crate::futures::select! {
_ = crate::global_cancel_token().cancelled().fuse() => {
return Err(crate::RpcError::Cancelled);
}
_ = crate::rt::sleep(
std::time::Duration::from_millis(crate::SERVER_READY_POLL_MS)
).fuse() => {}
}
node = discovery.locate_service(service_name);
}
let nid = node.ok_or_else(|| crate::RpcError::ServiceNotFound {
service: service_name.to_string(),
})?;
crate::ServiceLocator::global()
.hub()
.ensure_publishers(nid)
.map_err(|e| {
log::warn!("[{}Client] ensure_publishers failed: {}", service_name, e);
crate::RpcError::ProviderUnavailable { node: nid.0 }
})?;
self.store_target_node(nid.0);
Ok(nid)
}
pub fn start_discovery(&self) -> bool {
transition(&self.state, ConnectionState::Discovering)
}
pub fn store_target_node(&self, node_id: u32) -> bool {
if transition(&self.state, ConnectionState::Ready(node_id)) {
self.subscribe(node_id);
true
} else {
false
}
}
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));
}
#[test]
fn resolve_target_returns_cached_node_when_ready() {
let core = ClientCore::new("svc");
core.start_discovery();
core.store_target_node(42);
let node = pollster::block_on(core.resolve_target("svc", 30)).unwrap();
assert_eq!(node.0, 42);
}
}