use crate::protocol::error_codes;
use dashmap::DashMap;
pub const NO_PRODUCER_ID: i64 = -1;
#[derive(Debug, Clone)]
pub struct ProducerPartitionState {
pub last_base_sequence: i32,
pub last_sequence: i32,
}
#[derive(Default)]
pub struct IdempotentStateManager {
states: DashMap<(i64, String, i32), ProducerPartitionState>,
}
impl IdempotentStateManager {
pub fn new() -> Self {
Self {
states: DashMap::new(),
}
}
pub fn validate_and_advance(
&self,
producer_id: i64,
producer_epoch: i16,
topic: &str,
partition: i32,
base_sequence: i32,
last_offset_delta: i32,
) -> Result<(), i16> {
if producer_id == NO_PRODUCER_ID {
return Ok(());
}
let key = (producer_id, topic.to_string(), partition);
let entry = self.states.entry(key);
match entry {
dashmap::mapref::entry::Entry::Vacant(v) => {
v.insert(ProducerPartitionState {
last_base_sequence: base_sequence,
last_sequence: base_sequence + last_offset_delta,
});
Ok(())
}
dashmap::mapref::entry::Entry::Occupied(mut o) => {
let last = o.get().last_sequence;
let last_base = o.get().last_base_sequence;
if base_sequence == last_base {
return Err(error_codes::DUPLICATE_SEQUENCE_NUMBER);
}
if base_sequence == last + 1 {
o.get_mut().last_base_sequence = base_sequence;
o.get_mut().last_sequence = base_sequence + last_offset_delta;
Ok(())
} else if base_sequence < last {
Err(error_codes::OUT_OF_ORDER_SEQUENCE_NUMBER)
} else {
o.get_mut().last_base_sequence = base_sequence;
o.get_mut().last_sequence = base_sequence + last_offset_delta;
let _ = producer_epoch;
Ok(())
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_idempotent_sequence_validation() {
let mgr = IdempotentStateManager::new();
assert!(mgr
.validate_and_advance(100, 0, "t", 0, 0, 2)
.is_ok());
assert!(mgr
.validate_and_advance(100, 0, "t", 0, 3, 1)
.is_ok());
let err = mgr
.validate_and_advance(100, 0, "t", 0, 3, 1)
.unwrap_err();
assert_eq!(err, error_codes::DUPLICATE_SEQUENCE_NUMBER);
let err = mgr
.validate_and_advance(100, 0, "t", 0, 1, 0)
.unwrap_err();
assert_eq!(err, error_codes::OUT_OF_ORDER_SEQUENCE_NUMBER);
assert!(mgr
.validate_and_advance(100, 0, "t", 0, 4, 0)
.is_ok());
}
#[test]
fn test_non_idempotent_skipped() {
let mgr = IdempotentStateManager::new();
for _ in 0..3 {
assert!(mgr
.validate_and_advance(NO_PRODUCER_ID, 0, "t", 0, 0, 0)
.is_ok());
}
}
}