use super::offset_store::OffsetStore;
use crate::protocol::error_codes;
use crate::server::metadata::MetadataManager;
use bytes::Bytes;
use dashmap::DashMap;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::Instant;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GroupState {
Empty,
PreparingRebalance,
CompletingRebalance,
Stable,
}
#[derive(Debug, Clone)]
pub struct Member {
pub member_id: String,
pub session_timeout_ms: i32,
pub rebalance_timeout_ms: i32,
pub protocols: Vec<(String, Bytes)>,
pub last_heartbeat: Instant,
pub assignment: Bytes,
pub metadata: Bytes,
}
#[derive(Debug, Clone)]
pub struct Group {
pub group_id: String,
pub state: GroupState,
pub generation_id: i32,
pub leader_id: Option<String>,
pub protocol: Option<String>,
pub members: HashMap<String, Member>,
pub protocol_type: String,
}
impl Group {
pub fn new(group_id: &str) -> Self {
Self {
group_id: group_id.to_string(),
state: GroupState::Empty,
generation_id: 0,
leader_id: None,
protocol: None,
members: HashMap::new(),
protocol_type: String::new(),
}
}
}
pub struct GroupCoordinator {
pub groups: DashMap<String, Group>,
pub offset_store: Arc<Mutex<OffsetStore>>,
pub offsets_topic_partitions: i32,
}
impl GroupCoordinator {
pub fn new(metadata: Arc<MetadataManager>) -> Self {
let offset_store = Arc::new(Mutex::new(OffsetStore::new(metadata)));
Self {
groups: DashMap::new(),
offset_store,
offsets_topic_partitions: 50,
}
}
pub fn init(&self) {
self.offset_store.lock().unwrap().ensure_created();
self.offset_store.lock().unwrap().recover();
}
pub fn spawn_expiry_cleanup(&self) {
let groups = self.groups.clone();
tokio::spawn(async move {
let mut interval = tokio::time::interval(std::time::Duration::from_secs(5));
interval.tick().await; loop {
interval.tick().await;
let now = Instant::now();
for mut entry in groups.iter_mut() {
let group = entry.value_mut();
let expired: Vec<String> = group
.members
.iter()
.filter(|(_, m)| {
now.duration_since(m.last_heartbeat).as_millis()
> m.session_timeout_ms as u128
})
.map(|(id, _)| id.clone())
.collect();
if !expired.is_empty() {
for id in &expired {
group.members.remove(id);
}
if !group.members.is_empty() {
group.state = GroupState::PreparingRebalance;
group.leader_id = None;
group.protocol = None;
tracing::debug!(
"组 {} 成员过期被移除: {:?},触发 Rebalance",
group.group_id,
expired
);
} else {
group.state = GroupState::Empty;
}
}
}
}
});
}
pub fn coordinator_partition(&self, group_id: &str) -> i32 {
let hash = stable_hash(group_id);
(hash % (self.offsets_topic_partitions as u64)) as i32
}
pub fn join_group(
&self,
group_id: &str,
session_timeout_ms: i32,
rebalance_timeout_ms: i32,
member_id: &str,
protocol_type: &str,
protocols: Vec<(String, Bytes)>,
) -> (i16, i32, String, String, Option<String>, Vec<(String, Bytes)>) {
if session_timeout_ms < 0 {
return (error_codes::INVALID_SESSION_TIMEOUT, 0, String::new(), String::new(), None, vec![]);
}
let mut group = self
.groups
.entry(group_id.to_string())
.or_insert_with(|| Group::new(group_id));
if !group.protocol_type.is_empty() && group.protocol_type != protocol_type {
return (
error_codes::INCONSISTENT_GROUP_PROTOCOL,
0,
String::new(),
String::new(),
None,
vec![],
);
}
if protocols.is_empty() {
return (
error_codes::INCONSISTENT_GROUP_PROTOCOL,
0,
String::new(),
String::new(),
None,
vec![],
);
}
let now = Instant::now();
let expired: Vec<String> = group
.members
.iter()
.filter(|(_, m)| {
now.duration_since(m.last_heartbeat).as_millis() > m.session_timeout_ms as u128
})
.map(|(id, _)| id.clone())
.collect();
for id in expired {
group.members.remove(&id);
}
let member_id = if member_id.is_empty() {
format!("rivine-{}-{}", group_id, group.members.len() + 1)
} else {
member_id.to_string()
};
if !group.members.contains_key(&member_id) {
group.state = GroupState::PreparingRebalance;
group.leader_id = None;
group.protocol = None;
}
let metadata = protocols.first().map(|(_, m)| m.clone()).unwrap_or_default();
let member = Member {
member_id: member_id.clone(),
session_timeout_ms,
rebalance_timeout_ms,
protocols,
last_heartbeat: Instant::now(),
assignment: Bytes::new(),
metadata: metadata.clone(),
};
group.members.insert(member_id.clone(), member);
group.protocol_type = protocol_type.to_string();
if group.leader_id.is_none() {
group.leader_id = Some(member_id.clone());
}
let protocol = group
.members
.values()
.next()
.and_then(|m| m.protocols.first().map(|(n, _)| n.clone()));
let members: Vec<(String, Bytes)> = group
.members
.values()
.map(|m| (m.member_id.clone(), m.metadata.clone()))
.collect();
group.state = GroupState::CompletingRebalance;
group.generation_id += 1;
let generation = group.generation_id;
let leader = group.leader_id.clone().unwrap_or_default();
(0, generation, leader, member_id, protocol, members)
}
pub fn sync_group(
&self,
group_id: &str,
generation_id: i32,
member_id: &str,
assignments: Vec<(String, Bytes)>,
) -> (i16, Bytes) {
let Some(mut entry) = self.groups.get_mut(group_id) else {
return (16, Bytes::new()); };
let group = entry.value_mut();
if group.generation_id != generation_id {
return (22, Bytes::new()); }
if !group.members.contains_key(member_id) {
return (25, Bytes::new()); }
if let Some(leader) = &group.leader_id {
if leader == member_id {
let map: HashMap<String, Bytes> = assignments.into_iter().collect();
for (mid, assign) in &map {
if let Some(m) = group.members.get_mut(mid) {
m.assignment = assign.clone();
}
}
}
}
group.state = GroupState::Stable;
let assignment = group.members.get(member_id).map(|m| m.assignment.clone()).unwrap_or_default();
(0, assignment)
}
pub fn heartbeat(&self, group_id: &str, generation_id: i32, member_id: &str) -> i16 {
let Some(mut entry) = self.groups.get_mut(group_id) else {
return 16; };
let group = entry.value_mut();
if group.generation_id != generation_id {
return 22; }
if let Some(member) = group.members.get_mut(member_id) {
member.last_heartbeat = Instant::now();
0
} else {
25 }
}
pub fn leave_group(&self, group_id: &str, member_id: &str) -> i16 {
let Some(mut entry) = self.groups.get_mut(group_id) else {
return 16;
};
let group = entry.value_mut();
group.members.remove(member_id);
if group.members.is_empty() {
group.state = GroupState::Empty;
} else {
group.state = GroupState::PreparingRebalance;
}
0
}
pub fn commit_offset(
&self,
group_id: &str,
topic: &str,
partition: i32,
offset: i64,
metadata: Option<String>,
) {
self.offset_store
.lock()
.unwrap()
.commit(group_id, topic, partition, offset, metadata);
}
pub fn fetch_offset(&self, group_id: &str, topic: &str, partition: i32) -> Option<i64> {
self.offset_store
.lock()
.unwrap()
.fetch_offset(group_id, topic, partition)
}
pub fn fetch_offset_with_meta(
&self,
group_id: &str,
topic: &str,
partition: i32,
) -> Option<(i64, Option<String>)> {
self.offset_store
.lock()
.unwrap()
.fetch_offset_with_meta(group_id, topic, partition)
}
pub fn list_groups(&self) -> Vec<(String, String)> {
let mut result: Vec<(String, String)> = Vec::new();
for g in self.groups.iter() {
result.push((g.group_id.clone(), g.protocol_type.clone()));
}
for gid in self.offset_store.lock().unwrap().groups_with_offsets() {
if !result.iter().any(|(id, _)| *id == gid) {
result.push((gid, String::new()));
}
}
result
}
pub fn group_state_str(&self, group_id: &str) -> Option<String> {
self.groups.get(group_id).map(|g| match g.state {
GroupState::Empty => "Empty".to_string(),
GroupState::PreparingRebalance => "PreparingRebalance".to_string(),
GroupState::CompletingRebalance => "CompletingRebalance".to_string(),
GroupState::Stable => "Stable".to_string(),
})
}
pub fn group_protocol_type(&self, group_id: &str) -> Option<String> {
self.groups.get(group_id).map(|g| g.protocol_type.clone())
}
pub fn describe_members(
&self,
group_id: &str,
) -> Vec<(String, Bytes, Bytes)> {
self.groups
.get(group_id)
.map(|g| {
g.members
.iter()
.map(|(id, m)| (id.clone(), m.metadata.clone(), m.assignment.clone()))
.collect()
})
.unwrap_or_default()
}
}
fn stable_hash(s: &str) -> u64 {
let mut h: u64 = 0;
for b in s.bytes() {
h = h.wrapping_mul(31).wrapping_add(b as u64);
}
h
}