use core::time::Duration;
use std::collections::BTreeMap;
use std::os::fd::{AsFd, OwnedFd};
use std::sync::{Arc, Mutex, PoisonError};
use tokio::sync::Notify;
use tokio::time::Instant;
use super::origin::Side;
use crate::handover::DogConnection;
#[derive(Debug)]
struct Held {
name: String,
launch_for: Option<String>,
pid: u32,
fd: OwnedFd,
topics: Option<Vec<String>>,
reader_parked: bool,
writer_parked: bool,
}
impl Held {
const fn parked(&self) -> bool {
self.reader_parked && self.writer_parked
}
}
#[derive(Debug, Default)]
struct Rows {
frozen: bool,
next: u64,
held: BTreeMap<u64, Held>,
}
#[derive(Debug, Clone, Default)]
pub(crate) struct DogLinks {
rows: Arc<Mutex<Rows>>,
changed: Arc<Notify>,
}
impl DogLinks {
pub(super) fn register(
&self,
name: &str,
launch_for: Option<&str>,
pid: u32,
stream: &impl AsFd,
resumed: Option<Vec<String>>,
) -> Lease {
let fd = match stream.as_fd().try_clone_to_owned() {
Ok(fd) => fd,
Err(error) => {
tracing::warn!(dog = name, %error, "a dog connection could not be tracked for a handover");
return Lease::untracked();
}
};
let mut rows = self.lock();
let key = rows.next;
rows.next += 1;
rows.held.insert(
key,
Held {
name: name.to_owned(),
launch_for: launch_for.map(str::to_owned),
pid,
fd,
topics: resumed,
reader_parked: false,
writer_parked: false,
},
);
Lease {
tracked: Some((self.clone(), key)),
}
}
pub(crate) async fn freeze(&self, within: Duration) -> Vec<DogConnection> {
self.lock().frozen = true;
self.changed.notify_waiters();
let deadline = Instant::now() + within;
loop {
let changed = self.changed.notified();
tokio::pin!(changed);
changed.as_mut().enable();
if self.lock().held.values().all(Held::parked) {
break;
}
if tokio::time::timeout_at(deadline, changed).await.is_err() {
break;
}
}
let rows = self.lock();
for held in rows.held.values().filter(|held| !held.parked()) {
tracing::warn!(
dog = held.name,
"a dog connection was mid-frame at a handover and is not carried"
);
}
Self::copy(&rows, Held::parked)
}
pub(crate) fn thaw(&self) {
self.lock().frozen = false;
self.changed.notify_waiters();
}
#[cfg(test)]
pub(super) fn snapshot(&self) -> Vec<DogConnection> {
Self::copy(&self.lock(), |_| true)
}
fn copy(rows: &Rows, wanted: impl Fn(&Held) -> bool) -> Vec<DogConnection> {
rows.held
.values()
.filter(|held| wanted(held))
.filter_map(|held| {
Some(DogConnection {
name: held.name.clone(),
launch_for: held.launch_for.clone(),
pid: held.pid,
fd: held.fd.try_clone().ok()?,
topics: held.topics.clone(),
})
})
.collect()
}
fn lock(&self) -> std::sync::MutexGuard<'_, Rows> {
self.rows.lock().unwrap_or_else(PoisonError::into_inner)
}
}
#[derive(Debug)]
pub(super) struct Lease {
tracked: Option<(DogLinks, u64)>,
}
impl Lease {
pub(super) const fn untracked() -> Self {
Self { tracked: None }
}
pub(super) async fn greeted(&self) {
self.update(|topics| {
topics.get_or_insert_with(Vec::new);
})
.await;
}
pub(super) async fn subscribed(&self, patterns: &[String]) {
self.update(|topics| *topics = Some(patterns.to_vec()))
.await;
}
async fn update(&self, change: impl FnOnce(&mut Option<Vec<String>>)) {
let Some((links, key)) = &self.tracked else {
return;
};
let mut change = Some(change);
loop {
let changed = links.changed.notified();
tokio::pin!(changed);
changed.as_mut().enable();
{
let mut rows = links.lock();
if !rows.frozen {
if let (Some(held), Some(change)) = (rows.held.get_mut(key), change.take()) {
change(&mut held.topics);
}
return;
}
}
changed.await;
}
}
pub(super) async fn frozen(&self) {
let Some((links, _)) = &self.tracked else {
return core::future::pending().await;
};
loop {
let changed = links.changed.notified();
tokio::pin!(changed);
changed.as_mut().enable();
if links.lock().frozen {
return;
}
changed.await;
}
}
pub(super) async fn park(&self, side: Side) {
let Some((links, _)) = &self.tracked else {
return;
};
self.mark(side, true);
loop {
let changed = links.changed.notified();
tokio::pin!(changed);
changed.as_mut().enable();
if !links.lock().frozen {
break;
}
changed.await;
}
self.mark(side, false);
}
fn mark(&self, side: Side, parked: bool) {
let Some((links, key)) = &self.tracked else {
return;
};
if let Some(held) = links.lock().held.get_mut(key) {
match side {
Side::Reader => held.reader_parked = parked,
Side::Writer => held.writer_parked = parked,
}
}
links.changed.notify_waiters();
}
}
impl Drop for Lease {
fn drop(&mut self) {
if let Some((links, key)) = &self.tracked {
links.lock().held.remove(key);
}
}
}
#[cfg(test)]
mod tests;