use std::collections::HashMap;
use std::sync::Arc;
use petgraph::graph::NodeIndex;
use petgraph::Direction as PgDirection;
use super::overlay::{Overlay, ParsedFile};
use super::{Adjacency, Base, Dir, NodeMeta, Reached};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SymRef {
Base(NodeIndex),
Overlay(u32),
}
pub struct TenantRegistry {
base: Arc<Base>,
overlays: HashMap<String, Overlay>,
intern: HashMap<String, Arc<ParsedFile>>,
tenancy: crate::config::TenancyConfig,
tick: u64,
stamps: HashMap<String, (u64, u64)>,
}
impl TenantRegistry {
#[must_use]
pub fn new(base: Arc<Base>) -> Self {
Self::with_tenancy(base, crate::config::TenancyConfig::default())
}
#[must_use]
pub fn with_tenancy(base: Arc<Base>, tenancy: crate::config::TenancyConfig) -> Self {
Self {
base,
overlays: HashMap::new(),
intern: HashMap::new(),
tenancy,
tick: 0,
stamps: HashMap::new(),
}
}
#[must_use]
pub fn base(&self) -> &Arc<Base> {
&self.base
}
#[must_use]
pub fn tenancy(&self) -> &crate::config::TenancyConfig {
&self.tenancy
}
pub fn open_session(&mut self, tenant: &str) -> Option<String> {
let evicted = self.ensure_capacity_for(tenant);
self.tick += 1;
let tick = self.tick;
self.stamps
.entry(tenant.to_string())
.and_modify(|(_, used)| *used = tick)
.or_insert((tick, tick));
self.overlays.entry(tenant.to_string()).or_default();
evicted
}
pub fn close_session(&mut self, tenant: &str) {
self.overlays.remove(tenant);
self.stamps.remove(tenant);
self.sweep_intern();
}
pub fn reset(&mut self, tenant: &str) {
if let Some(overlay) = self.overlays.get_mut(tenant) {
*overlay = Overlay::default();
self.sweep_intern();
}
}
fn ensure_capacity_for(&mut self, tenant: &str) -> Option<String> {
if self.overlays.contains_key(tenant) || self.overlays.len() < self.tenancy.max_overlays {
return None;
}
let lru = self.tenancy.overlay_eviction == "lru";
let victim = self
.stamps
.iter()
.filter(|(t, _)| self.overlays.contains_key(t.as_str()))
.min_by_key(|(_, (created, used))| if lru { *used } else { *created })
.map(|(t, _)| t.clone())?;
tracing::warn!(
evicted = %victim, policy = %self.tenancy.overlay_eviction,
cap = self.tenancy.max_overlays, opening = %tenant,
"overlay cap reached — evicting to make room (FR-18)"
);
self.overlays.remove(&victim);
self.stamps.remove(&victim);
self.sweep_intern();
Some(victim)
}
fn sweep_intern(&mut self) {
self.intern.retain(|_, arc| Arc::strong_count(arc) > 1);
}
pub fn touch(&mut self, tenant: &str, rel: &str, source: &str) {
let parsed = ParsedFile::parse(rel, source);
if self.base.file(rel).is_some_and(|f| f.hash == parsed.hash) {
if let Some(overlay) = self.overlays.get_mut(tenant) {
overlay.revert(rel);
}
return;
}
self.open_session(tenant);
let shared = self
.intern
.entry(parsed.hash.clone())
.or_insert_with(|| Arc::new(parsed))
.clone();
self.overlays
.entry(tenant.to_string())
.or_default()
.touch(rel, shared);
}
#[must_use]
pub fn sharing_stats(&self) -> SharingStats {
let total_touches: usize = self.overlays.values().map(Overlay::touched_count).sum();
let mut live: std::collections::BTreeSet<*const ParsedFile> =
std::collections::BTreeSet::new();
for overlay in self.overlays.values() {
for rel in overlay.touched() {
if let Some(p) = overlay.parsed(rel) {
live.insert(Arc::as_ptr(p));
}
}
}
SharingStats {
total_touches,
unique_parses: live.len(),
interned: self.intern.len(),
}
}
pub fn revert(&mut self, tenant: &str, rel: &str) {
if let Some(overlay) = self.overlays.get_mut(tenant) {
overlay.revert(rel);
}
}
pub fn drop_tenant(&mut self, tenant: &str) {
self.close_session(tenant);
}
#[must_use]
pub fn overlay(&self, tenant: &str) -> Option<&Overlay> {
self.overlays.get(tenant)
}
#[must_use]
pub fn tenants(&self) -> Vec<&str> {
let mut t: Vec<&str> = self.overlays.keys().map(String::as_str).collect();
t.sort_unstable();
t
}
#[must_use]
pub fn view(&self, tenant: &str) -> TenantView<'_> {
TenantView {
base: &self.base,
overlay: self.overlays.get(tenant),
}
}
#[must_use]
pub fn status(&self) -> RegistryStatus {
let mut active: Vec<OverlayStatus> = self
.overlays
.iter()
.map(|(tenant, overlay)| OverlayStatus {
tenant: tenant.clone(),
touched_files: overlay.touched_count(),
symbols: overlay.symbol_count(),
})
.collect();
active.sort_by(|a, b| a.tenant.cmp(&b.tenant));
RegistryStatus {
base_commit: self.base.commit().to_string(),
active_overlays: active,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SharingStats {
pub total_touches: usize,
pub unique_parses: usize,
pub interned: usize,
}
impl SharingStats {
#[must_use]
pub fn saved(&self) -> usize {
self.total_touches.saturating_sub(self.unique_parses)
}
#[must_use]
pub fn ratio(&self) -> f64 {
if self.total_touches == 0 {
0.0
} else {
self.saved() as f64 / self.total_touches as f64
}
}
}
#[derive(Debug, Clone, serde::Serialize, PartialEq, Eq)]
pub struct OverlayStatus {
pub tenant: String,
pub touched_files: usize,
pub symbols: usize,
}
#[derive(Debug, Clone, serde::Serialize, PartialEq, Eq)]
pub struct RegistryStatus {
pub base_commit: String,
pub active_overlays: Vec<OverlayStatus>,
}
#[path = "tenant_view.rs"]
mod tenant_view;
pub use tenant_view::*;