use std::collections::HashMap;
use std::sync::Arc;
use std::sync::Mutex as StdMutex;
use std::time::Duration;
use tokio::sync::Mutex as AsyncMutex;
use tokio::task::JoinHandle;
use tokio_util::sync::CancellationToken;
use tracing::{debug, error, info};
use crate::buffer_budget::{BufferBudget, BufferReservation};
use crate::resource_events::ResourceEventHub;
use crate::rx_ring::RxRing;
use crate::serial::SerialConnection;
pub struct RxSession {
connection_id: String,
connection: Arc<SerialConnection>,
pump_task: StdMutex<Option<JoinHandle<()>>>,
pump_token: StdMutex<CancellationToken>,
pump_gate: Arc<AsyncMutex<()>>,
ring: Arc<RxRing>,
hub: Arc<ResourceEventHub>,
read_cursor: StdMutex<u64>,
ring_capacity: usize,
budget_reservation: StdMutex<Option<Box<dyn BufferReservation>>>,
}
impl RxSession {
const PUMP_READ_SIZE: usize = 4096;
pub fn new(
connection: Arc<SerialConnection>,
ring_capacity: usize,
budget: &Arc<dyn BufferBudget>,
hub: Arc<ResourceEventHub>,
) -> Result<Self, String> {
if ring_capacity == 0 {
return Err(format!(
"open.rx_buffer_size: ring_capacity must be > 0, got {ring_capacity}"
));
}
let reservation = budget
.try_reserve(ring_capacity)
.map_err(|e| crate::tools::helpers::map_budget_err("open.rx_buffer_size", e))?;
let connection_id = connection.id().to_string();
Ok(Self {
connection_id,
connection,
pump_task: StdMutex::new(None),
pump_token: StdMutex::new(CancellationToken::new()),
pump_gate: Arc::new(AsyncMutex::new(())),
ring: Arc::new(RxRing::new(ring_capacity)),
hub,
read_cursor: StdMutex::new(0),
ring_capacity,
budget_reservation: StdMutex::new(Some(reservation)),
})
}
pub fn connection_id(&self) -> &str {
&self.connection_id
}
pub(crate) fn ring(&self) -> &RxRing {
&self.ring
}
pub(crate) fn read_cursor(&self) -> u64 {
*self.read_cursor.lock().expect("read_cursor mutex poisoned")
}
pub(crate) fn set_read_cursor(&self, off: u64) {
*self.read_cursor.lock().expect("read_cursor mutex poisoned") = off;
}
pub(crate) fn ring_capacity(&self) -> usize {
self.ring_capacity
}
pub(crate) async fn pump_gate_guard(&self) -> tokio::sync::MutexGuard<'_, ()> {
self.pump_gate.lock().await
}
pub(crate) fn ensure_pump_running(&self) {
let mut task_slot = self.pump_task.lock().expect("pump_task mutex poisoned");
if let Some(handle) = task_slot.take() {
if handle.is_finished() {
debug!(
"rx_session: previous pump for {} finished, restarting",
self.connection_id
);
} else {
*task_slot = Some(handle);
return;
}
}
{
let mut token = self.pump_token.lock().expect("pump_token mutex poisoned");
if token.is_cancelled() {
*token = CancellationToken::new();
}
}
let connection = Arc::clone(&self.connection);
let token = self
.pump_token
.lock()
.expect("pump_token mutex poisoned")
.clone();
let ring = Arc::clone(&self.ring);
let pump_gate = Arc::clone(&self.pump_gate);
let hub = Arc::clone(&self.hub);
let handle = tokio::spawn(pump_loop(connection, token, ring, pump_gate, hub));
*task_slot = Some(handle);
debug!("rx_session: pump started for {}", self.connection_id);
}
pub fn shutdown(&self) {
self.pump_token
.lock()
.expect("pump_token mutex poisoned")
.cancel();
info!("rx_session: shut down for {}", self.connection_id);
}
pub async fn join_pump(&self) {
let handle = self
.pump_task
.lock()
.expect("pump_task mutex poisoned")
.take();
if let Some(h) = handle {
let _ = h.await;
}
}
pub async fn shutdown_and_join(&self) {
self.shutdown();
self.join_pump().await;
let reservation = self
.budget_reservation
.lock()
.expect("budget_reservation mutex poisoned")
.take();
drop(reservation);
debug!(
"rx_session: budget released for {} ({} bytes)",
self.connection_id, self.ring_capacity
);
}
}
async fn pump_loop(
connection: Arc<SerialConnection>,
token: CancellationToken,
ring: Arc<RxRing>,
pump_gate: Arc<AsyncMutex<()>>,
hub: Arc<ResourceEventHub>,
) {
let conn_id = connection.id().to_string();
let mut buf = vec![0u8; RxSession::PUMP_READ_SIZE];
info!("rx_session: pump entered for {conn_id}");
loop {
if token.is_cancelled() {
break;
}
let gate = pump_gate.lock().await;
let read_result = tokio::select! {
_ = token.cancelled() => break,
res = connection.read(&mut buf, Some(100)) => res,
};
match read_result {
Ok(0) | Err(crate::error::SerialError::ReadTimeout) => {
drop(gate);
continue;
}
Ok(n) => {
connection.log().rx_data(n);
let chunk = buf[..n].to_vec();
ring.append(&chunk);
drop(gate);
hub.publish_connection_changed(&conn_id);
}
Err(e) => {
error!("rx_session: read error on {conn_id}: {e}");
let is_fatal = if let crate::error::SerialError::IoError(ref io_err) = e {
crate::serial::is_fatal_disconnect(io_err)
} else {
false
};
if is_fatal {
connection
.mark_disconnected(format!("Read error: {e}"))
.await;
drop(gate);
let pause_start = std::time::Instant::now();
debug!("rx_session: pump for {conn_id} pausing (disconnected)");
loop {
if token.is_cancelled() {
info!(
"rx_session: pump for {conn_id} exiting during pause (cancelled)"
);
return;
}
let state = connection.state();
match state {
crate::serial::ConnectionState::Open => {
info!(
"rx_session: pump for {conn_id} resumed after {:.0?}",
pause_start.elapsed()
);
break; }
crate::serial::ConnectionState::Closed => {
info!(
"rx_session: pump for {conn_id} exiting (connection closed during pause)"
);
return;
}
_ => {
tokio::time::sleep(Duration::from_millis(50)).await;
}
}
}
continue;
}
error!("rx_session: non-fatal read error on {conn_id}, pump exiting: {e}");
break;
}
}
}
info!("rx_session: pump exiting for {conn_id}");
}
pub struct RxSessionManager {
sessions: AsyncMutex<HashMap<String, Arc<RxSession>>>,
budget: Arc<dyn BufferBudget>,
hub: Arc<ResourceEventHub>,
}
impl RxSessionManager {
pub fn new(budget: Arc<dyn BufferBudget>, hub: Arc<ResourceEventHub>) -> Self {
Self {
sessions: AsyncMutex::new(HashMap::new()),
budget,
hub,
}
}
pub async fn get_or_create(
&self,
connection: Arc<SerialConnection>,
ring_capacity: usize,
) -> Result<Arc<RxSession>, String> {
let conn_id = connection.id().to_string();
let mut sessions = self.sessions.lock().await;
if let Some(existing) = sessions.get(&conn_id) {
return Ok(Arc::clone(existing));
}
let session = Arc::new(RxSession::new(
connection,
ring_capacity,
&self.budget,
Arc::clone(&self.hub),
)?);
session.ensure_pump_running();
sessions.insert(conn_id, Arc::clone(&session));
debug!(
"rx_session: created new session for connection {}",
session.connection_id()
);
Ok(session)
}
pub async fn remove(&self, connection_id: &str) {
let session = {
let mut sessions = self.sessions.lock().await;
sessions.remove(connection_id)
};
if let Some(session) = session {
session.shutdown_and_join().await;
info!("rx_session: removed session for connection {connection_id}");
}
}
pub async fn count(&self) -> usize {
self.sessions.lock().await.len()
}
pub async fn get(&self, connection_id: &str) -> Option<Arc<RxSession>> {
self.sessions.lock().await.get(connection_id).cloned()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::buffer_budget::AtomicBudget;
use crate::serial::test_support::loopback_connection;
use crate::serial::{FlowControl, FlushTarget, SerialIo};
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, Ordering};
use std::task::{Context, Poll};
use std::time::Duration;
use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, ReadBuf};
use tokio::sync::Notify;
fn test_budget() -> Arc<dyn BufferBudget> {
Arc::new(AtomicBudget::new(1024 * 1024 * 1024, 1024 * 1024 * 1024))
}
fn test_hub() -> Arc<ResourceEventHub> {
Arc::new(ResourceEventHub::new(64))
}
fn test_session(conn: Arc<SerialConnection>) -> RxSession {
let budget = test_budget();
RxSession::new(conn, 1024, &budget, test_hub()).expect("test session creation")
}
fn test_manager() -> RxSessionManager {
RxSessionManager::new(test_budget(), test_hub())
}
#[tokio::test]
async fn manager_get_or_create_returns_same_session() {
let (conn, _peer) = loopback_connection("test-idem");
let conn = Arc::new(conn);
let mgr = test_manager();
let s1 = mgr.get_or_create(Arc::clone(&conn), 1024).await.unwrap();
let s2 = mgr.get_or_create(Arc::clone(&conn), 2048).await.unwrap();
assert!(Arc::ptr_eq(&s1, &s2));
assert_eq!(mgr.count().await, 1);
}
#[tokio::test]
async fn manager_remove_awaits_pump_exit() {
let (conn, _peer) = loopback_connection("test-remove-await");
let conn = Arc::new(conn);
let mgr = test_manager();
let session = mgr.get_or_create(Arc::clone(&conn), 1024).await.unwrap();
let id = session.connection_id().to_string();
assert!(!session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
mgr.remove(&id).await;
assert_eq!(mgr.count().await, 0);
assert!(session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
assert!(
session.pump_task.lock().expect("pump_task").is_none(),
"pump task handle should be consumed after join"
);
}
#[tokio::test]
async fn manager_remove_nonexistent_is_noop() {
let mgr = test_manager();
mgr.remove("does-not-exist").await;
assert_eq!(mgr.count().await, 0);
}
#[tokio::test]
async fn get_or_create_starts_pump() {
let (conn, _peer) = loopback_connection("test-pump-start");
let conn = Arc::new(conn);
let mgr = test_manager();
let session = mgr.get_or_create(Arc::clone(&conn), 1024).await.unwrap();
assert!(session.pump_task.lock().expect("pump_task").is_some());
}
#[tokio::test]
async fn session_shutdown_cancels_pump_token() {
let (conn, _peer) = loopback_connection("test-shutdown");
let conn = Arc::new(conn);
let session = test_session(conn);
session.ensure_pump_running();
assert!(!session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
session.shutdown();
assert!(session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
}
#[tokio::test]
async fn removing_session_awaits_pump_and_drops_consumers() {
let (conn, _peer) = loopback_connection("test-remove-lifecycle");
let conn = Arc::new(conn);
let mgr = test_manager();
let session = mgr.get_or_create(Arc::clone(&conn), 1024).await.unwrap();
let conn_id = session.connection_id().to_string();
assert!(!session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
mgr.remove(&conn_id).await;
assert!(session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
assert_eq!(mgr.count().await, 0);
assert!(
session.pump_task.lock().expect("pump_task").is_none(),
"pump handle should be consumed after remove"
);
}
#[tokio::test]
async fn connection_close_causes_pump_exit() {
let (conn, mut peer) = loopback_connection("test-close-exit");
let conn = Arc::new(conn);
let session = test_session(Arc::clone(&conn));
session.ensure_pump_running();
peer.write_all(b"bye").await.unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
conn.close().await.unwrap();
tokio::time::sleep(Duration::from_millis(300)).await;
assert!(
session.pump_task.lock().expect("pump_task").is_none()
|| session
.pump_task
.lock()
.expect("pump_task")
.as_ref()
.map(|h| h.is_finished())
.unwrap_or(true),
"pump should finish after connection close"
);
}
#[tokio::test]
async fn pump_exits_cleanly_on_shutdown_without_hanging() {
let (conn, _peer) = loopback_connection("test-pump-clean-exit");
let conn = Arc::new(conn);
let session = test_session(Arc::clone(&conn));
session.ensure_pump_running();
session.shutdown_and_join().await;
assert!(
session.pump_task.lock().expect("pump_task").is_none(),
"pump task handle should be consumed after join"
);
}
#[tokio::test]
async fn shutdown_is_idempotent() {
let (conn, _peer) = loopback_connection("test-shutdown-idem");
let conn = Arc::new(conn);
let session = test_session(conn);
session.ensure_pump_running();
session.shutdown();
session.shutdown();
session.shutdown();
assert!(session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
}
#[tokio::test]
async fn repeated_create_remove_no_leaked_pump_tasks() {
let iterations = 10;
for i in 0..iterations {
let port_name = format!("test-stress-{i}");
let (conn, _peer) = loopback_connection(&port_name);
let conn = Arc::new(conn);
let mgr = test_manager();
let session = mgr.get_or_create(Arc::clone(&conn), 1024).await.unwrap();
let conn_id = session.connection_id().to_string();
assert!(
session.pump_task.lock().expect("pump_task").is_some(),
"pump should be running on iteration {i}"
);
mgr.remove(&conn_id).await;
assert!(
session.pump_task.lock().expect("pump_task").is_none(),
"pump handle should be consumed after remove on iteration {i}"
);
assert!(
session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled(),
"pump token should be cancelled after remove on iteration {i}"
);
assert_eq!(mgr.count().await, 0);
}
}
#[tokio::test]
async fn ring_captures_bytes_without_consumers() {
let (conn, mut peer) = loopback_connection("test-ring-no-consumers");
let conn = Arc::new(conn);
let session = test_session(Arc::clone(&conn));
session.ensure_pump_running();
peer.write_all(b"hi").await.unwrap();
tokio::time::sleep(Duration::from_millis(200)).await;
let end = session.ring().end_offset();
assert_eq!(end, 2, "ring should have captured 2 bytes");
let slice = session.ring().read_from(0, 10);
assert_eq!(slice.bytes, b"hi");
assert_eq!(slice.bytes_lost, 0);
session.shutdown_and_join().await;
}
#[tokio::test]
async fn pump_keeps_running_when_no_consumers() {
let (conn, mut peer) = loopback_connection("test-pump-no-consumers");
let conn = Arc::new(conn);
let session = test_session(Arc::clone(&conn));
session.ensure_pump_running();
peer.write_all(b"before").await.unwrap();
tokio::time::sleep(Duration::from_millis(200)).await;
let end_before = session.ring().end_offset();
assert_eq!(end_before, 6, "ring should have 'before'");
peer.write_all(b"after").await.unwrap();
tokio::time::sleep(Duration::from_millis(200)).await;
let end_after = session.ring().end_offset();
assert_eq!(end_after, 11, "ring should have 'before'+'after'");
let slice = session.ring().read_from(0, 20);
assert_eq!(&slice.bytes[..6], b"before");
assert_eq!(&slice.bytes[6..], b"after");
session.shutdown_and_join().await;
}
#[tokio::test]
async fn budget_charged_at_open_released_at_close() {
let budget: Arc<dyn BufferBudget> = Arc::new(AtomicBudget::new(4096, 4096));
let avail_before = budget.available();
assert_eq!(avail_before, 4096);
let (conn, _peer) = loopback_connection("test-budget-lifecycle");
let conn = Arc::new(conn);
let session = RxSession::new(conn, 1024, &budget, test_hub()).expect("session create");
let avail_after_open = budget.available();
assert_eq!(avail_after_open, 4096 - 1024);
assert_eq!(session.ring_capacity(), 1024);
assert_eq!(session.read_cursor(), 0);
session.shutdown_and_join().await;
let avail_after_close = budget.available();
assert_eq!(avail_after_close, 4096);
}
#[tokio::test]
async fn budget_open_fails_if_insufficient() {
let budget: Arc<dyn BufferBudget> = Arc::new(AtomicBudget::new(1024, 1024));
let _hold = budget.try_reserve(900).expect("pre-reserve");
let result = RxSession::new(
Arc::new(loopback_connection("test-budget-fail").0),
200,
&budget,
test_hub(),
);
match result {
Err(e) => assert!(
e.contains("insufficient program buffer budget"),
"expected budget exhaustion error, got: {e}"
),
Ok(_) => panic!("expected error for insufficient budget"),
}
}
#[tokio::test]
async fn budget_open_fails_if_zero_capacity() {
let budget = test_budget();
let result = RxSession::new(
Arc::new(loopback_connection("test-zero-capacity").0),
0,
&budget,
test_hub(),
);
match result {
Err(e) => assert!(
e.contains("ring_capacity must be > 0"),
"expected zero capacity error, got: {e}"
),
Ok(_) => panic!("expected error for zero capacity"),
}
}
#[tokio::test]
async fn read_cursor_starts_at_zero() {
let (conn, _peer) = loopback_connection("test-cursor-zero");
let conn = Arc::new(conn);
let session = test_session(conn);
assert_eq!(session.read_cursor(), 0);
}
#[tokio::test]
async fn set_read_cursor_updates_value() {
let (conn, _peer) = loopback_connection("test-cursor-set");
let conn = Arc::new(conn);
let session = test_session(conn);
session.set_read_cursor(42);
assert_eq!(session.read_cursor(), 42);
session.set_read_cursor(0);
assert_eq!(session.read_cursor(), 0);
}
#[tokio::test]
async fn ensure_pump_running_is_idempotent() {
let (conn, _peer) = loopback_connection("test-pump-idem");
let conn = Arc::new(conn);
let session = test_session(Arc::clone(&conn));
assert!(session.pump_task.lock().expect("pump_task").is_none());
session.ensure_pump_running();
assert!(session.pump_task.lock().expect("pump_task").is_some());
session.ensure_pump_running();
assert!(session.pump_task.lock().expect("pump_task").is_some());
assert!(!session
.pump_token
.lock()
.expect("pump_token")
.is_cancelled());
session.shutdown_and_join().await;
}
#[tokio::test]
async fn ensure_pump_running_restarts_after_pump_finishes() {
let (conn, _peer) = loopback_connection("test-pump-restart");
let conn = Arc::new(conn);
let session = test_session(Arc::clone(&conn));
session.ensure_pump_running();
session.shutdown();
session.join_pump().await;
assert!(session.pump_task.lock().expect("pump_task").is_none());
session.ensure_pump_running();
assert!(session.pump_task.lock().expect("pump_task").is_some());
session.shutdown_and_join().await;
}
struct PumpGateState {
payload: StdMutex<Option<Vec<u8>>>,
released: AtomicBool,
waker: StdMutex<Option<std::task::Waker>>,
read_started: Notify,
consumed: Notify,
}
impl PumpGateState {
fn new(payload: &[u8]) -> Self {
Self {
payload: StdMutex::new(Some(payload.to_vec())),
released: AtomicBool::new(false),
waker: StdMutex::new(None),
read_started: Notify::new(),
consumed: Notify::new(),
}
}
fn release(&self) {
self.released.store(true, Ordering::SeqCst);
if let Some(w) = self.waker.lock().expect("waker poisoned").take() {
w.wake();
}
}
}
struct PumpGateIo {
state: Arc<PumpGateState>,
}
impl AsyncRead for PumpGateIo {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<std::io::Result<()>> {
*self.state.waker.lock().expect("waker poisoned") = Some(cx.waker().clone());
self.state.read_started.notify_one();
if !self.state.released.load(Ordering::SeqCst) {
return Poll::Pending;
}
let mut payload = self.state.payload.lock().expect("payload poisoned");
if let Some(bytes) = payload.take() {
let n = buf.initialize_unfilled().len().min(bytes.len());
let unfilled = buf.initialize_unfilled();
unfilled[..n].copy_from_slice(&bytes[..n]);
buf.advance(n);
self.state.consumed.notify_waiters();
Poll::Ready(Ok(()))
} else {
Poll::Pending
}
}
}
impl AsyncWrite for PumpGateIo {
fn poll_write(
self: Pin<&mut Self>,
_cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<std::io::Result<usize>> {
Poll::Ready(Ok(buf.len()))
}
fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Poll::Ready(Ok(()))
}
fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Poll::Ready(Ok(()))
}
}
impl SerialIo for PumpGateIo {
fn clear_os_buffers(&self, _target: FlushTarget) -> std::io::Result<()> {
Ok(())
}
fn set_dtr_rts(&mut self, _dtr: bool, _rts: bool) -> std::io::Result<()> {
Ok(())
}
fn set_flow_control(&mut self, _flow_control: FlowControl) -> std::io::Result<()> {
Ok(())
}
fn set_break_state(&self, _asserted: bool) -> std::io::Result<()> {
Ok(())
}
}
#[tokio::test]
async fn pump_holds_gate_across_inflight_read_and_ring_append() {
const PAYLOAD: &[u8] = b"INFLIGHT";
let state = Arc::new(PumpGateState::new(PAYLOAD));
let conn = Arc::new(SerialConnection::from_io(
"test-pump-gate".to_string(),
Box::new(PumpGateIo {
state: Arc::clone(&state),
}),
));
let session = test_session(Arc::clone(&conn));
let read_started = state.read_started.notified();
session.ensure_pump_running();
tokio::time::timeout(Duration::from_secs(5), read_started)
.await
.expect("pump read must start within the hang guard");
assert_eq!(
session.ring().end_offset(),
0,
"ring must be empty while the pump's read is in flight"
);
let mut gate_held = false;
for _ in 0..3 {
if session.pump_gate.try_lock().is_err() {
gate_held = true;
break;
}
tokio::task::yield_now().await;
}
assert!(
gate_held,
"pump must hold pump_gate while its read is in flight"
);
let consumed = state.consumed.notified();
state.release();
tokio::time::timeout(Duration::from_secs(5), consumed)
.await
.expect("pump must consume the released payload within the hang guard");
let guard = session.pump_gate_guard().await;
assert_eq!(
session.ring().end_offset(),
PAYLOAD.len() as u64,
"payload must be appended before the gate is released"
);
let slice = session.ring().read_from(0, PAYLOAD.len());
assert_eq!(slice.bytes, PAYLOAD);
assert_eq!(slice.bytes_lost, 0);
assert_eq!(slice.from_offset, 0);
assert_eq!(slice.next_offset, PAYLOAD.len() as u64);
drop(guard);
session.shutdown_and_join().await;
}
#[tokio::test]
async fn pump_publishes_resource_hints_only_after_ring_append() {
const PAYLOAD: &[u8] = b"INFLIGHT";
let hub = Arc::new(crate::resource_events::ResourceEventHub::new(64));
let mut rx = hub.subscribe();
let state = Arc::new(PumpGateState::new(PAYLOAD));
let conn = Arc::new(SerialConnection::from_io(
"test-pump-publish".to_string(),
Box::new(PumpGateIo {
state: Arc::clone(&state),
}),
));
let conn_id = conn.id().to_string();
let budget = test_budget();
let session =
RxSession::new(Arc::clone(&conn), 1024, &budget, hub).expect("session creation");
let read_started = state.read_started.notified();
session.ensure_pump_running();
tokio::time::timeout(Duration::from_secs(5), read_started)
.await
.expect("pump read must start within the hang guard");
assert_eq!(
session.ring().end_offset(),
0,
"ring must be empty while the pump's read is in flight"
);
assert!(
matches!(
rx.try_recv(),
Err(tokio::sync::broadcast::error::TryRecvError::Empty)
),
"no resource hint may arrive before the ring append"
);
let consumed = state.consumed.notified();
state.release();
tokio::time::timeout(Duration::from_secs(5), consumed)
.await
.expect("pump must consume the released payload within the hang guard");
let event = tokio::time::timeout(Duration::from_secs(5), rx.recv())
.await
.expect("detail hint within the hang guard")
.expect("hub not closed");
assert_eq!(
event,
crate::resource_events::ResourceEvent::Updated(
crate::resource_events::detail_uri(&conn_id).expect("detail uri")
),
"first published hint must be the connection detail URI"
);
assert_eq!(
session.ring().end_offset(),
PAYLOAD.len() as u64,
"bytes must be appended before the hint is delivered"
);
let slice = session.ring().read_from(0, PAYLOAD.len());
assert_eq!(slice.bytes, PAYLOAD);
assert_eq!(slice.bytes_lost, 0);
let raw_event = tokio::time::timeout(Duration::from_secs(5), rx.recv())
.await
.expect("raw hint within the hang guard")
.expect("hub not closed");
assert_eq!(
raw_event,
crate::resource_events::ResourceEvent::Updated(
crate::resource_events::raw_uri(&conn_id).expect("raw uri")
)
);
let log_event = tokio::time::timeout(Duration::from_secs(5), rx.recv())
.await
.expect("log hint within the hang guard")
.expect("hub not closed");
assert_eq!(
log_event,
crate::resource_events::ResourceEvent::Updated(
crate::resource_events::log_uri(&conn_id).expect("log uri")
)
);
let gate_guard = tokio::time::timeout(Duration::from_secs(1), session.pump_gate_guard())
.await
.expect("pump gate must be acquirable after publication");
drop(gate_guard);
session.shutdown_and_join().await;
}
}