use std::collections::HashMap;
use async_trait::async_trait;
use tokio::sync::RwLock;
pub const DEFAULT_TENANT_CAP_BYTES: usize = 16 * 1024 * 1024;
pub const ENTRY_OVERHEAD_BYTES: usize = 64;
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum KvError {
#[error("tenant kv quota exceeded: {used_bytes} used + {added_bytes} new > {cap_bytes} cap")]
QuotaExceeded {
used_bytes: usize,
added_bytes: usize,
cap_bytes: usize,
},
#[error("kv backend error: {0}")]
Backend(#[source] Box<dyn std::error::Error + Send + Sync>),
}
#[async_trait]
pub trait KvStore: Send + Sync {
async fn get(&self, tenant: &str, key: &str) -> Result<Option<Vec<u8>>, KvError>;
async fn put(&self, tenant: &str, key: &str, value: Vec<u8>) -> Result<(), KvError>;
}
#[derive(Default)]
struct MemKvInner {
entries: HashMap<(String, String), Vec<u8>>,
tenant_bytes: HashMap<String, usize>,
}
pub struct MemKv {
inner: RwLock<MemKvInner>,
tenant_cap_bytes: usize,
}
impl MemKv {
pub fn new() -> Self {
Self::with_capacity_bytes(DEFAULT_TENANT_CAP_BYTES)
}
pub fn with_capacity_bytes(tenant_cap_bytes: usize) -> Self {
Self {
inner: RwLock::new(MemKvInner::default()),
tenant_cap_bytes,
}
}
}
impl Default for MemKv {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl KvStore for MemKv {
async fn get(&self, tenant: &str, key: &str) -> Result<Option<Vec<u8>>, KvError> {
let composite = (tenant.to_string(), key.to_string());
Ok(self.inner.read().await.entries.get(&composite).cloned())
}
async fn put(&self, tenant: &str, key: &str, value: Vec<u8>) -> Result<(), KvError> {
let composite = (tenant.to_string(), key.to_string());
let mut inner = self.inner.write().await;
let cost = |v_len: usize| ENTRY_OVERHEAD_BYTES + key.len() + v_len;
let old_cost = inner
.entries
.get(&composite)
.map(|v| cost(v.len()))
.unwrap_or(0);
let new_cost = cost(value.len());
let used = inner.tenant_bytes.get(tenant).copied().unwrap_or(0);
let new_used = used - old_cost + new_cost;
if new_used > self.tenant_cap_bytes {
return Err(KvError::QuotaExceeded {
used_bytes: used,
added_bytes: new_cost,
cap_bytes: self.tenant_cap_bytes,
});
}
inner.tenant_bytes.insert(tenant.to_string(), new_used);
inner.entries.insert(composite, value);
Ok(())
}
}
impl std::fmt::Debug for MemKv {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MemKv")
.field("tenant_cap_bytes", &self.tenant_cap_bytes)
.finish_non_exhaustive()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn cross_tenant_composite_keys_do_not_collide() {
let kv = MemKv::new();
kv.put("a", "b/x", b"from-a-b-x".to_vec()).await.unwrap();
kv.put("a/b", "x", b"from-a-slash-b-x".to_vec())
.await
.unwrap();
assert_eq!(kv.get("a", "b/x").await.unwrap().unwrap(), b"from-a-b-x");
assert_eq!(
kv.get("a/b", "x").await.unwrap().unwrap(),
b"from-a-slash-b-x"
);
}
#[tokio::test]
async fn put_over_tenant_quota_errors() {
let kv = MemKv::with_capacity_bytes(ENTRY_OVERHEAD_BYTES + 12);
kv.put("t", "k1", vec![0u8; 10]).await.unwrap();
let err = kv.put("t", "k2", vec![0u8; 10]).await.unwrap_err();
assert!(matches!(err, KvError::QuotaExceeded { .. }), "{err:?}");
}
#[tokio::test]
async fn overwrite_does_not_double_count_quota() {
let kv = MemKv::with_capacity_bytes(ENTRY_OVERHEAD_BYTES + 11);
kv.put("t", "k", vec![0u8; 10]).await.unwrap();
kv.put("t", "k", vec![1u8; 10]).await.unwrap();
assert_eq!(kv.get("t", "k").await.unwrap().unwrap(), vec![1u8; 10]);
}
#[tokio::test]
async fn empty_values_still_consume_quota() {
let kv = MemKv::with_capacity_bytes(ENTRY_OVERHEAD_BYTES * 3);
let mut accepted = 0;
for i in 0..100 {
if kv.put("t", &format!("k{i}"), Vec::new()).await.is_ok() {
accepted += 1;
}
}
assert!(accepted < 3, "accepted {accepted} empty-value entries");
}
}