1use std::collections::HashSet;
4use std::future::Future;
5use std::pin::Pin;
6use std::sync::{Arc, Mutex, Weak};
7
8use tokio::sync::{mpsc, oneshot, watch};
9
10use super::inner_net_status_client::InnerNetStatusClient;
11use super::network_status_snapshot::NetworkStatusSnapshot;
12use crate::common::CommonEngine;
13use crate::error::{ErrorKind, NetError};
14use crate::net_status::{MonitorState, NetworkSnapshot};
15
16#[derive(Clone)]
20pub struct NetworkStatusContext {
21 service: Weak<SharedNetworkService>,
22 facts: watch::Receiver<NetworkSnapshot>,
23 failure: watch::Receiver<Option<NetError>>,
24 gate: watch::Receiver<NetworkStatusSnapshot>,
25}
26impl std::fmt::Debug for NetworkStatusContext {
27 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28 f.debug_struct("NetworkStatusContext")
29 .finish_non_exhaustive()
30 }
31}
32impl NetworkStatusContext {
33 pub(super) fn observation_source(
34 &self,
35 ) -> Result<super::network_status_snapshot::NetworkStatusSource, NetError> {
36 self.service
37 .upgrade()
38 .map(|service| service.inner.observation_source())
39 .ok_or_else(|| NetError::from(ErrorKind::Closed))
40 }
41 #[cfg(any(windows, test))]
42 pub(super) fn windows_sampler(&self) -> Result<Arc<super::refresh::WindowsSampler>, NetError> {
43 self.service
44 .upgrade()
45 .map(|service| service.inner.windows_sampler())
46 .ok_or_else(|| NetError::from(ErrorKind::Closed))
47 }
48 #[cfg(any(windows, test))]
49 pub(super) fn windows_reachability_sampler(
50 &self,
51 ) -> Result<Arc<super::refresh::WindowsSampler>, NetError> {
52 self.service
53 .upgrade()
54 .map(|service| service.inner.windows_reachability_sampler())
55 .ok_or_else(|| NetError::from(ErrorKind::Closed))
56 }
57 pub fn snapshot(&self) -> Result<NetworkSnapshot, NetError> {
59 if let Some(error) = ::tokio::sync::watch::Receiver::borrow(&self.failure).clone() {
60 return Err(error);
61 }
62 match self.service.upgrade() {
63 Some(service) => service.inner.snapshot(),
64 None => Ok(::tokio::sync::watch::Receiver::borrow(&self.facts).clone()),
65 }
66 }
67 pub(crate) fn common_engine(&self) -> Result<Arc<CommonEngine>, NetError> {
68 self.service
69 .upgrade()
70 .map(|service| service.engine.clone())
71 .ok_or_else(|| NetError::from(ErrorKind::Closed))
72 }
73 pub(crate) fn is_closed(&self) -> bool {
74 self.service.upgrade().map_or(true, |service| {
75 match service.admission.lock() {
76 Ok(state) => state.closed,
77 Err(_) => {
78 crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_service_state", "error", "admission_lock_poisoned");
79 true
80 }
81 }
82 })
83 }
84 pub(crate) fn acquire(&self) -> Result<NetworkLease, NetError> {
85 let service = self
86 .service
87 .upgrade()
88 .ok_or_else(|| NetError::from(ErrorKind::Closed))?;
89 service.inner.snapshot()?;
92 let id = {
93 let mut state = service.admission.lock().map_err(NetError::from_poison)?;
94 if state.closed {
95 return Err(NetError::from(ErrorKind::Closed));
96 }
97 let id = state
98 .next_id
99 .checked_add(1)
100 .ok_or_else(|| NetError::from(ErrorKind::Internal))?;
101 service
102 .commands
103 .send(Command::Acquire(id))
104 .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))?;
105 state.next_id = id;
106 state.active.insert(id);
107 id
108 };
109 Ok(NetworkLease {
110 inner: Arc::new(LeaseState {
111 id,
112 service: Arc::downgrade(&service),
113 released: Mutex::new(None),
114 closed: service.closed.clone(),
115 }),
116 })
117 }
118 pub(crate) fn subscribe_facts(&self) -> watch::Receiver<NetworkSnapshot> {
119 self.facts.clone()
120 }
121 pub(crate) fn subscribe_failure(&self) -> watch::Receiver<Option<NetError>> {
122 self.failure.clone()
123 }
124 pub(crate) fn subscribe_gate(&self) -> watch::Receiver<NetworkStatusSnapshot> {
125 self.gate.clone()
126 }
127}
128
129#[derive(Clone)]
130pub(crate) struct CleanupTicket {
131 finished: watch::Receiver<Option<Result<(), NetError>>>,
132}
133impl CleanupTicket {
134 fn pending() -> (watch::Sender<Option<Result<(), NetError>>>, Self) {
135 let (sender, finished) = watch::channel(None);
136 (sender, Self { finished })
137 }
138 pub(crate) fn is_finished(&self) -> bool {
139 matches!(
140 *::tokio::sync::watch::Receiver::borrow(&self.finished),
141 Some(Ok(()))
142 )
143 }
144 pub(crate) async fn wait(&self) -> Result<(), NetError> {
145 let mut finished = self.finished.clone();
146 loop {
147 if let Some(result) = finished.borrow_and_update().clone() {
148 return result;
149 }
150 finished
151 .changed()
152 .await
153 .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))?;
154 }
155 }
156}
157
158#[derive(Clone)]
159pub(crate) struct NetworkLease {
160 inner: Arc<LeaseState>,
161}
162struct LeaseState {
163 id: u64,
164 service: Weak<SharedNetworkService>,
165 released: Mutex<Option<CleanupTicket>>,
166 closed: CleanupTicket,
167}
168impl NetworkLease {
169 pub(crate) fn ensure_started(&self) -> Result<(), NetError> {
170 self.inner.ensure(None)
171 }
172 pub(crate) async fn wait_started(&self) -> Result<NetworkSnapshot, NetError> {
173 let (sender, received) = oneshot::channel();
174 self.inner.ensure(Some(sender))?;
175 received
176 .await
177 .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))?
178 }
179 pub(crate) fn release(&self) -> CleanupTicket {
180 self.inner.release()
181 }
182}
183
184impl LeaseState {
185 fn ensure(
186 &self,
187 waiter: Option<oneshot::Sender<Result<NetworkSnapshot, NetError>>>,
188 ) -> Result<(), NetError> {
189 let released = self.released.lock().map_err(NetError::from_poison)?;
190 if released.is_some() {
191 return Err(NetError::from(ErrorKind::Closed));
192 }
193 let service = self
194 .service
195 .upgrade()
196 .ok_or_else(|| NetError::from(ErrorKind::Closed))?;
197 let state = service.admission.lock().map_err(NetError::from_poison)?;
198 if state.closed || !state.active.contains(&self.id) {
199 return Err(NetError::from(ErrorKind::Closed));
200 }
201 service
202 .commands
203 .send(Command::Ensure(self.id, waiter))
204 .map_err(|_| NetError::from(ErrorKind::RuntimeUnavailable))
205 }
206 fn release(&self) -> CleanupTicket {
207 let mut released = match self.released.lock() {
208 Ok(state) => state,
209 Err(poisoned) => {
210 crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_lease_release", "error", "poisoned_lease_recovered");
211 poisoned.into_inner()
212 }
213 };
214 if let Some(ticket) = released.as_ref() {
215 return ticket.clone();
216 }
217 let ticket = match self.service.upgrade() {
218 Some(service) => {
219 let mut admission = match service.admission.lock() {
220 Ok(state) => state,
221 Err(poisoned) => {
222 crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_lease_release", "error", "admission_lock_poisoned_recovered");
223 poisoned.into_inner()
224 }
225 };
226 admission.active.remove(&self.id);
227 if admission.closed {
228 service.closed.clone()
229 } else {
230 let (sender, ticket) = CleanupTicket::pending();
231 if let Err(error) = service.commands.send(Command::Release(self.id, sender)) {
232 if let Command::Release(_, sender) = error.0 {
233 Completion::new(sender, &service.engine)
234 .finish(Err(NetError::from(ErrorKind::RuntimeUnavailable)));
235 }
236 }
237 ticket
238 }
239 }
240 None => self.closed.clone(),
241 };
242 *released = Some(ticket.clone());
243 ticket
244 }
245}
246impl Drop for LeaseState {
247 fn drop(&mut self) {
248 self.release();
249 }
250}
251
252struct Admission {
253 closed: bool,
254 next_id: u64,
255 active: HashSet<u64>,
256}
257pub(crate) struct SharedNetworkService {
258 engine: Arc<CommonEngine>,
259 inner: Arc<InnerNetStatusClient>,
260 admission: Mutex<Admission>,
261 commands: mpsc::UnboundedSender<Command>,
262 closed: CleanupTicket,
263}
264enum Command {
265 Acquire(u64),
266 Ensure(
267 u64,
268 Option<oneshot::Sender<Result<NetworkSnapshot, NetError>>>,
269 ),
270 Release(u64, watch::Sender<Option<Result<(), NetError>>>),
271 Close,
272}
273impl SharedNetworkService {
274 pub(crate) fn new(engine: Arc<CommonEngine>) -> Result<Arc<Self>, NetError> {
275 let inner = Arc::new(InnerNetStatusClient::new(engine.clone())?);
276 let (commands, receiver) = mpsc::unbounded_channel();
277 let (closed_sender, closed) = CleanupTicket::pending();
278 engine.runtime_handle().spawn(coordinate(
279 inner.clone(),
280 engine.clone(),
281 receiver,
282 closed_sender,
283 ));
284 Ok(Arc::new(Self {
285 engine,
286 inner,
287 commands,
288 admission: Mutex::new(Admission {
289 closed: false,
290 next_id: 0,
291 active: HashSet::new(),
292 }),
293 closed,
294 }))
295 }
296 pub(crate) fn context(self: &Arc<Self>) -> NetworkStatusContext {
297 NetworkStatusContext {
298 service: Arc::downgrade(self),
299 facts: self.inner.subscribe_facts(),
300 failure: self.inner.subscribe_failure(),
301 gate: self.inner.subscribe(),
302 }
303 }
304 pub(crate) fn request_close(&self) {
305 let newly_closed = {
306 let mut state = match self.admission.lock() {
307 Ok(state) => state,
308 Err(poisoned) => {
309 crate::log_e!(crate::common::log::log_def::LogType::Engine; "network_service_close", "error", "admission_lock_poisoned_recovered");
310 poisoned.into_inner()
311 }
312 };
313 if state.closed {
314 false
315 } else {
316 state.closed = true;
317 state.active.clear();
318 true
319 }
320 };
321 if newly_closed {
322 self.inner.request_destroy();
325 let _ = self.commands.send(Command::Close);
326 }
327 }
328 #[cfg(test)]
329 pub(crate) fn inner_for_test(&self) -> Arc<InnerNetStatusClient> {
330 self.inner.clone()
331 }
332 #[cfg(test)]
333 pub(crate) fn active_consumers_for_test(&self) -> Result<usize, NetError> {
334 Ok(self
335 .admission
336 .lock()
337 .map_err(NetError::from_poison)?
338 .active
339 .len())
340 }
341 pub(crate) async fn shutdown(&self) -> Result<(), NetError> {
342 self.request_close();
343 self.closed.wait().await
344 }
345}
346
347impl Drop for SharedNetworkService {
348 fn drop(&mut self) {
349 self.request_close();
350 }
351}
352
353type StartFuture = Pin<Box<dyn Future<Output = Result<NetworkSnapshot, NetError>> + Send>>;
354struct Completion {
357 sender: Option<watch::Sender<Option<Result<(), NetError>>>>,
358 engine: Arc<CommonEngine>,
359}
360impl Completion {
361 fn new(
362 sender: watch::Sender<Option<Result<(), NetError>>>,
363 engine: &Arc<CommonEngine>,
364 ) -> Self {
365 Self {
366 sender: Some(sender),
367 engine: engine.clone(),
368 }
369 }
370 fn finish(mut self, result: Result<(), NetError>) {
371 if let Some(sender) = self.sender.take() {
372 let engine = self.engine.clone();
373 self.engine.runtime_handle().spawn_blocking(move || {
374 let _runtime_owner = engine;
376 sender.send_replace(Some(result));
377 });
378 }
379 }
380}
381impl Drop for Completion {
382 fn drop(&mut self) {
383 if let Some(sender) = self.sender.take() {
384 let engine = self.engine.clone();
385 self.engine.runtime_handle().spawn_blocking(move || {
386 let _runtime_owner = engine;
387 sender.send_replace(Some(Err(NetError::from(ErrorKind::RuntimeUnavailable))));
388 });
389 }
390 }
391}
392fn notify_waiters(
393 engine: &Arc<CommonEngine>,
394 waiters: Vec<oneshot::Sender<Result<NetworkSnapshot, NetError>>>,
395 result: Result<NetworkSnapshot, NetError>,
396) {
397 for waiter in waiters {
398 let retained_engine = engine.clone();
399 let result = result.clone();
400 engine.runtime_handle().spawn_blocking(move || {
401 let _runtime_owner = retained_engine;
402 let _ = waiter.send(result);
404 });
405 }
406}
407
408fn retire(
409 inner: &InnerNetStatusClient,
410 engine: &Arc<CommonEngine>,
411 permanent: bool,
412 sender: watch::Sender<Option<Result<(), NetError>>>,
413) {
414 let (finished, error) = inner.request_stop(permanent);
415 let completion = Completion::new(sender, engine);
416 engine.runtime_handle().spawn(async move {
417 let result = InnerNetStatusClient::wait_until_finished(finished).await;
418 completion.finish(result.and_then(|()| error.map_or(Ok(()), Err)));
419 });
420}
421async fn coordinate(
422 inner: Arc<InnerNetStatusClient>,
423 engine: Arc<CommonEngine>,
424 mut commands: mpsc::UnboundedReceiver<Command>,
425 closed: watch::Sender<Option<Result<(), NetError>>>,
426) {
427 let closed = Completion::new(closed, &engine);
428 let mut active = HashSet::new();
429 let mut start: Option<StartFuture> = None;
430 let mut waiters = Vec::<oneshot::Sender<Result<NetworkSnapshot, NetError>>>::new();
431 let mut retry_waiters = Vec::new();
432 let mut retry_requested = false;
433 let mut start_revision = 0;
434 loop {
435 tokio::select! {
436 biased;
437 command = commands.recv() => {
438 match command {
439 Some(Command::Acquire(id)) => { active.insert(id); }
440 Some(Command::Ensure(id, waiter)) if active.contains(&id) => {
441 let snapshot = inner.snapshot();
442 let failed_during_start = start.is_some() && snapshot.as_ref().is_ok_and(|snapshot| {
443 snapshot.revision > start_revision && matches!(snapshot.state, MonitorState::Failed(_))
444 });
445 if failed_during_start {
446 retry_requested = true;
447 if let Some(waiter) = waiter { retry_waiters.push(waiter); }
448 } else {
449 if let Some(waiter) = waiter { waiters.push(waiter); }
450 if start.is_none() {
451 start_revision = snapshot.as_ref().map_or(0, |snapshot| snapshot.revision);
452 let inner = inner.clone();
453 start = Some(Box::pin(async move { inner.start().await }));
454 }
455 }
456 }
457 Some(Command::Ensure(_, waiter)) => {
458 if let Some(waiter) = waiter { notify_waiters(&engine, vec![waiter], Err(NetError::from(ErrorKind::Closed))); }
459 }
460 Some(Command::Release(id, sender)) => {
461 active.remove(&id);
462 if active.is_empty() {
463 drop(start.take());
464 retry_requested = false;
465 waiters.append(&mut retry_waiters);
466 retire(&inner, &engine, false, sender);
467 let result = inner.snapshot();
468 notify_waiters(&engine, std::mem::take(&mut waiters), result);
469 } else {
470 Completion::new(sender, &engine).finish(Ok(()));
471 }
472 }
473 Some(Command::Close) | None => {
474 drop(start.take());
475 waiters.append(&mut retry_waiters);
476 notify_waiters(&engine, std::mem::take(&mut waiters), Err(NetError::from(ErrorKind::Closed)));
477 let (finished, error) = inner.request_stop(true);
478 let result = InnerNetStatusClient::wait_until_finished(finished).await;
481 closed.finish(result.and_then(|()| error.map_or(Ok(()), Err)));
482 return;
483 }
484 }
485 }
486 result = async {
487 match start.as_mut() {
488 Some(start) => start.await,
489 None => std::future::pending().await,
490 }
491 } => {
492 start = None;
493 notify_waiters(&engine, std::mem::take(&mut waiters), result);
494 if retry_requested && !active.is_empty() {
495 retry_requested = false;
496 waiters = std::mem::take(&mut retry_waiters);
497 start_revision = inner.snapshot().map_or(0, |snapshot| snapshot.revision);
498 let inner = inner.clone();
499 start = Some(Box::pin(async move { inner.start().await }));
500 }
501 }
502 }
503 }
504}
505
506#[cfg(test)]
507mod tests {
508 use super::*;
509 type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;
510 fn check(condition: bool, message: &str) -> TestResult {
511 if condition {
512 Ok(())
513 } else {
514 Err(std::io::Error::other(message).into())
515 }
516 }
517 fn service() -> Result<Arc<SharedNetworkService>, NetError> {
518 SharedNetworkService::new(Arc::new(CommonEngine::new(16, 16)?))
519 }
520 struct BlockingWake {
521 entered: Mutex<Option<oneshot::Sender<()>>>,
522 release: Mutex<std::sync::mpsc::Receiver<()>>,
523 }
524 impl std::task::Wake for BlockingWake {
525 fn wake(self: Arc<Self>) {
526 if let Ok(mut entered) = self.entered.lock() {
527 if let Some(entered) = entered.take() {
528 let _ = entered.send(());
529 }
530 }
531 if let Ok(release) = self.release.lock() {
532 let _ = release.recv_timeout(std::time::Duration::from_secs(5));
533 }
534 }
535 }
536 #[tokio::test]
537 async fn accepted_waiters_are_not_blocked_by_another_callers_waker() -> TestResult {
538 let engine = Arc::new(CommonEngine::new(16, 16)?);
539 let (entered, entered_wait) = oneshot::channel();
540 let (release, released) = std::sync::mpsc::channel();
541 let waker = std::task::Waker::from(Arc::new(BlockingWake {
542 entered: Mutex::new(Some(entered)),
543 release: Mutex::new(released),
544 }));
545 let (first_sender, mut first) = oneshot::channel();
546 let (second_sender, second) = oneshot::channel();
547 let first_pending = Pin::new(&mut first)
548 .poll(&mut std::task::Context::from_waker(&waker))
549 .is_pending();
550 check(first_pending, "first waiter was already complete")?;
551 notify_waiters(
552 &engine,
553 vec![first_sender, second_sender],
554 Err(NetError::from(ErrorKind::Closed)),
555 );
556 tokio::time::timeout(std::time::Duration::from_secs(5), entered_wait).await??;
557 let second_result = tokio::time::timeout(std::time::Duration::from_secs(2), second).await;
558 let _ = release.send(());
559 check(
560 second_result??.is_err(),
561 "second caller did not receive terminal result",
562 )?;
563 check(
564 first.await?.is_err(),
565 "first caller did not receive terminal result",
566 )?;
567 Ok(())
568 }
569
570 #[tokio::test]
571 async fn accepted_cleanup_notification_keeps_runtime_until_delivery() -> TestResult {
572 let engine = Arc::new(CommonEngine::new(16, 16)?);
573 let (sender, ticket) = CleanupTicket::pending();
574 let completion = Completion::new(sender, &engine);
575 let runtime_owner = Arc::downgrade(&engine);
576 drop(engine);
577 check(
578 runtime_owner.upgrade().is_some(),
579 "accepted cleanup lost its runtime owner",
580 )?;
581 completion.finish(Ok(()));
582 tokio::time::timeout(std::time::Duration::from_secs(5), ticket.wait()).await??;
583 Ok(())
584 }
585
586 #[tokio::test]
587 async fn snapshots_are_inert_and_leases_are_logical_and_idempotent() -> TestResult {
588 let service = service()?;
589 let context = service.context();
590 check(
591 matches!(context.snapshot()?.state, MonitorState::Stopped),
592 "new source is not stopped",
593 )?;
594 let lease = context.acquire()?;
595 let clone = lease.clone();
596 check(
597 service
598 .admission
599 .lock()
600 .map_err(NetError::from_poison)?
601 .active
602 .len()
603 == 1,
604 "clone added demand",
605 )?;
606 lease.release().wait().await?;
607 clone.release().wait().await?;
608 check(
609 service
610 .admission
611 .lock()
612 .map_err(NetError::from_poison)?
613 .active
614 .is_empty(),
615 "released demand leaked",
616 )?;
617 check(
618 matches!(context.snapshot()?.state, MonitorState::Stopped),
619 "acquisition started monitoring",
620 )?;
621 service.shutdown().await?;
622 Ok(())
623 }
624 #[tokio::test]
625 async fn closed_context_rejects_new_leases_and_preserves_terminal_cache() -> TestResult {
626 let service = service()?;
627 let context = service.context();
628 service.request_close();
629 check(context.acquire().is_err(), "closed context admitted demand")?;
630 check(
631 matches!(context.snapshot()?.state, MonitorState::Closed),
632 "close was not synchronous",
633 )?;
634 service.shutdown().await?;
635 drop(service);
636 check(
637 matches!(context.snapshot()?.state, MonitorState::Closed),
638 "terminal cache was lost",
639 )?;
640 Ok(())
641 }
642 fn gated_service() -> Result<
643 (
644 Arc<SharedNetworkService>,
645 mpsc::UnboundedReceiver<oneshot::Sender<()>>,
646 Arc<std::sync::atomic::AtomicUsize>,
647 ),
648 NetError,
649 > {
650 let service = service()?;
651 let (attempts, receiver) = mpsc::unbounded_channel();
652 let calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
653 let factory_calls = calls.clone();
654 service
655 .inner
656 .set_monitor_factory_for_test(Arc::new(move || {
657 factory_calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
658 let (release, ready) = oneshot::channel();
659 let _ = attempts.send(release);
660 Box::pin(async move {
661 let _ = ready.await;
662 Err(NetError::from(ErrorKind::Io))
663 })
664 }))?;
665 Ok((service, receiver, calls))
666 }
667 async fn attempt(
668 receiver: &mut mpsc::UnboundedReceiver<oneshot::Sender<()>>,
669 ) -> Result<oneshot::Sender<()>, Box<dyn std::error::Error + Send + Sync>> {
670 Ok(
671 tokio::time::timeout(std::time::Duration::from_secs(5), receiver.recv())
672 .await?
673 .ok_or("factory missing")?,
674 )
675 }
676 #[tokio::test]
677 async fn concurrent_demand_shares_pending_initialization_and_nonlast_release_is_isolated(
678 ) -> TestResult {
679 let (service, mut attempts, calls) = gated_service()?;
680 let a = service.context().acquire()?;
681 let b = service.context().acquire()?;
682 a.ensure_started()?;
683 b.ensure_started()?;
684 let release = attempt(&mut attempts).await?;
685 a.release().wait().await?;
686 check(
687 calls.load(std::sync::atomic::Ordering::SeqCst) == 1,
688 "concurrent demand duplicated provider",
689 )?;
690 check(
691 !release.is_closed(),
692 "nonlast release cancelled shared startup",
693 )?;
694 let mut waiting = Box::pin(b.wait_started());
695 check(
696 futures::poll!(&mut waiting).is_pending(),
697 "start waiter unexpectedly completed",
698 )?;
699 let _ = release.send(());
700 let result = tokio::time::timeout(std::time::Duration::from_secs(5), waiting).await?;
701 check(
702 matches!(result, Err(error) if error.kind() == ErrorKind::Io),
703 "shared startup error lost",
704 )?;
705 service.shutdown().await?;
706 Ok(())
707 }
708 #[tokio::test]
709 async fn failed_generation_can_retry_with_existing_lease_and_live_fact_stream() -> TestResult {
710 let (service, mut attempts, calls) = gated_service()?;
711 let context = service.context();
712 let lease = context.acquire()?;
713 let mut facts = context.subscribe_facts();
714 let first = lease.clone();
715 let waiting = tokio::spawn(async move { first.wait_started().await });
716 let _ = attempt(&mut attempts).await?.send(());
717 check(waiting.await?.is_err(), "failure was hidden")?;
718 check(
719 matches!(context.snapshot()?.state, MonitorState::Failed(_)),
720 "failure snapshot absent",
721 )?;
722 lease.ensure_started()?;
723 let second = attempt(&mut attempts).await?;
724 check(
725 calls.load(std::sync::atomic::Ordering::SeqCst) == 2,
726 "existing demand could not retry",
727 )?;
728 check(
729 facts.changed().await.is_ok(),
730 "recoverable failure closed stream",
731 )?;
732 lease.release().wait().await?;
733 check(second.is_closed(), "last release did not cancel retry")?;
734 service.shutdown().await?;
735 Ok(())
736 }
737 #[tokio::test]
738 async fn close_during_pending_start_finishes_waiters_and_prevents_revival() -> TestResult {
739 let (service, mut attempts, _) = gated_service()?;
740 let context = service.context();
741 let lease = context.acquire()?;
742 let waiter = lease.clone();
743 let waiting = tokio::spawn(async move { waiter.wait_started().await });
744 let _attempt = attempt(&mut attempts).await?;
745 service.request_close();
746 check(
747 matches!(context.snapshot()?.state, MonitorState::Closed),
748 "close did not publish terminal",
749 )?;
750 check(
751 matches!(waiting.await?, Err(error) if error.kind() == ErrorKind::Closed),
752 "pending start survived close",
753 )?;
754 lease.release().wait().await?;
755 check(context.acquire().is_err(), "closed service revived")?;
756 service.shutdown().await?;
757 Ok(())
758 }
759 #[tokio::test]
760 async fn service_drop_does_not_require_external_context_or_lease_drop() -> TestResult {
761 let (service, mut attempts, _) = gated_service()?;
762 let context = service.context();
763 let lease = context.acquire()?;
764 lease.ensure_started()?;
765 let _attempt = attempt(&mut attempts).await?;
766 drop(service);
767 check(
768 matches!(context.snapshot()?.state, MonitorState::Closed),
769 "external context kept engine alive",
770 )?;
771 lease.release().wait().await?;
772 check(
773 lease.ensure_started().is_err(),
774 "released context restarted engine",
775 )?;
776 Ok(())
777 }
778}
779
780#[cfg(test)]
781#[path = "shared_regression_tests.rs"]
782mod regression_tests;