use std::{
collections::{BTreeMap, HashMap},
ffi::OsString,
hash::Hash,
marker::PhantomData,
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
time::{Duration, Instant},
vec::Vec,
};
use agnostic_lite::RuntimeLite;
use futures_util::FutureExt;
use tributary_proto::Epoch;
#[cfg(feature = "fs")]
use tributary_fs::{RootHandle, WatcherOptions};
use crate::{
coalesce::Coalescer,
error::{CloseError, SyncError, UnwatchError, WatchError},
event::Event,
filter::{Filter, FilterInput},
options::{Debounce, DebounceConfig, TributariesOptions, WatchOptions},
route::RoutableEvent,
source::{Armed, LocalSource, Source, SourceEvent, SyncOutcome, SyncToken},
subscription::Subscription,
subsume::{Subsumer, UnwatchOutcome, WatchOutcome},
view::WatchView,
};
#[cfg(feature = "fs")]
use crate::{error::BuildError, source::FsSource};
use self::epoch::EpochLedger;
mod epoch;
#[cfg(all(test, feature = "tokio"))]
mod tests;
type CloseReply = futures_channel::oneshot::Sender<Result<(), CloseError>>;
enum Command<C, V> {
Watch {
key: Vec<C>,
value: V,
options: WatchOptions<C>,
reply: futures_channel::oneshot::Sender<Result<WatchGrant, WatchError>>,
},
Unwatch {
sub: Subscription,
reply: futures_channel::oneshot::Sender<Result<(), UnwatchError>>,
},
}
struct SyncRequest {
sub: Subscription,
loss_gen_at_call: u64,
reply: futures_channel::oneshot::Sender<Result<SyncOutcome, SyncError>>,
}
struct PendingSync<C, H> {
cookie_key: Vec<C>,
sub: Subscription,
root: H,
loss_serial_at_install: u64,
dominated_at_install: bool,
reply: futures_channel::oneshot::Sender<Result<SyncOutcome, SyncError>>,
}
enum Cleanup {
Claim(Subscription),
DropOrphan(Subscription),
}
struct WatchGrant {
sub: Subscription,
cleanup: async_channel::Sender<Cleanup>,
defused: bool,
}
impl WatchGrant {
fn new(sub: Subscription, cleanup: async_channel::Sender<Cleanup>) -> Self {
Self {
sub,
cleanup,
defused: false,
}
}
fn defuse(mut self) -> Result<Subscription, Subscription> {
self.defused = true;
match self.cleanup.try_send(Cleanup::Claim(self.sub)) {
Ok(()) => Ok(self.sub),
Err(_) => Err(self.sub),
}
}
}
impl Drop for WatchGrant {
fn drop(&mut self) {
if !self.defused {
let _ = self.cleanup.try_send(Cleanup::DropOrphan(self.sub));
}
}
}
pub struct Tributaries<C, V, R, H> {
commands: async_channel::Sender<Command<C, V>>,
sync_commands: async_channel::Sender<SyncRequest>,
loss_gen: Arc<AtomicU64>,
closes: async_channel::Sender<CloseReply>,
events: async_channel::Receiver<Event<C, V>>,
view: WatchView<C, V, H>,
_rt: PhantomData<fn() -> R>,
}
impl<C, V, R, H> core::fmt::Debug for Tributaries<C, V, R, H> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Tributaries")
.field("view", &self.view)
.finish_non_exhaustive()
}
}
impl<C, V, R, H> Clone for Tributaries<C, V, R, H> {
#[inline]
fn clone(&self) -> Self {
Self {
commands: self.commands.clone(),
sync_commands: self.sync_commands.clone(),
loss_gen: Arc::clone(&self.loss_gen),
closes: self.closes.clone(),
events: self.events.clone(),
view: self.view.clone(),
_rt: PhantomData,
}
}
}
impl<C, V, R, H> Tributaries<C, V, R, H>
where
C: Ord + Clone + Send + Sync + 'static,
V: Clone + Send + Sync + 'static,
R: RuntimeLite,
H: Copy + Eq + Hash + Send + Sync + 'static,
{
pub fn with_source<S>(source: S, options: impl Into<TributariesOptions>) -> Self
where
S: Source<C, Handle = H> + Send + 'static,
{
let (this, driver) = Self::parts(source, options);
R::spawn_detach(driver);
this
}
pub fn parts<S>(
source: S,
options: impl Into<TributariesOptions>,
) -> (Self, impl Future<Output = ()> + Send + 'static)
where
S: Source<C, Handle = H> + Send + 'static,
{
let (this, owner) = Self::assemble(source, options.into());
(this, run(owner))
}
pub fn parts_local<S>(
source: S,
options: impl Into<TributariesOptions>,
) -> (Self, impl Future<Output = ()> + 'static)
where
S: LocalSource<C, Handle = H> + 'static,
{
let (this, owner) = Self::assemble(source, options.into());
(this, run(owner))
}
fn assemble<S>(source: S, options: TributariesOptions) -> (Self, Owner<C, V, R, S>)
where
S: LocalSource<C, Handle = H>,
{
let (event_capacity, command_capacity, debounce) = options.into_parts();
let subsumer = Subsumer::new();
let view = subsumer.view();
let (event_tx, event_rx) = async_channel::bounded(event_capacity.get());
let (command_tx, command_rx) = async_channel::bounded(command_capacity.get());
let (sync_command_tx, sync_command_rx) = async_channel::bounded(command_capacity.get());
let (close_tx, close_rx) = async_channel::bounded(1);
let (cleanup_tx, cleanup_rx) = async_channel::unbounded();
let loss_gen = Arc::new(AtomicU64::new(0));
let owner = Owner {
source,
subsumer,
epochs: EpochLedger::new(),
filters: HashMap::new(),
needs_rescan: BTreeMap::new(),
suppressed_rescan: BTreeMap::new(),
unclaimed: std::collections::HashSet::new(),
flush_cursor: None,
#[cfg(test)]
last_flush_visited: 0,
#[cfg(test)]
test_pre_cut_claims: Vec::new(),
debounce,
coalescer: debounce.map(|config| Coalescer::new(Some(config))),
pending_syncs: Vec::new(),
sync_seq: 0,
sync_nonce_seed: std::collections::hash_map::RandomState::new(),
loss_serial: HashMap::new(),
loss_gen: Arc::clone(&loss_gen),
cleanup_tx,
cleanup_rx,
commands: command_rx,
sync_commands: sync_command_rx,
closes: close_rx,
events: event_tx,
#[cfg(debug_assertions)]
observed_handles: std::collections::HashSet::new(),
_rt: PhantomData::<R>,
};
(
Self {
commands: command_tx,
sync_commands: sync_command_tx,
loss_gen,
closes: close_tx,
events: event_rx,
view,
_rt: PhantomData,
},
owner,
)
}
}
impl<C, V, R, H> Tributaries<C, V, R, H> {
#[inline]
#[must_use]
pub fn view(&self) -> WatchView<C, V, H> {
self.view.clone()
}
pub async fn watch(
&self,
key: Vec<C>,
value: V,
options: WatchOptions<C>,
) -> Result<Subscription, WatchError> {
let (reply, response) = futures_channel::oneshot::channel();
if self
.commands
.send(Command::Watch {
key,
value,
options,
reply,
})
.await
.is_err()
{
return Err(WatchError::Closed);
}
match response.await {
Ok(Ok(grant)) => grant.defuse().map_err(|_| WatchError::Closed),
Ok(Err(err)) => Err(err),
Err(_) => Err(WatchError::Closed),
}
}
pub async fn unwatch(&self, sub: Subscription) -> Result<(), UnwatchError> {
let (reply, response) = futures_channel::oneshot::channel();
if self
.commands
.send(Command::Unwatch { sub, reply })
.await
.is_err()
{
return Err(UnwatchError::Closed);
}
response.await.unwrap_or(Err(UnwatchError::Closed))
}
#[inline]
pub async fn next(&mut self) -> Option<Event<C, V>> {
self.events.recv().await.ok()
}
pub(crate) fn queued_events(&self) -> usize {
self.events.len()
}
pub async fn close(self) -> Result<(), CloseError> {
let (reply, response) = futures_channel::oneshot::channel();
if self.closes.send(reply).await.is_err() {
return Err(CloseError::Stopped);
}
response.await.unwrap_or(Err(CloseError::Stopped))
}
}
impl<C, V, R, H> Tributaries<C, V, R, H>
where
R: RuntimeLite,
{
pub async fn sync(
&self,
sub: Subscription,
timeout: core::time::Duration,
) -> Result<SyncOutcome, SyncError> {
let (reply, response) = futures_channel::oneshot::channel();
let tx = self.sync_commands.clone();
let loss_gen_at_call = self.loss_gen.load(Ordering::SeqCst);
let req = SyncRequest {
sub,
loss_gen_at_call,
reply,
};
match R::timeout(timeout, async move {
if tx.send(req).await.is_err() {
return Err(SyncError::Closed);
}
match response.await {
Ok(outcome) => outcome,
Err(_) => Err(SyncError::Closed),
}
})
.await
{
Ok(res) => res,
Err(_) => Err(SyncError::Timeout),
}
}
}
#[cfg(feature = "fs")]
#[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
impl<R: RuntimeLite> Tributaries<OsString, (), R, RootHandle> {
pub fn new(watcher: WatcherOptions, options: TributariesOptions) -> Result<Self, BuildError> {
let source = FsSource::<R>::new(watcher)?;
Ok(Self::with_source(source, options))
}
}
struct Owner<C, V, R, S>
where
S: LocalSource<C>,
{
source: S,
subsumer: Subsumer<C, V, S::Handle>,
epochs: EpochLedger,
filters: HashMap<Subscription, Filter<C>>,
needs_rescan: BTreeMap<Subscription, ParkedRescan<C, V>>,
suppressed_rescan: BTreeMap<Subscription, ParkedRescan<C, V>>,
unclaimed: std::collections::HashSet<Subscription>,
flush_cursor: Option<Subscription>,
#[cfg(test)]
last_flush_visited: usize,
#[cfg(test)]
test_pre_cut_claims: Vec<Cleanup>,
debounce: Option<DebounceConfig>,
coalescer: Option<Coalescer<C, V>>,
pending_syncs: Vec<PendingSync<C, S::Handle>>,
sync_seq: u64,
sync_nonce_seed: std::collections::hash_map::RandomState,
loss_serial: HashMap<Subscription, u64>,
loss_gen: Arc<AtomicU64>,
commands: async_channel::Receiver<Command<C, V>>,
sync_commands: async_channel::Receiver<SyncRequest>,
closes: async_channel::Receiver<CloseReply>,
cleanup_tx: async_channel::Sender<Cleanup>,
cleanup_rx: async_channel::Receiver<Cleanup>,
events: async_channel::Sender<Event<C, V>>,
#[cfg(debug_assertions)]
observed_handles: std::collections::HashSet<S::Handle>,
_rt: PhantomData<R>,
}
impl<C, V, R, S> Drop for Owner<C, V, R, S>
where
S: LocalSource<C>,
{
fn drop(&mut self) {
for pending in std::mem::take(&mut self.pending_syncs) {
self.source.end_sync(pending.root, &pending.cookie_key);
}
self.subsumer.publish_empty();
}
}
enum Flow {
Continue,
Break {
closing: Option<CloseReply>,
drain_owed: bool,
},
}
enum SyncAdmit {
Done,
CloseRequested(CloseReply),
}
enum SyncStep<C> {
Close(CloseReply),
Canceled,
Began(Result<Vec<C>, SyncError>),
}
#[derive(Debug)]
enum ReconcileStop {
Failed(WatchError),
CloseRequested(CloseReply),
}
impl From<WatchError> for ReconcileStop {
fn from(err: WatchError) -> Self {
Self::Failed(err)
}
}
enum ReplaceStep<C, H> {
Close(CloseReply),
HandlesGone,
Replaced(Result<Armed<C, H>, WatchError>),
}
async fn run<C, V, R, S>(mut owner: Owner<C, V, R, S>)
where
C: Ord + Clone,
V: Clone,
R: RuntimeLite,
S: LocalSource<C>,
{
let mut command_streak: u32 = 0;
let mut close_open = true;
let mut sync_open = true;
let (closing, drain_owed) = loop {
owner.prune_abandoned_syncs();
if close_open {
match owner.closes.try_recv() {
Ok(reply) => break (Some(reply), false),
Err(async_channel::TryRecvError::Closed) => close_open = false,
Err(async_channel::TryRecvError::Empty) => {}
}
}
if let Ok(req) = owner.sync_commands.try_recv() {
if let SyncAdmit::CloseRequested(reply) = owner
.on_sync(req.sub, req.loss_gen_at_call, req.reply)
.await
{
break (Some(reply), false);
}
}
owner.drain_pending_cleanup();
owner.flush_pending_rescans();
if command_streak >= COMMAND_FAIRNESS_BUDGET {
command_streak = 0;
match owner.source.next().now_or_never() {
Some(Some(event)) => owner.consume_source_event(&event),
Some(None) => break (None, true),
None => {}
}
owner.drain_coalescer_due();
}
let coalescer_deadline = owner.coalescer.as_ref().and_then(Coalescer::next_deadline);
let retry_deadline =
(!owner.needs_rescan.is_empty()).then(|| Into::<Instant>::into(R::now()) + RETRY);
let deadline = min_deadline(coalescer_deadline, retry_deadline);
let timer = async {
match deadline {
Some(at) => {
R::sleep_until(at.into()).await;
}
None => futures_util::future::pending::<()>().await,
}
}
.fuse();
futures_util::pin_mut!(timer);
let closes = &owner.closes;
let close_arm = async move {
if close_open {
closes.recv().await.ok()
} else {
futures_util::future::pending::<Option<CloseReply>>().await
}
};
let cleanup_rx = &owner.cleanup_rx;
let cleanup_arm = async move { cleanup_rx.recv().await };
let sync_commands = &owner.sync_commands;
let sync_arm = async move {
if sync_open {
sync_commands.recv().await.ok()
} else {
futures_util::future::pending::<Option<SyncRequest>>().await
}
};
let flow = futures_util::select_biased! {
maybe_reply = close_arm.fuse() => match maybe_reply {
Some(reply) => Flow::Break { closing: Some(reply), drain_owed: false },
None => {
close_open = false;
Flow::Continue
}
},
cleanup = cleanup_arm.fuse() => {
if let Ok(cleanup) = cleanup {
owner.apply_cleanup(cleanup);
}
Flow::Continue
}
cmd = owner.commands.recv().fuse() => {
command_streak += 1;
owner.dispatch_command(cmd).await
}
maybe_req = sync_arm.fuse() => match maybe_req {
Some(req) => {
command_streak += 1;
match owner.on_sync(req.sub, req.loss_gen_at_call, req.reply).await {
SyncAdmit::Done => Flow::Continue,
SyncAdmit::CloseRequested(reply) => Flow::Break {
closing: Some(reply),
drain_owed: false,
},
}
}
None => {
sync_open = false;
Flow::Continue
}
},
raw = owner.source.next().fuse() => { command_streak = 0; match raw {
Some(event) => {
owner.consume_source_event(&event);
Flow::Continue
}
None => Flow::Break { closing: None, drain_owed: true },
} },
_ = timer => {
command_streak = 0;
owner.drain_coalescer_due();
Flow::Continue
}
};
match flow {
Flow::Continue => {}
Flow::Break {
closing,
drain_owed,
} => break (closing, drain_owed),
}
};
owner.reap_all_pending_syncs();
while let Ok(req) = owner.sync_commands.try_recv() {
let _ = req.reply.send(Err(SyncError::Closed));
}
let ack = if drain_owed {
let interrupted = owner.drain_owed_before_shutdown().await;
owner.cleanup_rx.close();
owner.drain_pending_cleanup();
owner.drain_owed_once();
interrupted
} else {
owner.cleanup_rx.close();
owner.drain_pending_cleanup();
owner.drain_owed_once();
closing
};
owner.subsumer.publish_empty();
if let Some(reply) = ack {
let _ = reply.send(Ok(()));
}
}
const RETRY: Duration = Duration::from_millis(25);
const COMMAND_FAIRNESS_BUDGET: u32 = 32;
fn min_deadline(a: Option<Instant>, b: Option<Instant>) -> Option<Instant> {
match (a, b) {
(Some(a), Some(b)) => Some(a.min(b)),
(a, b) => a.or(b),
}
}
impl<C, V, R, S> Owner<C, V, R, S>
where
C: Ord + Clone,
V: Clone,
R: RuntimeLite,
S: LocalSource<C>,
{
async fn dispatch_command(
&mut self,
cmd: Result<Command<C, V>, async_channel::RecvError>,
) -> Flow {
match cmd {
Ok(Command::Watch {
key,
value,
options,
reply,
}) => match self.on_watch(key, value, options, reply).await {
None => Flow::Continue,
Some(close_reply) => Flow::Break {
closing: Some(close_reply),
drain_owed: false,
},
},
Ok(Command::Unwatch { sub, reply }) => {
self.on_unwatch(sub, reply);
Flow::Continue
}
Err(_) => Flow::Break {
closing: None,
drain_owed: false,
},
}
}
fn apply_cleanup(&mut self, cleanup: Cleanup) {
match cleanup {
Cleanup::Claim(sub) => {
self.unclaimed.remove(&sub);
if let Some(parked) = self.suppressed_rescan.remove(&sub) {
merge_max(
&mut self.needs_rescan,
sub,
parked.key,
parked.epoch,
parked.value,
);
}
}
Cleanup::DropOrphan(sub) => {
let _ = self.release_subscription(sub);
}
}
}
fn drain_pending_cleanup(&mut self) {
while let Ok(cleanup) = self.cleanup_rx.try_recv() {
self.apply_cleanup(cleanup);
}
}
async fn on_watch(
&mut self,
key: Vec<C>,
value: V,
options: WatchOptions<C>,
reply: futures_channel::oneshot::Sender<Result<WatchGrant, WatchError>>,
) -> Option<CloseReply> {
match self.reconcile_watch(&key, value, options).await {
Ok(sub) => {
match reply.send(Ok(WatchGrant::new(sub, self.cleanup_tx.clone()))) {
Ok(()) => {
self.unclaimed.insert(sub);
}
Err(Ok(grant)) => {
let sub = match grant.defuse() {
Ok(sub) | Err(sub) => sub,
};
let _ = self.release_subscription(sub);
}
Err(Err(_)) => {}
}
None
}
Err(ReconcileStop::Failed(err)) => {
let _ = reply.send(Err(err));
None
}
Err(ReconcileStop::CloseRequested(close_reply)) => {
drop(reply);
Some(close_reply)
}
}
}
fn on_unwatch(
&mut self,
sub: Subscription,
reply: futures_channel::oneshot::Sender<Result<(), UnwatchError>>,
) {
let result = self.release_subscription(sub);
let _ = reply.send(result);
}
const RETIRED_RESCAN_DEBT_LIMIT: usize = 1024;
async fn reconcile_watch(
&mut self,
key: &[C],
value: V,
options: WatchOptions<C>,
) -> Result<Subscription, ReconcileStop> {
let (interest, filter, debounce) = options.into_parts();
let retired_debt = self
.needs_rescan
.keys()
.chain(self.suppressed_rescan.keys())
.filter(|&&sub| self.subsumer.subscription_key(sub).is_none())
.count();
if retired_debt >= Self::RETIRED_RESCAN_DEBT_LIMIT {
return Err(WatchError::RescanBacklog.into());
}
let canonical_key = self.source.canonicalize_key(key)?;
let key = canonical_key.as_slice();
let outcome = loop {
let outcome = self.subsumer.plan_watch(key, value.clone(), interest);
if let WatchOutcome::Covered { fs_root, .. } = &outcome {
let covering = *fs_root;
if self.source.root_key(covering).is_none() {
self.subsumer.abort_watch(&outcome);
self.retire_root_with_terminal_rescan(covering);
continue;
}
}
break outcome;
};
match &outcome {
WatchOutcome::Covered {
fs_root,
sub,
outside_cover,
} => {
let (fs_root, sub, outside_cover) = (*fs_root, *sub, *outside_cover);
let record_cover = if outside_cover {
match self.subsumer.retained_cover_for(fs_root, Some(key)) {
Some(cover) => {
if let Err(err) = self.source.grow(fs_root, &cover).await {
self.subsumer.abort_watch(&outcome);
return Err(err.into());
}
Some(Some(cover))
}
None => {
match self
.subsumer
.entry(fs_root)
.map(|record| record.key.clone())
{
Some(root_key) => {
if let Err(err) = self.source.grow(fs_root, &[root_key]).await {
self.subsumer.abort_watch(&outcome);
return Err(err.into());
}
Some(None)
}
None => None,
}
}
}
} else {
None
};
self.subsumer.commit_watch(&outcome, fs_root, key);
self.filters.insert(sub, filter);
self.register_debounce(sub, debounce);
if let Some(cover) = record_cover {
self.subsumer.set_retained_cover(fs_root, cover);
}
Ok(sub)
}
WatchOutcome::Disjoint { sub, .. } => {
let sub = *sub;
let armed = match self.arm(key).await {
Ok(armed) => armed,
Err(err) => {
self.subsumer.abort_watch(&outcome);
return Err(err.into());
}
};
let (handle, fs_key) = armed;
if !self.subsumer.fs_path_preserves_plan(&fs_key, &[]) {
self.source.disarm(handle);
self.subsumer.abort_watch(&outcome);
return Err(canonical_race().into());
}
self.subsumer.commit_watch(&outcome, handle, &fs_key);
self.filters.insert(sub, filter);
self.register_debounce(sub, debounce);
Ok(sub)
}
WatchOutcome::Widen {
repointed,
unwatch,
sub,
..
} => {
let sub = *sub;
let repointed = repointed.clone();
let in_place = match unwatch.as_slice() {
[only] => self
.source
.root_key(*only)
.map(|only_key| (*only, only_key)),
_ => None,
};
let retargeted = match in_place {
Some((only, only_key)) => match self.replace_racing_close(only, key).await {
ReplaceStep::Replaced(Ok(armed)) => Some((armed, only_key)),
ReplaceStep::Replaced(Err(_)) => None,
ReplaceStep::Close(close_reply) => {
self.subsumer.abort_watch(&outcome);
return Err(ReconcileStop::CloseRequested(close_reply));
}
ReplaceStep::HandlesGone => {
self.subsumer.abort_watch(&outcome);
return Err(WatchError::Closed.into());
}
},
None => None,
};
if let Some((armed, only_key)) = retargeted {
let handle = armed.handle();
let fs_key = armed.canonical_key().to_vec();
if self.subsumer.fs_path_preserves_plan(&fs_key, unwatch) {
self.commit_widen(&outcome, handle, &fs_key, sub, filter, debounce, &repointed);
return Ok(sub);
}
let restored = match self.replace_racing_close(handle, &only_key).await {
ReplaceStep::Replaced(res) => {
matches!(res, Ok(armed) if armed.canonical_key() == only_key.as_slice())
}
ReplaceStep::Close(close_reply) => {
self.subsumer.abort_watch(&outcome);
return Err(ReconcileStop::CloseRequested(close_reply));
}
ReplaceStep::HandlesGone => {
self.subsumer.abort_watch(&outcome);
return Err(WatchError::Closed.into());
}
};
if restored {
self.rescan_live_root(handle);
self.subsumer.abort_watch(&outcome);
return Err(canonical_race().into());
}
self.retire_root_with_terminal_rescan(handle);
self.source.disarm(handle);
self.subsumer.abort_watch(&outcome);
return Err(canonical_race().into());
}
for &old in unwatch {
self.source.disarm(old);
}
let armed = match self.arm(key).await {
Ok(armed) => armed,
Err(err) => {
let restore = self.restore_disarmed_roots(unwatch);
restore.await;
self.subsumer.abort_watch(&outcome);
return Err(err.into());
}
};
let (handle, fs_key) = armed;
if !self.subsumer.fs_path_preserves_plan(&fs_key, unwatch) {
self.source.disarm(handle);
let restore = self.restore_disarmed_roots(unwatch);
restore.await;
self.subsumer.abort_watch(&outcome);
return Err(canonical_race().into());
}
self.commit_widen(&outcome, handle, &fs_key, sub, filter, debounce, &repointed);
Ok(sub)
}
}
}
async fn replace_racing_close(
&mut self,
handle: S::Handle,
new_key: &[C],
) -> ReplaceStep<C, S::Handle> {
let closes = &self.closes;
let source = &mut self.source;
futures_util::select_biased! {
close = closes.recv().fuse() => match close {
Ok(close_reply) => ReplaceStep::Close(close_reply),
Err(_) => ReplaceStep::HandlesGone,
},
res = source.replace(handle, new_key).fuse() => ReplaceStep::Replaced(res),
}
}
#[allow(clippy::too_many_arguments)]
fn commit_widen(
&mut self,
outcome: &WatchOutcome<C, S::Handle>,
handle: S::Handle,
fs_key: &[C],
sub: Subscription,
filter: Filter<C>,
debounce: Debounce,
repointed: &[Subscription],
) {
self.subsumer.commit_watch(outcome, handle, fs_key);
self.filters.insert(sub, filter);
self.register_debounce(sub, debounce);
let mut rescans = Vec::with_capacity(repointed.len());
for &moved in repointed {
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.drop_subscription(moved);
}
let rescan = self.epochs.repoint(moved);
let mut event = Event::rescan(moved, fs_key.to_vec(), rescan);
event.set_value(self.subsumer.subscription_value(moved).cloned());
rescans.push(event);
}
self.push_all(rescans);
for &moved in repointed {
self.dominate_syncs_of_subscription(moved);
}
}
fn register_debounce(&mut self, sub: Subscription, debounce: Debounce) {
match debounce {
Debounce::Inherit => {}
Debounce::Off => {
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.set_policy(sub, debounce);
}
}
Debounce::Custom(_) => {
let default = self.debounce;
self
.coalescer
.get_or_insert_with(|| Coalescer::new(default))
.set_policy(sub, debounce);
}
}
}
async fn arm(&mut self, key: &[C]) -> Result<(S::Handle, Vec<C>), WatchError> {
let armed = self.source.arm(key).await?;
let handle = armed.handle();
if self.source.root_key(handle).is_none() {
self.source.disarm(handle);
return Err(WatchError::DeadOnArrival);
}
#[cfg(debug_assertions)]
debug_assert!(
self.observed_handles.insert(handle),
"Source::arm returned a handle already observed by this owner (a reused handle, even after \
retirement) — a generation-unique Source::Handle contract violation; see Source::Handle"
);
Ok((handle, armed.canonical_key().to_vec()))
}
fn release_subscription(&mut self, sub: Subscription) -> Result<(), UnwatchError> {
self.retire_syncs_of_subscription(sub);
if sub.instance() != self.subsumer.instance() {
return Err(UnwatchError::UnknownSubscription);
}
self.retire_sub_state(sub);
self.needs_rescan.remove(&sub);
self.suppressed_rescan.remove(&sub);
self.unclaimed.remove(&sub);
self.loss_serial.remove(&sub);
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.forget_subscription(sub);
}
let Some(outcome) = self.subsumer.plan_unwatch(sub) else {
return Err(UnwatchError::UnknownSubscription);
};
match outcome {
UnwatchOutcome::RootEmptied { fs_root } => {
self.source.disarm(fs_root);
}
UnwatchOutcome::Dropped {
shrink: Some((handle, retained)),
} => {
self.source.set_cover(handle, &retained);
self.subsumer.set_retained_cover(handle, Some(retained));
}
UnwatchOutcome::Dropped { shrink: None } => {}
}
Ok(())
}
fn retire_sub_state(&mut self, sub: Subscription) {
self.filters.remove(&sub);
self.epochs.remove(sub);
self.loss_serial.remove(&sub);
}
async fn restore_disarmed_roots(&mut self, unwatch: &[S::Handle]) {
for &old in unwatch {
let Some((root_key, subscribers)) = self
.subsumer
.entry(old)
.map(|record| (record.key.clone(), record.subscribers.clone()))
else {
continue;
};
match self.arm(&root_key).await {
Ok((new_handle, fs_key)) if fs_key == root_key => {
self.subsumer.rebind_root(old, new_handle);
let mut rescans = Vec::with_capacity(subscribers.len());
for &sub in &subscribers {
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.drop_subscription(sub);
}
let rescan = self.epochs.repoint(sub);
let mut event = Event::rescan(sub, root_key.clone(), rescan);
event.set_value(self.subsumer.subscription_value(sub).cloned());
rescans.push(event);
}
self.push_all(rescans);
for &sub in &subscribers {
self.dominate_syncs_of_subscription(sub);
}
}
Ok((new_handle, _diverged)) => {
self.source.disarm(new_handle);
self.retire_root_with_terminal_rescan(old);
}
Err(_) => self.retire_root_with_terminal_rescan(old),
}
}
}
fn retire_root_with_terminal_rescan(&mut self, handle: S::Handle) {
self.rescan_live_root(handle);
for sub in self.subsumer.force_remove_root(handle) {
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.forget_subscription(sub);
}
self.retire_sub_state(sub);
}
}
fn rescan_live_root(&mut self, root: S::Handle) {
let Some((root_key, subscribers)) = self
.subsumer
.entry(root)
.map(|record| (record.key.clone(), record.subscribers.clone()))
else {
return;
};
for &sub in &subscribers {
self.note_loss(sub);
let value = self.subsumer.subscription_value(sub).cloned();
let epoch = self.epochs.shed_rescan(sub);
let target = if self.unclaimed.contains(&sub) {
&mut self.suppressed_rescan
} else {
&mut self.needs_rescan
};
merge_max(target, sub, root_key.clone(), epoch, value);
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.drop_subscription(sub);
}
}
self.dominate_syncs_of_root(root);
}
fn fan_out_and_push(&mut self, raw: &SourceEvent<C, S::Handle>) {
let fanned = self.fan_out_raw(raw);
self.push_all(fanned);
}
fn try_emit(&mut self, ev: Event<C, V>) {
let sub = ev.subscription();
if self.needs_rescan.contains_key(&sub) || self.suppressed_rescan.contains_key(&sub) {
if ev.is_rescan() {
self.park_rescan_event(ev);
} else {
self.note_loss(sub);
}
return;
}
match self.events.try_send(ev) {
Ok(()) => {}
Err(async_channel::TrySendError::Full(ev)) => {
if ev.is_rescan() {
self.park_rescan_event(ev);
} else {
self.park_rescan(sub);
}
}
Err(async_channel::TrySendError::Closed(_)) => {}
}
}
fn note_loss(&mut self, sub: Subscription) {
*self.loss_serial.entry(sub).or_insert(0) += 1;
self.loss_gen.fetch_add(1, Ordering::SeqCst);
}
fn note_domination(&self) {
self.loss_gen.fetch_add(1, Ordering::SeqCst);
}
fn park_rescan(&mut self, sub: Subscription) {
self.note_loss(sub);
let Some(key) = self.subsumer.subscription_key(sub).map(<[C]>::to_vec) else {
return;
};
let value = self.subsumer.subscription_value(sub).cloned();
let epoch = self.epochs.shed_rescan(sub);
let target = if self.unclaimed.contains(&sub) {
&mut self.suppressed_rescan
} else {
&mut self.needs_rescan
};
merge_max(target, sub, key, epoch, value);
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.drop_subscription(sub);
}
}
fn park_rescan_event(&mut self, ev: Event<C, V>) {
let sub = ev.subscription();
self.note_loss(sub);
let target = if self.unclaimed.contains(&sub) {
&mut self.suppressed_rescan
} else {
&mut self.needs_rescan
};
merge_max(
target,
sub,
ev.key().to_vec(),
ev.epoch(),
ev.value().cloned(),
);
}
fn flush_pending_rescans(&mut self) {
#[cfg(test)]
{
self.last_flush_visited = 0;
}
if self.events.is_full() {
return;
}
let len = self.needs_rescan.len();
if len == 0 {
return;
}
let mut resume = self.flush_cursor.take();
let mut exclusive = false;
for _ in 0..len {
#[cfg(test)]
{
self.last_flush_visited += 1;
}
let bound = match (&resume, exclusive) {
(Some(at), false) => (std::ops::Bound::Included(*at), std::ops::Bound::Unbounded),
(Some(at), true) => (std::ops::Bound::Excluded(*at), std::ops::Bound::Unbounded),
(None, _) => (std::ops::Bound::Unbounded, std::ops::Bound::Unbounded),
};
let next = self
.needs_rescan
.range(bound)
.next()
.or_else(|| self.needs_rescan.iter().next())
.map(|(&sub, _)| sub);
let Some(sub) = next else {
break;
};
resume = Some(sub);
exclusive = true;
debug_assert!(
!self.unclaimed.contains(&sub),
"offerable parked debt for an unclaimed sub — a park missed the partition"
);
let Some(parked) = self.needs_rescan.get(&sub) else {
continue;
};
let mut event = Event::rescan(sub, parked.key.clone(), parked.epoch);
event.set_value(parked.value.clone());
match self.events.try_send(event) {
Ok(()) => {
self.note_domination();
self.needs_rescan.remove(&sub);
}
Err(async_channel::TrySendError::Closed(_)) => {
self.needs_rescan.remove(&sub);
}
Err(async_channel::TrySendError::Full(_)) => {
self.flush_cursor = Some(sub);
return;
}
}
}
self.flush_cursor = None;
}
fn fan_out_raw(&mut self, raw: &SourceEvent<C, S::Handle>) -> Vec<Event<C, V>> {
let (subsumer, filters, epochs) = (&self.subsumer, &self.filters, &mut self.epochs);
let Some(record) = subsumer.entry(raw.handle()) else {
return Vec::new();
};
let subscribers = record.subscribers.as_slice();
let routable = SourceRoutable::<C, V, S::Handle>::new(raw);
let raw_epoch = raw.epoch();
epochs.stamp_and_fan_out(
&routable,
raw_epoch,
subscribers,
|sub| subsumer.subscription_key(sub),
|sub, event: &Event<C, V>| {
subsumer
.subscription_interest(sub)
.is_some_and(|interest| interest.admits(event.kind()))
&& filters.get(&sub).is_some_and(|filter| {
filter.admits(&FilterInput::new(
event.key(),
event.kind(),
event.location(),
))
})
},
|event: &Event<C, V>| event.subscription(),
|mut event, stamp| {
event.set_epoch(stamp);
event.set_value(subsumer.subscription_value(event.subscription()).cloned());
event
},
)
}
fn consume_source_event(&mut self, event: &SourceEvent<C, S::Handle>) {
if !self.retire_if_dead(event) {
if !event.kind().is_rescan() && self.source.is_sync_artifact(event.key()) {
self.resolve_matching_pending_sync(event);
return;
}
let clamped = self.clamp_disjoint_live_root_rescan(event);
let event = clamped.as_ref().unwrap_or(event);
self.degrade_retained_cover_on_rescan(event);
self.fan_out_and_push(event);
if event.kind().is_rescan() {
self.dominate_pending_syncs(event);
}
}
}
fn clamp_disjoint_live_root_rescan(
&self,
event: &SourceEvent<C, S::Handle>,
) -> Option<SourceEvent<C, S::Handle>> {
if !event.kind().is_rescan() {
return None;
}
let root_key = self.source.root_key(event.handle())?;
let key = event.key();
if key.starts_with(root_key.as_slice()) || root_key.starts_with(key) {
return None;
}
Some(SourceEvent::new(
event.handle(),
root_key,
event.kind().clone(),
event.location().clone(),
event.epoch(),
event.change_id(),
))
}
async fn on_sync(
&mut self,
sub: Subscription,
loss_gen_at_call: u64,
mut reply: futures_channel::oneshot::Sender<Result<SyncOutcome, SyncError>>,
) -> SyncAdmit {
if reply.is_canceled() {
return SyncAdmit::Done;
}
let (Some(root), Some(dir_key)) = (
self.subsumer.subscription_root(sub),
self.subsumer.subscription_key(sub).map(<[C]>::to_vec),
) else {
let _ = reply.send(Err(SyncError::UnknownSubscription));
return SyncAdmit::Done;
};
self.sync_seq += 1;
let nonce = {
use std::hash::{BuildHasher, Hasher};
let mut hasher = self.sync_nonce_seed.build_hasher();
hasher.write_u64(self.sync_seq);
hasher.finish()
};
let token = SyncToken::new(
sub.instance().get(),
std::process::id(),
self.sync_seq,
nonce,
);
let step = {
let closes = &self.closes;
let source = &mut self.source;
futures_util::select_biased! {
res = source.begin_sync(root, &dir_key, token).fuse() => SyncStep::Began(res),
close = closes.recv().fuse() => match close {
Ok(close_reply) => SyncStep::Close(close_reply),
Err(_) => SyncStep::Canceled,
},
() = reply.cancellation().fuse() => SyncStep::Canceled,
}
};
match step {
SyncStep::Close(close_reply) => {
self.source.cancel_sync(root, token);
SyncAdmit::CloseRequested(close_reply)
}
SyncStep::Canceled => {
self.source.cancel_sync(root, token);
SyncAdmit::Done
}
SyncStep::Began(Ok(cookie_key)) => {
self.admit_begun_cookie(cookie_key, sub, root, loss_gen_at_call, reply);
SyncAdmit::Done
}
SyncStep::Began(Err(err)) => {
let _ = reply.send(Err(err));
SyncAdmit::Done
}
}
}
fn admit_begun_cookie(
&mut self,
cookie_key: Vec<C>,
sub: Subscription,
root: S::Handle,
loss_gen_at_call: u64,
reply: futures_channel::oneshot::Sender<Result<SyncOutcome, SyncError>>,
) {
if reply.is_canceled() {
self.source.end_sync(root, &cookie_key);
return;
}
let loss_serial_at_install = self.loss_serial.get(&sub).copied().unwrap_or(0);
let dominated_at_install = self.needs_rescan.contains_key(&sub)
|| self.suppressed_rescan.contains_key(&sub)
|| self.loss_gen.load(Ordering::SeqCst) != loss_gen_at_call;
self.pending_syncs.push(PendingSync {
cookie_key,
sub,
root,
loss_serial_at_install,
dominated_at_install,
reply,
});
}
fn resolve_matching_pending_sync(&mut self, event: &SourceEvent<C, S::Handle>) {
let Some(idx) = self
.pending_syncs
.iter()
.position(|pending| pending.cookie_key.as_slice() == event.key())
else {
return;
};
let pending = self.pending_syncs.swap_remove(idx);
let lost_during_window =
self.loss_serial.get(&pending.sub).copied().unwrap_or(0) != pending.loss_serial_at_install;
let dominated_at_install = pending.dominated_at_install;
self.reap_cookie(pending.root, &pending.cookie_key);
let clean =
self.flush_subscription_now(pending.sub) && !lost_during_window && !dominated_at_install;
let outcome = if clean {
SyncOutcome::Delivered
} else {
SyncOutcome::Dominated
};
let _ = pending.reply.send(Ok(outcome));
}
fn dominate_pending_syncs(&mut self, event: &SourceEvent<C, S::Handle>) {
self.note_domination();
let handle = event.handle();
let mut i = 0;
while i < self.pending_syncs.len() {
if self.pending_syncs[i].root == handle {
let pending = self.pending_syncs.swap_remove(i);
self.reap_cookie(pending.root, &pending.cookie_key);
self.flush_subscription_now(pending.sub);
let _ = pending.reply.send(Ok(SyncOutcome::Dominated));
} else {
i += 1;
}
}
}
fn dominate_syncs_of_root(&mut self, root: S::Handle)
where
S::Handle: PartialEq,
{
self.note_domination();
let mut i = 0;
while i < self.pending_syncs.len() {
if self.pending_syncs[i].root == root {
let pending = self.pending_syncs.swap_remove(i);
let _ = pending.reply.send(Ok(SyncOutcome::Dominated));
self.reap_cookie(pending.root, &pending.cookie_key);
} else {
i += 1;
}
}
}
fn dominate_syncs_of_subscription(&mut self, sub: Subscription) {
self.note_domination();
let mut i = 0;
while i < self.pending_syncs.len() {
if self.pending_syncs[i].sub == sub {
let pending = self.pending_syncs.swap_remove(i);
let _ = pending.reply.send(Ok(SyncOutcome::Dominated));
self.reap_cookie(pending.root, &pending.cookie_key);
} else {
i += 1;
}
}
}
fn retire_syncs_of_subscription(&mut self, sub: Subscription) {
let mut i = 0;
while i < self.pending_syncs.len() {
if self.pending_syncs[i].sub == sub {
let pending = self.pending_syncs.swap_remove(i);
let _ = pending.reply.send(Err(SyncError::Retired));
self.reap_cookie(pending.root, &pending.cookie_key);
} else {
i += 1;
}
}
}
fn prune_abandoned_syncs(&mut self) {
let mut i = 0;
while i < self.pending_syncs.len() {
if self.pending_syncs[i].reply.is_canceled() {
let pending = self.pending_syncs.swap_remove(i);
self.reap_cookie(pending.root, &pending.cookie_key);
} else {
i += 1;
}
}
}
fn reap_cookie(&mut self, root: S::Handle, cookie_key: &[C]) {
self.source.end_sync(root, cookie_key);
}
fn reap_all_pending_syncs(&mut self) {
for pending in std::mem::take(&mut self.pending_syncs) {
self.source.end_sync(pending.root, &pending.cookie_key);
}
}
fn flush_subscription_now(&mut self, sub: Subscription) -> bool {
let now: Instant = R::now().into();
let mut due = Vec::new();
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.flush_subscription(sub, now);
coalescer.drain_ready(now, &mut due);
}
for event in due {
self.try_emit(event);
}
!self.needs_rescan.contains_key(&sub)
}
fn degrade_retained_cover_on_rescan(&mut self, raw: &SourceEvent<C, S::Handle>) {
if !raw.kind().is_rescan() {
return;
}
self.subsumer.degrade_retained_cover(raw.handle());
}
fn retire_if_dead(&mut self, raw: &SourceEvent<C, S::Handle>) -> bool {
if self.source.root_key(raw.handle()).is_some() {
return false;
}
self.retire_root_with_terminal_rescan(raw.handle());
true
}
fn push_all(&mut self, events: Vec<Event<C, V>>) {
let (ready, overflowed) = match self.coalescer.as_mut() {
Some(coalescer) => {
let now: Instant = R::now().into();
let mut overflowed = Vec::new();
for event in events {
if let Some(sub) = coalescer.admit(event, now) {
overflowed.push(sub);
}
}
let mut ready = Vec::new();
coalescer.drain_ready(now, &mut ready);
(ready, overflowed)
}
None => (events, Vec::new()),
};
for sub in overflowed {
self.park_rescan(sub);
}
for event in ready {
self.try_emit(event);
}
}
fn drain_coalescer_due(&mut self) {
let mut ready = Vec::new();
if let Some(coalescer) = self.coalescer.as_mut() {
let now: Instant = R::now().into();
coalescer.drain_ready(now, &mut ready);
}
for event in ready {
self.try_emit(event);
}
}
fn drain_owed_once(&mut self) {
let mut tail = Vec::new();
if let Some(coalescer) = self.coalescer.as_mut() {
coalescer.flush_all(&mut tail);
}
tail.retain(|event| {
let sub = event.subscription();
!self.needs_rescan.contains_key(&sub) && !self.suppressed_rescan.contains_key(&sub)
});
self.flush_pending_rescans();
for event in tail {
self.try_emit(event);
}
}
async fn drain_owed_before_shutdown(&mut self) -> Option<CloseReply> {
let mut close_open = true;
let mut cleanup_open = true;
loop {
if close_open {
match self.closes.try_recv() {
Ok(reply) => return Some(reply),
Err(async_channel::TryRecvError::Closed) => close_open = false,
Err(async_channel::TryRecvError::Empty) => {}
}
}
self.drain_pending_cleanup();
self.drain_owed_once();
if (self.needs_rescan.is_empty() && self.cleanup_rx.is_empty()) || self.events.is_closed() {
#[cfg(test)]
for staged in self.test_pre_cut_claims.drain(..) {
let _ = self.cleanup_tx.try_send(staged);
}
self.cleanup_rx.close();
cleanup_open = false;
self.drain_pending_cleanup();
self.drain_owed_once();
if self.needs_rescan.is_empty() || self.events.is_closed() {
return None;
}
continue;
}
let sleep = R::sleep(RETRY).fuse();
futures_util::pin_mut!(sleep);
let closes = &self.closes;
let close_arm = async move {
if close_open {
closes.recv().await.ok()
} else {
futures_util::future::pending::<Option<CloseReply>>().await
}
};
let cleanup_rx = &self.cleanup_rx;
let cleanup_arm = async move {
if cleanup_open {
cleanup_rx.recv().await.ok()
} else {
futures_util::future::pending::<Option<Cleanup>>().await
}
};
futures_util::select_biased! {
maybe_reply = close_arm.fuse() => match maybe_reply {
Some(reply) => return Some(reply),
None => close_open = false,
},
cleanup = cleanup_arm.fuse() => match cleanup {
Some(cleanup) => self.apply_cleanup(cleanup),
None => cleanup_open = false,
},
cmd = self.commands.recv().fuse() => match cmd {
Ok(command) => self.handle_teardown_command(command),
Err(_) => return None,
},
_ = sleep => {}
}
}
}
fn handle_teardown_command(&mut self, cmd: Command<C, V>) {
match cmd {
Command::Watch { reply, .. } => {
let _ = reply.send(Err(WatchError::Closed));
}
Command::Unwatch { reply, .. } => {
let _ = reply.send(Err(UnwatchError::Closed));
}
}
}
}
struct ParkedRescan<C, V> {
key: Vec<C>,
epoch: Epoch,
value: Option<V>,
}
fn merge_max<C: PartialEq, V>(
needs_rescan: &mut BTreeMap<Subscription, ParkedRescan<C, V>>,
sub: Subscription,
key: Vec<C>,
epoch: Epoch,
value: Option<V>,
) {
use std::collections::btree_map::Entry;
match needs_rescan.entry(sub) {
Entry::Occupied(mut occupied) => {
let parked = occupied.get_mut();
let common = key
.iter()
.zip(parked.key.iter())
.take_while(|(a, b)| a == b)
.count();
parked.key.truncate(common);
parked.epoch = parked.epoch.max(epoch);
parked.value = value;
}
Entry::Vacant(vacant) => {
vacant.insert(ParkedRescan { key, epoch, value });
}
}
}
struct SourceRoutable<'a, C, V, H> {
event: &'a SourceEvent<C, H>,
_value: PhantomData<V>,
}
impl<'a, C, V, H> SourceRoutable<'a, C, V, H> {
#[inline]
fn new(event: &'a SourceEvent<C, H>) -> Self {
Self {
event,
_value: PhantomData,
}
}
}
impl<C, V, H> RoutableEvent<C> for SourceRoutable<'_, C, V, H>
where
C: Clone,
{
type Delivered = Event<C, V>;
#[inline]
fn key(&self) -> &[C] {
self.event.key()
}
#[inline]
fn move_from(&self) -> Option<&[C]> {
self.event.kind().moved_from()
}
#[inline]
fn is_rescan(&self) -> bool {
self.event.is_rescan()
}
#[inline]
fn deliver(&self, sub: Subscription) -> Event<C, V> {
Event::from_source(sub, self.event)
}
#[inline]
fn deliver_move_out(&self, sub: Subscription) -> Event<C, V> {
Event::source_move_out(sub, self.event)
}
#[inline]
fn deliver_move_in(&self, sub: Subscription) -> Event<C, V> {
Event::source_move_in(sub, self.event)
}
}
fn canonical_race() -> WatchError {
WatchError::CanonicalRace
}
#[cfg(all(feature = "fs", feature = "tokio"))]
#[allow(dead_code)]
fn assert_fs_owner_send() {
fn is_send<T: Send>() {}
is_send::<Tributaries<OsString, (), agnostic_lite::tokio::TokioRuntime, RootHandle>>();
fn owner_future_is_send(
owner: Owner<
OsString,
(),
agnostic_lite::tokio::TokioRuntime,
FsSource<agnostic_lite::tokio::TokioRuntime>,
>,
) {
fn needs_send<F: Send>(_: F) {}
needs_send(run(owner));
}
let _ = owner_future_is_send;
}
#[allow(dead_code)]
fn assert_generic_owner_send<C, V, R, S>(owner: Owner<C, V, R, S>)
where
C: Ord + Clone + Send + Sync + 'static,
V: Clone + Send + Sync + 'static,
R: RuntimeLite,
S: Source<C> + Send + 'static,
S::Handle: Send + Sync + 'static,
{
fn needs_send<F: Send>(_: F) {}
needs_send(run(owner));
}
#[allow(dead_code)]
fn assert_rc_local_source_constructs<R: RuntimeLite>() {
use std::{cell::Cell, rc::Rc};
struct RcSource {
state: Rc<Cell<u32>>,
}
impl LocalSource<OsString> for RcSource {
type Handle = u32;
fn canonicalize_key(&self, key: &[OsString]) -> Result<Vec<OsString>, WatchError> {
Ok(key.to_vec())
}
fn arm(
&mut self,
key: &[OsString],
) -> impl Future<Output = Result<Armed<OsString, u32>, WatchError>> {
let state = Rc::clone(&self.state);
let canonical = key.to_vec();
async move {
let handle = state.get() + 1;
state.set(handle);
Ok(Armed::new(handle, canonical))
}
}
fn disarm(&mut self, _handle: u32) {}
fn next(&mut self) -> impl Future<Output = Option<SourceEvent<OsString, u32>>> {
let state = Rc::clone(&self.state);
async move {
let _ = state.get();
core::future::pending().await
}
}
fn root_key(&self, _handle: u32) -> Option<Vec<OsString>> {
None
}
}
let (_handle, _driver): (Tributaries<OsString, (), R, u32>, _) = Tributaries::parts_local(
RcSource {
state: Rc::new(Cell::new(0)),
},
TributariesOptions::new(),
);
}
#[cfg(all(feature = "fs", feature = "tokio"))]
#[cfg_attr(docsrs, doc(cfg(all(feature = "fs", feature = "tokio"))))]
pub type TokioTributaries =
Tributaries<OsString, (), agnostic_lite::tokio::TokioRuntime, RootHandle>;
#[cfg(all(feature = "fs", feature = "smol"))]
#[cfg_attr(docsrs, doc(cfg(all(feature = "fs", feature = "smol"))))]
pub type SmolTributaries = Tributaries<OsString, (), agnostic_lite::smol::SmolRuntime, RootHandle>;