use core::time::Duration;
use std::collections::BTreeSet;
use std::path::PathBuf;
use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
use tokio::sync::watch;
use shep_core::paths::ShepPaths;
use shep_core::protocol::Reply;
use crate::bus::{Bus, TopicFilter};
use crate::host::HostState;
use crate::limits::stats::StatsState;
use crate::secrets::ProviderSecrets;
use crate::snapshot::{FlockRegistry, SnapshotError, write_atomic};
use crate::supervisor::SupervisorHandle;
pub(crate) const DEFAULT_DEADLINE_MS: u64 = 5_000;
pub(crate) const MAX_DEADLINE_MS: u64 = 60_000;
#[derive(Debug, Clone)]
pub(crate) struct KnownDogs {
names: Arc<Mutex<BTreeSet<String>>>,
}
impl KnownDogs {
pub(crate) fn new(names: BTreeSet<String>) -> Self {
Self {
names: Arc::new(Mutex::new(names)),
}
}
pub(crate) fn contains(&self, name: &str) -> bool {
self.lock().contains(name)
}
pub(crate) fn insert(&self, name: &str) {
self.lock().insert(name.to_owned());
}
fn lock(&self) -> MutexGuard<'_, BTreeSet<String>> {
self.names.lock().unwrap_or_else(PoisonError::into_inner)
}
}
#[derive(Clone, Debug)]
pub struct RpcContext {
pub(crate) supervisor: SupervisorHandle,
pub(crate) events: Bus,
pub(crate) registry: FlockRegistry,
pub(crate) snapshot_path: PathBuf,
pub(crate) dogs_config: PathBuf,
pub(crate) known_dogs: KnownDogs,
pub(crate) dog_names: Vec<String>,
pub(crate) boot_first_dogs: Vec<String>,
pub(crate) paths: ShepPaths,
pub(crate) daemon_version: String,
pub(crate) dog_refusals: crate::dogs::DogRefusals,
pub(crate) peer_contacts: crate::dogs::PeerContacts,
pub(crate) pid: u32,
pub(crate) shutdown: Arc<watch::Sender<bool>>,
pub(crate) stats: Arc<StatsState>,
pub(crate) host: Arc<HostState>,
pub(crate) provider_secrets: Arc<ProviderSecrets>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SavedRoll {
pub path: PathBuf,
pub apps: u32,
}
impl RpcContext {
pub fn shutdown(&self) {
let _ = self.shutdown.send(true);
}
pub fn announce_dog_config(&self, dogs: &[String]) {
crate::bus::publish_dog_config_changed(&self.events, dogs);
}
pub async fn save_roll_now(&self) -> Result<Option<SavedRoll>, SnapshotError> {
let Ok(infos) = self.supervisor.list_checked().await else {
return Ok(None);
};
let roll = self.registry.roll(&infos, crate::now_ms());
write_atomic(&self.snapshot_path, &roll)?;
Ok(Some(SavedRoll {
path: self.snapshot_path.clone(),
apps: u32::try_from(roll.apps.len()).unwrap_or(u32::MAX),
}))
}
pub async fn snapshot_now(&self) -> Result<(), SnapshotError> {
self.save_roll_now().await.map(|_| ())
}
}
#[derive(Debug)]
pub(crate) enum Outcome {
Reply(Reply),
Subscribe {
reply: Reply,
filter: TopicFilter,
},
Shutdown(Reply),
}
#[must_use]
pub(crate) fn budget(deadline_ms: Option<u64>) -> Duration {
Duration::from_millis(
deadline_ms
.unwrap_or(DEFAULT_DEADLINE_MS)
.clamp(1, MAX_DEADLINE_MS),
)
}