use std::collections::BTreeMap;
use std::fmt;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use crate::runner::PartitionRunner;
use crate::ShutdownReport;
pub const DEFAULT_RUNNER: &str = "default";
const DEFAULT_MAX_RUNNERS: usize = 64;
const MAX_RUNNERS_LIMIT: usize = 4_096;
const MAX_RUNNER_NAME_BYTES: usize = 128;
const MAX_PARTITIONS: usize = 65_536;
const MAX_TYPE_STATES: usize = 1_048_576;
const MAX_DURATION: Duration = Duration::from_secs(31_536_000);
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RunnerName(Arc<str>);
impl RunnerName {
pub fn new(name: impl AsRef<str>) -> Result<Self, RunnerRegistryError> {
let name = name.as_ref();
if name.is_empty()
|| name.len() > MAX_RUNNER_NAME_BYTES
|| name.trim() != name
|| name.chars().any(char::is_control)
{
return Err(RunnerRegistryError::InvalidName);
}
Ok(Self(Arc::from(name)))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for RunnerName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("RunnerName").field(&self.as_str()).finish()
}
}
impl fmt::Display for RunnerName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for RunnerName {
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RunnerConfig {
pub partitions: usize,
pub queue_capacity_per_type: usize,
pub global_inflight: usize,
pub max_type_states: usize,
pub frozen_evidence_capacity: usize,
pub max_inbound_tunnels: usize,
pub idle_task_threshold: usize,
pub strict_opportunity_attempts: usize,
pub return_observations: usize,
pub tunnel_lease: Duration,
pub load_observer_interval: Duration,
pub control_tick: Duration,
pub transition_timeout: Duration,
pub shutdown_timeout: Duration,
pub drain_batch: usize,
}
impl RunnerConfig {
pub fn validated(&self) -> Result<Self, RunnerRegistryError> {
if self.partitions == 0 || self.partitions > MAX_PARTITIONS {
return Err(RunnerRegistryError::InvalidConfig(
"partitions must be within 1..=65536",
));
}
let partitions = self
.partitions
.checked_next_power_of_two()
.filter(|value| *value <= MAX_PARTITIONS)
.ok_or(RunnerRegistryError::InvalidConfig(
"normalized partitions exceed 65536",
))?;
if self.queue_capacity_per_type == 0
|| self.queue_capacity_per_type > tokio::sync::Semaphore::MAX_PERMITS
{
return Err(RunnerRegistryError::InvalidConfig(
"queue_capacity_per_type exceeds the Tokio semaphore capacity",
));
}
if self.global_inflight == 0 || self.global_inflight > tokio::sync::Semaphore::MAX_PERMITS {
return Err(RunnerRegistryError::InvalidConfig(
"global_inflight exceeds the Tokio semaphore capacity",
));
}
if self.max_type_states < partitions || self.max_type_states > MAX_TYPE_STATES {
return Err(RunnerRegistryError::InvalidConfig(
"max_type_states must cover every partition and remain bounded",
));
}
if self.frozen_evidence_capacity == 0
|| self.max_inbound_tunnels == 0
|| self.idle_task_threshold == 0
|| self.strict_opportunity_attempts == 0
|| self.return_observations == 0
|| self.drain_batch == 0
{
return Err(RunnerRegistryError::InvalidConfig(
"all capacities and control counts must be positive",
));
}
for (duration, name) in [
(self.tunnel_lease, "tunnel_lease"),
(self.load_observer_interval, "load_observer_interval"),
(self.control_tick, "control_tick"),
(self.transition_timeout, "transition_timeout"),
(self.shutdown_timeout, "shutdown_timeout"),
] {
if duration.is_zero() || duration > MAX_DURATION {
return Err(RunnerRegistryError::InvalidConfig(name));
}
}
let mut validated = self.clone();
validated.partitions = partitions;
Ok(validated)
}
}
impl Default for RunnerConfig {
fn default() -> Self {
let parallelism = std::thread::available_parallelism()
.map(std::num::NonZeroUsize::get)
.unwrap_or(1);
let partitions = parallelism
.saturating_mul(2)
.next_power_of_two()
.min(MAX_PARTITIONS);
let queue_capacity_per_type = 65_536;
Self {
partitions,
queue_capacity_per_type,
global_inflight: partitions
.saturating_mul(queue_capacity_per_type.saturating_add(1))
.min(tokio::sync::Semaphore::MAX_PERMITS),
max_type_states: 4_096_usize.max(partitions),
frozen_evidence_capacity: 1_024,
max_inbound_tunnels: 64,
idle_task_threshold: 8,
strict_opportunity_attempts: 2,
return_observations: 3,
tunnel_lease: Duration::from_secs(2),
load_observer_interval: Duration::from_secs(1),
control_tick: Duration::from_millis(1),
transition_timeout: Duration::from_secs(5),
shutdown_timeout: Duration::from_secs(2),
drain_batch: 64,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RunnerRegistryError {
InvalidName,
InvalidConfig(&'static str),
ConfigConflict,
RegistryFull,
IdExhausted,
}
impl fmt::Display for RunnerRegistryError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidName => f.write_str("invalid partition runner name"),
Self::InvalidConfig(field) => write!(f, "invalid partition runner config: {field}"),
Self::ConfigConflict => f.write_str("partition runner name is bound to another config"),
Self::RegistryFull => f.write_str("partition runner registry is full"),
Self::IdExhausted => f.write_str("partition runner id space is exhausted"),
}
}
}
impl std::error::Error for RunnerRegistryError {}
#[derive(Debug, Clone)]
pub struct PartitionRunnerRegistryBuilder {
max_runners: usize,
}
impl PartitionRunnerRegistryBuilder {
pub fn max_runners(mut self, max_runners: usize) -> Self {
self.max_runners = max_runners;
self
}
pub fn build(self) -> Result<PartitionRunnerRegistry, RunnerRegistryError> {
if self.max_runners == 0 || self.max_runners > MAX_RUNNERS_LIMIT {
return Err(RunnerRegistryError::InvalidConfig(
"max_runners must be within 1..=4096",
));
}
Ok(PartitionRunnerRegistry {
inner: Arc::new(RegistryInner {
max_runners: self.max_runners,
next_id: AtomicU64::new(1),
runners: Mutex::new(BTreeMap::new()),
}),
})
}
}
struct RegistryInner {
max_runners: usize,
next_id: AtomicU64,
runners: Mutex<BTreeMap<RunnerName, PartitionRunner>>,
}
#[derive(Clone)]
pub struct PartitionRunnerRegistry {
inner: Arc<RegistryInner>,
}
impl PartitionRunnerRegistry {
pub fn builder() -> PartitionRunnerRegistryBuilder {
PartitionRunnerRegistryBuilder {
max_runners: DEFAULT_MAX_RUNNERS,
}
}
pub fn get_or_create(
&self,
name: impl AsRef<str>,
config: RunnerConfig,
) -> Result<PartitionRunner, RunnerRegistryError> {
let name = RunnerName::new(name)?;
let config = config.validated()?;
let mut runners = self.inner.runners.lock().unwrap_or_else(|e| e.into_inner());
if let Some(existing) = runners.get(&name) {
return if existing.config() == &config {
Ok(existing.clone())
} else {
Err(RunnerRegistryError::ConfigConflict)
};
}
if runners.len() >= self.inner.max_runners {
return Err(RunnerRegistryError::RegistryFull);
}
let id = self
.inner
.next_id
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |value| {
value.checked_add(1)
})
.map_err(|_| RunnerRegistryError::IdExhausted)?;
let runner = PartitionRunner::registered(id, name.clone(), config);
runners.insert(name, runner.clone());
Ok(runner)
}
pub fn get(&self, name: impl AsRef<str>) -> Option<PartitionRunner> {
let name = RunnerName::new(name).ok()?;
self.inner
.runners
.lock()
.unwrap_or_else(|e| e.into_inner())
.get(&name)
.cloned()
}
pub async fn stop_all(&self, deadline: Instant) -> StopAllReport {
let runners = self
.inner
.runners
.lock()
.unwrap_or_else(|e| e.into_inner())
.values()
.cloned()
.collect::<Vec<_>>();
for runner in &runners {
runner.request_stop();
}
let mut results = Vec::with_capacity(runners.len());
for runner in runners.into_iter().rev() {
let name = runner.name().clone();
let result = runner.stop(deadline).await;
results.push(StopAllEntry {
name,
converged: result.is_ok(),
report: result.ok(),
});
}
results.sort_by(|left, right| left.name.cmp(&right.name));
StopAllReport {
converged: results.iter().all(|entry| entry.converged),
runners: results,
}
}
}
impl Default for PartitionRunnerRegistry {
fn default() -> Self {
Self::builder()
.build()
.expect("default runner registry bounds are valid")
}
}
#[derive(Debug, Clone)]
pub struct StopAllEntry {
pub name: RunnerName,
pub converged: bool,
pub report: Option<ShutdownReport>,
}
#[derive(Debug, Clone)]
pub struct StopAllReport {
pub converged: bool,
pub runners: Vec<StopAllEntry>,
}