use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use tokio::sync::{OwnedSemaphorePermit, Semaphore};
use crate::error::{ArcadeDbError, Result};
use crate::{ArcadeDbClient, ClientOptions};
static SPAWN_SEQ: AtomicU64 = AtomicU64::new(0);
pub struct TestDatabase {
client: Option<ArcadeDbClient>,
name: Option<String>,
}
impl TestDatabase {
pub async fn spawn(options: ClientOptions, prefix: &str) -> Result<Self> {
let name = unique_name(prefix);
let mut options = options;
options.database = name.clone();
let client = ArcadeDbClient::connect_with(options).await?;
match client.admin().create_database(&name, "graph").await {
Ok(()) => {}
Err(crate::error::ArcadeDbError::AlreadyExists { .. }) => {}
Err(e) => return Err(e),
}
Ok(Self {
client: Some(client),
name: Some(name),
})
}
pub fn name(&self) -> &str {
self.name.as_deref().expect("name present until removal")
}
pub fn client(&self) -> &ArcadeDbClient {
self.client.as_ref().expect("client present until removal")
}
pub async fn remove(mut self) -> Result<()> {
let client = self.client.take().expect("client present");
let name = self.name.take().expect("name present");
client.admin().drop_database(&name).await
}
}
impl Drop for TestDatabase {
fn drop(&mut self) {
let Some(client) = self.client.take() else {
return;
};
let Some(name) = self.name.take() else {
return;
};
if let Ok(handle) = tokio::runtime::Handle::try_current() {
handle.spawn(async move {
let _ = client.admin().drop_database(&name).await;
});
}
}
}
fn unique_name(prefix: &str) -> String {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let seq = SPAWN_SEQ.fetch_add(1, Ordering::Relaxed);
format!("{}_{nanos:x}_{seq}", sanitize_prefix(prefix))
}
fn sanitize_prefix(prefix: &str) -> String {
let sanitized: String = prefix
.chars()
.filter(|c| c.is_ascii_alphanumeric() || *c == '_')
.take(48)
.collect();
if sanitized.is_empty() {
"test".to_string()
} else {
sanitized
}
}
type SeedFuture = Pin<Box<dyn Future<Output = Result<()>> + Send>>;
type SeedFn = Arc<dyn Fn(ArcadeDbClient, String) -> SeedFuture + Send + Sync>;
pub struct TestPool {
inner: Arc<PoolInner>,
}
struct PoolInner {
options: ClientOptions,
prefix: String,
owner: String,
seed: Option<SeedFn>,
semaphore: Arc<Semaphore>,
slots: Mutex<Vec<usize>>,
size: usize,
swept: std::sync::atomic::AtomicBool,
}
impl TestPool {
pub fn builder(options: ClientOptions, prefix: &str) -> TestPoolBuilder {
TestPoolBuilder {
options,
prefix: sanitize_prefix(prefix),
size: 8,
seed: None,
}
}
pub fn size(&self) -> usize {
self.inner.size
}
pub async fn checkout(&self) -> Result<PooledDatabase> {
self.sweep_stale_once().await;
let permit = self
.inner
.semaphore
.clone()
.acquire_owned()
.await
.map_err(|_| ArcadeDbError::InvalidInput {
message: "test pool semaphore closed".into(),
})?;
let slot = {
let mut slots = self.inner.slots.lock().unwrap();
match slots.pop() {
Some(slot) => slot,
None => {
return Err(ArcadeDbError::InvalidInput {
message: "test pool: permit held but no slot free".into(),
});
}
}
};
let name = format!("{}_{}_{slot}", self.inner.prefix, self.inner.owner);
let bootstrap = match ArcadeDbClient::connect_with(self.inner.options.clone()).await {
Ok(client) => client,
Err(e) => {
release_slot(&self.inner, slot);
return Err(e);
}
};
let _ = bootstrap.admin().drop_database(&name).await;
match bootstrap.admin().create_database(&name, "graph").await {
Ok(()) => {}
Err(ArcadeDbError::AlreadyExists { .. }) => {}
Err(e) => {
release_slot(&self.inner, slot);
return Err(e);
}
}
let mut options = self.inner.options.clone();
options.database = name.clone();
let client = match ArcadeDbClient::connect_with(options).await {
Ok(client) => client,
Err(e) => {
release_slot(&self.inner, slot);
return Err(e);
}
};
if let Some(seed) = &self.inner.seed {
if let Err(e) = seed(client.clone(), name.clone()).await {
release_slot(&self.inner, slot);
return Err(e);
}
}
Ok(PooledDatabase {
client,
name,
slot,
pool: self.inner.clone(),
_permit: permit,
})
}
}
fn release_slot(inner: &PoolInner, slot: usize) {
inner.slots.lock().unwrap().push(slot);
}
fn owner_token() -> String {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let seq = SPAWN_SEQ.fetch_add(1, Ordering::Relaxed);
format!("p{}_{nanos:x}_{seq}", std::process::id())
}
impl TestPool {
async fn sweep_stale_once(&self) {
if self.inner.swept.swap(true, Ordering::AcqRel) {
return;
}
let bootstrap = match ArcadeDbClient::connect_with(self.inner.options.clone()).await {
Ok(client) => client,
Err(_) => return,
};
let dbs = match bootstrap.admin().list_databases().await {
Ok(dbs) => dbs,
Err(_) => return,
};
for db in dbs {
if dead_owner_pid(&db, &self.inner.prefix).is_some() {
let _ = bootstrap.admin().drop_database(&db).await;
}
}
}
}
fn dead_owner_pid(db: &str, prefix: &str) -> Option<u32> {
let rest = db.strip_prefix(prefix)?.strip_prefix('_')?;
let owner = rest.split('_').next()?;
let pid = owner.strip_prefix('p')?.parse::<u32>().ok()?;
if pid == std::process::id() {
return None;
}
(!owner_process_alive(pid)).then_some(pid)
}
#[cfg(target_os = "linux")]
fn owner_process_alive(pid: u32) -> bool {
std::path::Path::new(&format!("/proc/{pid}")).exists()
}
#[cfg(not(target_os = "linux"))]
fn owner_process_alive(_pid: u32) -> bool {
true
}
pub struct TestPoolBuilder {
options: ClientOptions,
prefix: String,
size: usize,
seed: Option<SeedFn>,
}
impl TestPoolBuilder {
pub fn size(mut self, size: usize) -> Self {
self.size = size;
self
}
pub fn seed<F, Fut>(mut self, seed: F) -> Self
where
F: Fn(ArcadeDbClient, String) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<()>> + Send + 'static,
{
self.seed = Some(Arc::new(move |client, name| {
Box::pin(seed(client, name)) as SeedFuture
}));
self
}
pub fn build(self) -> TestPool {
assert!(
self.size >= 1,
"test pool size must be at least 1 (a zero-permit semaphore deadlocks checkout)"
);
let size = self.size;
TestPool {
inner: Arc::new(PoolInner {
options: self.options,
prefix: self.prefix,
owner: owner_token(),
seed: self.seed,
semaphore: Arc::new(Semaphore::new(size)),
slots: Mutex::new((0..size).rev().collect()),
size,
swept: std::sync::atomic::AtomicBool::new(false),
}),
}
}
}
pub struct PooledDatabase {
client: ArcadeDbClient,
name: String,
slot: usize,
pool: Arc<PoolInner>,
_permit: OwnedSemaphorePermit,
}
impl PooledDatabase {
pub fn name(&self) -> &str {
&self.name
}
pub fn client(&self) -> &ArcadeDbClient {
&self.client
}
}
impl Drop for PooledDatabase {
fn drop(&mut self) {
release_slot(&self.pool, self.slot);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn owner_tokens_are_process_tagged_and_unique() {
let a = owner_token();
let b = owner_token();
assert!(a.starts_with(&format!("p{}_", std::process::id())), "{a}");
assert_ne!(a, b);
assert!(a.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'));
}
#[test]
fn dead_owner_pid_parses_only_foreign_owned_slots() {
let prefix = "mytest";
let ours = format!("{prefix}_p{}_{:x}_0", std::process::id(), 0xabc);
assert_eq!(dead_owner_pid(&ours, prefix), None);
let dead = format!("{prefix}_p4294967290_{:x}_3", 0xabc);
if !owner_process_alive(4294967290) {
assert_eq!(dead_owner_pid(&dead, prefix), Some(4294967290));
}
assert_eq!(dead_owner_pid(&format!("{prefix}_3"), prefix), None);
assert_eq!(
dead_owner_pid(&format!("{prefix}_x1_{:x}_0", 0xabc), prefix),
None
);
assert_eq!(dead_owner_pid("other_p1_1_0", prefix), None);
assert_eq!(
dead_owner_pid(&format!("{prefix}_p1_{:x}_0", 0xabc), prefix),
None
);
}
#[test]
fn generated_names_are_unique_sanitized_and_prefixed() {
let a = unique_name("my-test!");
let b = unique_name("my-test!");
assert!(a.starts_with("mytest_"), "{a}");
assert_ne!(a, b);
assert!(a.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'));
assert!(unique_name("///").starts_with("test_"));
assert!(unique_name(&"x".repeat(500)).len() < 80);
}
#[test]
fn pool_builder_defaults_to_eight_and_sanitizes_prefix() {
let pool = TestPool::builder(ClientOptions::new("", "", "", ""), "my-pool!").build();
assert_eq!(pool.size(), 8);
assert_eq!(pool.inner.prefix, "mypool");
let sized = TestPool::builder(ClientOptions::new("", "", "", ""), "p")
.size(3)
.build();
assert_eq!(sized.size(), 3);
assert_eq!(sized.inner.slots.lock().unwrap().len(), 3);
}
#[test]
#[should_panic(expected = "at least 1")]
fn pool_builder_rejects_zero_size() {
TestPool::builder(ClientOptions::new("", "", "", ""), "p")
.size(0)
.build();
}
}