Struct ServiceWatcher 

pub struct ServiceWatcher<S: ServiceMarker>(/* private fields */);

Per-Kernel manager that watches /svc/<S::SERVICE_NAME> at most once and fans out discovered ServiceMarker::Proxy instances to registered Starnix drivers.

Active instances are retained so drivers registered after initial discovery still receive previously discovered live instances, and each bound instance can register devices and disconnect hooks on a ServiceBindingScope that are automatically torn down when a monitored channel closes or when the service instance directory entry is removed or replaced.

Implementations

impl<S: ServiceMarker<Proxy: Send + Sync + 'static>> ServiceWatcher<S>

pub fn register<Bind>(kernel: &Kernel, marker: S, bind: Bind)

where Bind: FnMut(&CurrentTask, Arc<S::Proxy>, &mut ServiceBindingScope) + Send + 'static,

Registers a driver that binds each discovered service instance on the kernel’s main async executor.

pub fn register_singleton<Bind>(kernel: &Kernel, marker: S, bind: Bind)

where Bind: FnMut(&CurrentTask, Arc<S::Proxy>, &mut ServiceBindingScope) + Send + 'static,

Registers a singleton driver that binds at most one service instance at a time on the kernel’s main async executor, ignoring additional instances while bound and promoting a remaining active instance if the bound instance disconnects.

pub fn register_with_probe<P, Probe, ProbeFut, Bind>( kernel: &Kernel, marker: S, probe: Probe, bind: Bind, )

where P: Send + 'static, Probe: Fn(Arc<S::Proxy>) -> ProbeFut + Send + Sync + 'static, ProbeFut: Future<Output = Option<P>> + Send + 'static, Bind: FnMut(&CurrentTask, P, &mut ServiceBindingScope) + Send + 'static,

Registers a driver that probes each discovered service instance asynchronously (without holding kernel locks) and, when probe returns Some(probed), invokes bind on the kernel’s main async executor with KernelThreads::system_task and a ServiceBindingScope.

probe futures may run concurrently across instances, whereas bind and teardown invocations are serialized per driver after synchronously tearing down any stale bindings. Any active service instances discovered before this call are replayed to the driver on the kernel’s main async executor.

Trait Implementations

impl<S: Debug + ServiceMarker> Debug for ServiceWatcher<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.