@@ -421,24 +421,39 @@ pub(crate) async fn run_demo_echo(
421421 tracing:: info!( %session_id, %peer, "mesh demo echo: session open" ) ;
422422 let mut drain_tick = tokio:: time:: interval ( std:: time:: Duration :: from_millis ( 100 ) ) ;
423423 loop {
424- let frame = tokio:: select! {
425- _ = drain_tick. tick( ) => {
426- if shutting_down. load( Ordering :: Relaxed ) {
427- if let Some ( community_id) = stream. community_id( ) {
428- if let Err ( e) = stream. send_goodbye( community_id, GoodbyeReason :: Draining ) . await {
429- tracing:: warn!( %session_id, "mesh demo echo: draining goodbye failed: {e}" ) ;
430- } else {
431- tracing:: info!( %session_id, "mesh demo echo: sent draining goodbye" ) ;
424+ let frame = {
425+ // A receive can consume bytes before waiting on Redis validation.
426+ // Keep it alive across housekeeping ticks; only shutdown may cancel it.
427+ let recv = stream. recv_validated ( & directory) ;
428+ tokio:: pin!( recv) ;
429+ loop {
430+ tokio:: select! {
431+ _ = drain_tick. tick( ) => {
432+ if shutting_down. load( Ordering :: Relaxed ) {
433+ break None ;
432434 }
433- } else {
434- let _ = stream. finish( ) ;
435- tracing:: info!( %session_id, "mesh demo echo: drain before community latch — closing" ) ;
436435 }
437- return ;
436+ frame = & mut recv => break Some ( frame ) ,
438437 }
439- continue ;
440438 }
441- frame = stream. recv_validated( & directory) => frame,
439+ } ;
440+ // The pending receive and its mutable stream borrow have ended before
441+ // the drain response or next echo uses the stream.
442+ let Some ( frame) = frame else {
443+ if let Some ( community_id) = stream. community_id ( ) {
444+ if let Err ( e) = stream
445+ . send_goodbye ( community_id, GoodbyeReason :: Draining )
446+ . await
447+ {
448+ tracing:: warn!( %session_id, "mesh demo echo: draining goodbye failed: {e}" ) ;
449+ } else {
450+ tracing:: info!( %session_id, "mesh demo echo: sent draining goodbye" ) ;
451+ }
452+ } else {
453+ let _ = stream. finish ( ) ;
454+ tracing:: info!( %session_id, "mesh demo echo: drain before community latch — closing" ) ;
455+ }
456+ return ;
442457 } ;
443458 match frame {
444459 Ok ( Some ( ReliableFrame :: Data ( payload) ) ) => {
@@ -696,6 +711,72 @@ mod tests {
696711 MeshStream :: new ( Box :: new ( StubSend ) , Box :: new ( StubRecv ) )
697712 }
698713
714+ struct PausedRecv {
715+ started : Option < tokio:: sync:: oneshot:: Sender < ( ) > > ,
716+ resume : Option < tokio:: sync:: oneshot:: Receiver < ( ) > > ,
717+ calls : Arc < std:: sync:: atomic:: AtomicUsize > ,
718+ }
719+
720+ impl StreamRecvHalf for PausedRecv {
721+ fn recv_frame ( & mut self ) -> BoxFuture < ' _ , Result < Option < MeshStreamFrame > , MeshError > > {
722+ self . calls . fetch_add ( 1 , Ordering :: Relaxed ) ;
723+ let started = self . started . take ( ) ;
724+ let resume = self . resume . take ( ) ;
725+ Box :: pin ( async move {
726+ if let Some ( started) = started {
727+ let _ = started. send ( ( ) ) ;
728+ }
729+ if let Some ( resume) = resume {
730+ resume. await . expect ( "test resumes the in-flight receive" ) ;
731+ }
732+ Ok ( None )
733+ } )
734+ }
735+ }
736+
737+ /// Housekeeping must retain a receive that already consumed transport state.
738+ /// Returning to recv_frame after a tick loses that state and closes the stream.
739+ #[ tokio:: test( start_paused = true ) ]
740+ async fn demo_echo_retains_pending_receive_across_housekeeping_ticks ( ) {
741+ let pool = deadpool_redis:: Config :: from_url ( "redis://127.0.0.1:1" )
742+ . create_pool ( Some ( deadpool_redis:: Runtime :: Tokio1 ) )
743+ . expect ( "test pool" ) ;
744+ let ( started_tx, started_rx) = tokio:: sync:: oneshot:: channel ( ) ;
745+ let ( resume_tx, resume_rx) = tokio:: sync:: oneshot:: channel ( ) ;
746+ let calls = Arc :: new ( std:: sync:: atomic:: AtomicUsize :: new ( 0 ) ) ;
747+ let fenced = FencedHeader {
748+ session_id : uuid:: Uuid :: new_v4 ( ) ,
749+ generation : 1 ,
750+ owner_runtime_id : rid ( 1 ) ,
751+ } ;
752+ let stream = MeshStream :: new (
753+ Box :: new ( StubSend ) ,
754+ Box :: new ( PausedRecv {
755+ started : Some ( started_tx) ,
756+ resume : Some ( resume_rx) ,
757+ calls : Arc :: clone ( & calls) ,
758+ } ) ,
759+ ) ;
760+ let worker = tokio:: spawn ( run_demo_echo (
761+ SessionDirectory :: new ( pool) ,
762+ ReliableInbound {
763+ fenced,
764+ from : rid ( 2 ) ,
765+ stream : crate :: tunnel:: reliable:: ReliableMeshStream :: new_inbound ( fenced, stream) ,
766+ } ,
767+ Arc :: new ( AtomicBool :: new ( false ) ) ,
768+ ) ) ;
769+ started_rx
770+ . await
771+ . expect ( "production consumer started receiving" ) ;
772+ tokio:: time:: advance ( std:: time:: Duration :: from_millis ( 300 ) ) . await ;
773+ tokio:: task:: yield_now ( ) . await ;
774+ assert_eq ! ( calls. load( Ordering :: Relaxed ) , 1 , "tick restarted a receive" ) ;
775+ assert ! ( !worker. is_finished( ) , "tick abandoned the pending receive" ) ;
776+ resume_tx. send ( ( ) ) . expect ( "receive remains alive" ) ;
777+ worker. await . expect ( "consumer completed after stream EOF" ) ;
778+ }
779+
699780 fn rid ( byte : u8 ) -> RuntimeId {
700781 RuntimeId ( [ byte; 32 ] )
701782 }
0 commit comments