use std::collections::HashMap;
use std::sync::Arc;
use rustango::sql::sqlx;
use sqlx::pool::{Pool, PoolConnection};
use sqlx::Database;
use tokio::sync::RwLock;
use super::error::TenancyError;
use super::org::{BackendKind, Org, StorageMode};
use super::pools::TenantPoolsConfig;
use super::secrets::{ChainSecretsResolver, SecretsResolver};
#[derive(Debug)]
pub struct DatabasePool<DB: Database> {
pool: Arc<Pool<DB>>,
}
impl<DB: Database> Clone for DatabasePool<DB> {
fn clone(&self) -> Self {
Self {
pool: self.pool.clone(),
}
}
}
impl<DB: Database> DatabasePool<DB> {
#[must_use]
pub fn pool(&self) -> &Pool<DB> {
&self.pool
}
#[must_use]
pub fn pool_arc(&self) -> Arc<Pool<DB>> {
self.pool.clone()
}
}
pub struct DatabaseConn<DB: Database> {
inner: PoolConnection<DB>,
#[cfg_attr(not(any(feature = "mysql", feature = "sqlite")), allow(dead_code))]
pool: crate::sql::PoolId,
}
impl<DB: Database> DatabaseConn<DB> {
pub(crate) fn new(inner: PoolConnection<DB>, pool: &crate::sql::Pool) -> Self {
let pool = crate::sql::PoolId::of(pool);
Self { inner, pool }
}
#[cfg(any(feature = "mysql", feature = "sqlite"))]
pub(crate) fn pool_id(&self) -> &crate::sql::PoolId {
&self.pool
}
}
impl<DB: Database> std::ops::Deref for DatabaseConn<DB> {
type Target = PoolConnection<DB>;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<DB: Database> std::ops::DerefMut for DatabaseConn<DB> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
pub struct DatabasePools<DB: Database> {
config: TenantPoolsConfig,
secrets: Arc<dyn SecretsResolver>,
lru_tick: std::sync::atomic::AtomicU64,
cache: RwLock<HashMap<String, super::pools::CachedPool<DB>>>,
building: super::pools::SingleFlight<Arc<Pool<DB>>>,
gate: std::sync::OnceLock<super::pools::BuildGate>,
backend: BackendKind,
url_template: Option<String>,
}
impl<DB: Database> DatabasePools<DB> {
#[must_use]
pub fn new(backend: BackendKind) -> Self {
Self::with_secrets(backend, ChainSecretsResolver::standard())
}
fn next_tick(&self) -> u64 {
self.lru_tick
.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
}
#[must_use]
pub fn with_secrets<R: SecretsResolver>(backend: BackendKind, secrets: R) -> Self {
Self {
config: TenantPoolsConfig::default(),
secrets: Arc::new(secrets),
lru_tick: std::sync::atomic::AtomicU64::new(0),
cache: RwLock::new(HashMap::new()),
building: super::pools::SingleFlight::default(),
gate: std::sync::OnceLock::new(),
backend,
url_template: None,
}
}
#[must_use]
pub fn with_url_template(mut self, template: impl Into<String>) -> Self {
self.url_template = Some(template.into());
self
}
#[must_use]
pub fn config(mut self, config: TenantPoolsConfig) -> Self {
self.config = config;
self.gate = std::sync::OnceLock::new();
self
}
#[must_use]
pub fn pool_config(&self) -> &TenantPoolsConfig {
&self.config
}
#[must_use]
pub fn backend_kind(&self) -> BackendKind {
self.backend
}
pub async fn pool_for_org(&self, org: &Org) -> Result<DatabasePool<DB>, TenancyError> {
let want = BackendKind::parse(&org.backend_kind).map_err(|got| {
TenancyError::Validation(format!(
"org `{}` has unknown backend_kind `{got}` \
(expected `postgres`, `mysql`, or `sqlite`)",
org.slug
))
})?;
if want != self.backend {
return Err(TenancyError::Validation(format!(
"org `{}` is configured for backend `{want}` \
but this DatabasePools is serving `{}`. \
The process boots one backend; route through the \
matching server instance.",
org.slug, self.backend
)));
}
let mode = StorageMode::parse(&org.storage_mode).map_err(|got| {
TenancyError::Validation(format!(
"org `{}` has unknown storage_mode `{got}` \
(expected `schema` or `database`)",
org.slug
))
})?;
if mode != StorageMode::Database {
return Err(TenancyError::Validation(format!(
"org `{}` storage_mode is `{mode}` but DatabasePools \
only supports database-mode. \
(Schema-mode is Postgres-only — use TenantPools.)",
org.slug
)));
}
let source = super::pools::PoolSource::database(org);
if let Some(pool) = self.cached(&org.slug, &source).await {
return Ok(DatabasePool { pool });
}
let build = self.build_for(org, source.clone());
let pool = if self.config.max_cached_database_pools == 0 {
build.await?
} else {
self.building.run(&org.slug, &source, build).await?
};
Ok(DatabasePool { pool })
}
async fn build_for(
&self,
org: &Org,
source: super::pools::PoolSource,
) -> Result<Arc<sqlx::Pool<DB>>, TenancyError> {
if let Some(pool) = self.cached(&org.slug, &source).await {
return Ok(pool);
}
let url_ref = match org.database_url.as_deref() {
Some(u) => u.to_owned(),
None => match &self.url_template {
Some(tpl) => tpl.replace("{slug}", &org.slug),
None => {
return Err(TenancyError::Validation(format!(
"org `{}` is database-mode but has no database_url \
and no url_template is configured on DatabasePools \
(call `.with_url_template(...)` at boot)",
org.slug
)));
}
},
};
let _slot = self
.gate
.get_or_init(|| super::pools::BuildGate::new(&self.config))
.admit()
.await?;
let resolved = self
.secrets
.resolve(&url_ref)
.await
.map_err(TenancyError::Secrets)?;
let pool = self.build_pool(&resolved).await?;
let pool_arc = Arc::new(pool);
let mut cache = self.cache.write().await;
if let Some(existing) = super::pools::CachedPool::lookup(&cache, &org.slug, &source) {
existing.touch(self.next_tick());
return Ok(existing.pool.clone());
}
cache.remove(&org.slug);
for slug in super::pools::evict_to_fit(&mut cache, self.config.max_cached_database_pools) {
tracing::info!(
target: "rustango::tenancy::pools",
evicted = %slug,
for_slug = %org.slug,
cap = self.config.max_cached_database_pools,
"evicted the least recently used tenant pool to make room",
);
}
if self.config.max_cached_database_pools == 0 {
return Ok(pool_arc);
}
cache.insert(
org.slug.clone(),
super::pools::CachedPool::new(pool_arc.clone(), source, self.next_tick()),
);
Ok(pool_arc)
}
async fn cached(
&self,
slug: &str,
source: &super::pools::PoolSource,
) -> Option<Arc<sqlx::Pool<DB>>> {
let cache = self.cache.read().await;
let entry = super::pools::CachedPool::lookup(&cache, slug, source)?;
entry.touch(self.next_tick());
Some(entry.pool.clone())
}
pub async fn acquire(&self, org: &Org) -> Result<DatabaseConn<DB>, TenancyError>
where
crate::sql::Pool: From<Pool<DB>>,
{
let pool = self.pool_for_org(org).await?;
let inner = pool.pool().acquire().await?;
Ok(DatabaseConn::new(
inner,
&crate::sql::Pool::from(pool.pool().clone()),
))
}
pub async fn invalidate(&self, slug: &str) {
let mut cache = self.cache.write().await;
cache.remove(slug);
}
pub(crate) async fn build_pool(&self, url: &str) -> Result<Pool<DB>, TenancyError> {
super::pools::tenant_pool_options::<DB>(
&self.config,
self.config.database_pool_max_connections,
self.config.database_pool_min_connections,
)
.connect(url)
.await
.map_err(TenancyError::from)
}
}
#[cfg(all(test, any(feature = "sqlite", feature = "mysql")))]
mod tests {
use super::*;
#[cfg(feature = "sqlite")]
#[test]
fn sqlite_pool_registry_constructible() {
let _: DatabasePools<sqlx::Sqlite> = DatabasePools::new(BackendKind::Sqlite);
}
#[cfg(feature = "mysql")]
#[test]
fn mysql_pool_registry_constructible() {
let _: DatabasePools<sqlx::MySql> = DatabasePools::new(BackendKind::MySql);
}
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn cold_builds_past_the_budget_are_refused() {
for (budget, built) in [(2, 2), (0, 3)] {
let pools: DatabasePools<sqlx::Sqlite> = DatabasePools::new(BackendKind::Sqlite)
.config(TenantPoolsConfig {
max_cached_database_pools: 1,
max_pool_builds_per_minute: budget,
..TenantPoolsConfig::default()
});
let org = |slug: &str| {
crate::testkit::org_with(|o| {
o.slug = slug.into();
o.backend_kind = "sqlite".into();
o.database_url = Some("sqlite::memory:".into());
})
};
let mut ok = 0;
for slug in ["a", "b", "c"] {
match pools.pool_for_org(&org(slug)).await {
Ok(_) => ok += 1,
Err(e) => assert!(matches!(e, TenancyError::PoolBusy), "{e}"),
}
}
assert_eq!(ok, built, "budget {budget}");
if budget > 0 {
assert!(pools.pool_for_org(&org("b")).await.is_ok());
}
}
}
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn concurrent_builds_wait_for_a_slot() {
let gate = crate::tenancy::pools::BuildGate::new(&TenantPoolsConfig {
max_concurrent_pool_builds: 1,
database_pool_acquire_timeout: std::time::Duration::from_millis(50),
..TenantPoolsConfig::default()
});
let held = gate.admit().await.expect("first slot");
assert!(matches!(gate.admit().await, Err(TenancyError::PoolBusy)));
drop(held);
assert!(gate.admit().await.is_ok(), "slot back after the build");
}
#[cfg(feature = "sqlite")]
#[test]
fn backend_kind_round_trips() {
let p: DatabasePools<sqlx::Sqlite> = DatabasePools::new(BackendKind::Sqlite);
assert_eq!(p.backend_kind(), BackendKind::Sqlite);
}
}