#![forbid(unsafe_code)]
use std::sync::Arc;
use std::time::Duration;
use async_trait::async_trait;
use nadis::RedisClient;
use naidempotency::{
ExecutionLease, IdempotencyError, IdempotencyKey, IdempotencyOutcome, IdempotencyStore,
RequestFingerprint, StoredResponse,
};
use sha2::{Digest as _, Sha256};
const STATE_IN_FLIGHT: u8 = 0;
const STATE_COMPLETED: u8 = 1;
const DEFAULT_INFLIGHT_TTL: Duration = Duration::from_secs(5 * 60);
const DEFAULT_COMPLETED_TTL: Duration = Duration::from_secs(24 * 3600);
const COMPLETE_LUA: &str = "\
local v = redis.call('GET', KEYS[1]) \
if not v then return 0 end \
if v ~= ARGV[1] then return 0 end \
local fp = string.sub(v, 2, 33) \
redis.call('SET', KEYS[1], string.char(1) .. fp .. ARGV[2], 'PX', ARGV[3]) \
return 1";
const ABORT_LUA: &str = "\
local v = redis.call('GET', KEYS[1]) \
if not v or v ~= ARGV[1] then return 0 end \
return redis.call('DEL', KEYS[1])";
#[derive(Clone)]
pub struct RedisIdempotencyStore {
client: Arc<RedisClient>,
inflight_ttl: Duration,
completed_ttl: Duration,
}
impl RedisIdempotencyStore {
pub fn new(client: Arc<RedisClient>) -> Self {
Self {
client,
inflight_ttl: DEFAULT_INFLIGHT_TTL,
completed_ttl: DEFAULT_COMPLETED_TTL,
}
}
pub fn with_ttls(
client: Arc<RedisClient>,
inflight_ttl: Duration,
completed_ttl: Duration,
) -> Self {
Self {
client,
inflight_ttl,
completed_ttl,
}
}
fn redis_key(key: &IdempotencyKey) -> String {
const SEPARATOR: char = '\u{1f}';
let components = [
key.tenant.as_str(),
key.subject.as_str(),
key.route_id.as_str(),
key.client_key.as_str(),
];
if components
.iter()
.all(|component| !component.contains(SEPARATOR))
{
return format!(
"idem:{}{SEPARATOR}{}{SEPARATOR}{}{SEPARATOR}{}",
key.tenant, key.subject, key.route_id, key.client_key
);
}
let mut digest = Sha256::new();
for component in components.map(str::as_bytes) {
digest.update((component.len() as u64).to_be_bytes());
digest.update(component);
}
let digest = digest.finalize();
let mut encoded = String::with_capacity("idem:v2:".len() + digest.len() * 2);
encoded.push_str("idem:v2:");
for byte in digest {
use std::fmt::Write as _;
let _ = write!(encoded, "{byte:02x}");
}
encoded
}
}
fn ttl_millis(ttl: Duration) -> Result<u64, IdempotencyError> {
let millis =
u64::try_from(ttl.as_millis()).map_err(|_| IdempotencyError::new("invalid ttl"))?;
if millis == 0 || millis > i64::MAX as u64 {
return Err(IdempotencyError::new("invalid ttl"));
}
Ok(millis)
}
fn encode_inflight(fingerprint: RequestFingerprint, lease: ExecutionLease) -> Vec<u8> {
let mut value = Vec::with_capacity(49);
value.push(STATE_IN_FLIGHT);
value.extend_from_slice(&fingerprint.0);
value.extend_from_slice(&lease.0);
value
}
fn encode_completed_suffix(response: &StoredResponse) -> Result<Vec<u8>, IdempotencyError> {
let headers = serde_json::to_vec(&response.headers).map_err(map_err)?;
let header_len =
u32::try_from(headers.len()).map_err(|_| IdempotencyError::new("headers too large"))?;
let mut suffix = Vec::with_capacity(6 + headers.len() + response.body.len());
suffix.extend_from_slice(&response.status.to_le_bytes());
suffix.extend_from_slice(&header_len.to_le_bytes());
suffix.extend_from_slice(&headers);
suffix.extend_from_slice(&response.body);
Ok(suffix)
}
struct Decoded {
state: u8,
fingerprint: RequestFingerprint,
response: Option<StoredResponse>,
}
fn decode(bytes: &[u8]) -> Option<Decoded> {
if bytes.len() < 33 {
return None;
}
let state = bytes[0];
if !matches!(state, STATE_IN_FLIGHT | STATE_COMPLETED) {
return None;
}
if state == STATE_IN_FLIGHT && bytes.len() != 49 {
return None;
}
let fingerprint = RequestFingerprint(bytes[1..33].try_into().ok()?);
let response = if state == STATE_COMPLETED {
if bytes.len() < 39 {
return None;
}
let status = u16::from_le_bytes(bytes[33..35].try_into().ok()?);
if !(100..=599).contains(&status) {
return None;
}
let headers_len = u32::from_le_bytes(bytes[35..39].try_into().ok()?) as usize;
let body_start = 39usize.checked_add(headers_len)?;
if body_start > bytes.len() {
return None;
}
let headers = serde_json::from_slice(&bytes[39..body_start]).ok()?;
Some(StoredResponse {
status,
body: bytes[body_start..].to_vec(),
headers,
})
} else {
None
};
Some(Decoded {
state,
fingerprint,
response,
})
}
#[async_trait]
impl IdempotencyStore for RedisIdempotencyStore {
async fn begin(
&self,
key: &IdempotencyKey,
fingerprint: RequestFingerprint,
lease: ExecutionLease,
) -> Result<IdempotencyOutcome, IdempotencyError> {
let redis_key = Self::redis_key(key);
let mut set = redis::cmd("SET");
set.arg(&redis_key)
.arg(encode_inflight(fingerprint, lease).as_slice())
.arg("NX")
.arg("PX")
.arg(ttl_millis(self.inflight_ttl)?);
let claimed: Option<String> = self.client.execute_raw(&set).await.map_err(map_err)?;
if claimed.is_some() {
return Ok(IdempotencyOutcome::FirstExecution);
}
let mut get = redis::cmd("GET");
get.arg(&redis_key);
let existing: Option<Vec<u8>> = self.client.execute_raw(&get).await.map_err(map_err)?;
let Some(bytes) = existing else {
return Ok(IdempotencyOutcome::ConcurrentInFlight);
};
let Some(decoded) = decode(&bytes) else {
return Err(IdempotencyError::new("corrupt idempotency record"));
};
if decoded.fingerprint != fingerprint {
return Ok(IdempotencyOutcome::FingerprintConflict);
}
if decoded.state == STATE_COMPLETED {
let response = decoded
.response
.ok_or_else(|| IdempotencyError::new("corrupt idempotency record"))?;
Ok(IdempotencyOutcome::Replay(response))
} else {
Ok(IdempotencyOutcome::ConcurrentInFlight)
}
}
async fn complete(
&self,
key: &IdempotencyKey,
fingerprint: RequestFingerprint,
lease: ExecutionLease,
response: StoredResponse,
) -> Result<bool, IdempotencyError> {
let redis_key = Self::redis_key(key);
let mut eval = redis::cmd("EVAL");
eval.arg(COMPLETE_LUA)
.arg(1)
.arg(&redis_key)
.arg(encode_inflight(fingerprint, lease).as_slice())
.arg(encode_completed_suffix(&response)?.as_slice())
.arg(ttl_millis(self.completed_ttl)?);
let completed: i64 = self.client.execute_raw(&eval).await.map_err(map_err)?;
Ok(completed == 1)
}
async fn abort(
&self,
key: &IdempotencyKey,
fingerprint: RequestFingerprint,
lease: ExecutionLease,
) -> Result<bool, IdempotencyError> {
let redis_key = Self::redis_key(key);
let mut eval = redis::cmd("EVAL");
eval.arg(ABORT_LUA)
.arg(1)
.arg(&redis_key)
.arg(encode_inflight(fingerprint, lease).as_slice());
let deleted: i64 = self.client.execute_raw(&eval).await.map_err(map_err)?;
Ok(deleted == 1)
}
}
fn map_err<E>(_error: E) -> IdempotencyError {
IdempotencyError::new("redis error")
}