use super::driver::{DriverState, RaftDriver};
use super::transport::MemTransport;
use crate::config::BrokerConfig;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
pub struct RaftState {
pub leader_id: AtomicU64,
pub current_term: AtomicU64,
pub started: AtomicBool,
}
impl RaftState {
pub fn new() -> Self {
Self {
leader_id: AtomicU64::new(0),
current_term: AtomicU64::new(0),
started: AtomicBool::new(false),
}
}
}
impl Default for RaftState {
fn default() -> Self {
Self::new()
}
}
pub struct ClusterController {
pub config: Arc<BrokerConfig>,
pub raft_state: Arc<RaftState>,
driver_state: std::sync::Mutex<Option<Arc<DriverState>>>,
}
impl ClusterController {
pub fn new(config: Arc<BrokerConfig>) -> Self {
Self {
config,
raft_state: Arc::new(RaftState::new()),
driver_state: std::sync::Mutex::new(None),
}
}
pub fn is_controller(&self) -> bool {
if self.config.single_node {
return true;
}
if let Ok(guard) = self.driver_state.lock() {
if let Some(ds) = guard.as_ref() {
return ds.is_leader.load(Ordering::SeqCst);
}
}
let leader = self.raft_state.leader_id.load(Ordering::SeqCst);
leader == self.config.broker_id as u64 && leader != 0
}
pub fn on_topic_created(&self, topic: &str, partitions: i32, rf: i16) {
tracing::info!(
"元数据变更: 创建主题 {topic}, 分区={partitions}, 副本因子={rf}"
);
}
pub fn start_raft(
&self,
transport: MemTransport,
all_nodes: Vec<u64>,
) -> bool {
if self.config.single_node {
return false;
}
if self
.raft_state
.started
.swap(true, Ordering::SeqCst)
{
return false;
}
let id = self.config.broker_id as u64;
let peers: Vec<u64> = all_nodes.iter().copied().filter(|p| *p != id).collect();
let mut driver = RaftDriver::new(id, peers, transport);
let state = driver.state.clone();
*self.driver_state.lock().unwrap() = Some(state.clone());
let raft_state = self.raft_state.clone();
driver.start(Arc::new(move |_entries: &[crate::cluster::raft::LogEntry]| {
raft_state
.leader_id
.store(if state.is_leader.load(Ordering::SeqCst) {
id
} else {
0
}, Ordering::SeqCst);
raft_state
.current_term
.store(state.current_term.load(Ordering::SeqCst), Ordering::SeqCst);
}));
std::mem::forget(driver);
true
}
}