@@ -17,7 +17,7 @@ mod git_cli;
1717
1818use std:: {
1919 fs,
20- io:: Read ,
20+ io:: { Read , Write } ,
2121 net:: TcpStream ,
2222 path:: { Path , PathBuf } ,
2323 process:: { Child , Command , ExitStatus , Stdio } ,
@@ -234,6 +234,78 @@ fn is_service_tcp_connection(stream: &TcpStream) -> bool {
234234 )
235235}
236236
237+ /// A bare TCP accept is not readiness: another test's port allocator briefly
238+ /// `listen`s on a port it already claimed and then drops it, so a successful
239+ /// `connect` can belong to a stranger that never answers HTTP. Only a peer that
240+ /// replies with an HTTP/1.x status line can be this test's own service.
241+ fn is_service_http_ready ( port : u16 , deadline : Instant ) -> bool {
242+ let remaining = || {
243+ let now = Instant :: now ( ) ;
244+ ( now < deadline) . then ( || deadline - now)
245+ } ;
246+ let Some ( connect_budget) = remaining ( ) else {
247+ return false ;
248+ } ;
249+ let address = std:: net:: SocketAddr :: from ( ( [ 127 , 0 , 0 , 1 ] , port) ) ;
250+ let Ok ( mut stream) =
251+ TcpStream :: connect_timeout ( & address, connect_budget. min ( Duration :: from_secs ( 2 ) ) )
252+ else {
253+ return false ;
254+ } ;
255+ if !is_service_tcp_connection ( & stream) {
256+ return false ;
257+ }
258+ let Some ( write_budget) = remaining ( ) else {
259+ return false ;
260+ } ;
261+ let _ = stream. set_write_timeout ( Some ( write_budget. min ( Duration :: from_secs ( 2 ) ) ) ) ;
262+ let request = format ! ( "GET / HTTP/1.1\r \n Host: 127.0.0.1:{port}\r \n Connection: close\r \n \r \n " ) ;
263+ if stream. write_all ( request. as_bytes ( ) ) . is_err ( ) {
264+ return false ;
265+ }
266+ // Read one bounded status line instead of a fixed prefix: a stranger that
267+ // sends just `HTTP/` and closes must not be accepted as the service. Every
268+ // read is bounded by the remaining startup budget so a slow drip cannot
269+ // stretch one probe past the caller's deadline.
270+ let mut status = Vec :: with_capacity ( 64 ) ;
271+ let mut byte = [ 0u8 ; 1 ] ;
272+ while status. len ( ) < 64 {
273+ let Some ( read_budget) = remaining ( ) else {
274+ return false ;
275+ } ;
276+ let _ = stream. set_read_timeout ( Some ( read_budget. min ( Duration :: from_secs ( 2 ) ) ) ) ;
277+ match stream. read ( & mut byte) {
278+ Ok ( 1 ) => {
279+ status. push ( byte[ 0 ] ) ;
280+ if byte[ 0 ] == b'\n' {
281+ break ;
282+ }
283+ }
284+ _ => return false ,
285+ }
286+ }
287+ status_line_is_http ( & status)
288+ }
289+
290+ /// `HTTP/1.x` + exactly three status digits, terminated by a line break.
291+ fn status_line_is_http ( status : & [ u8 ] ) -> bool {
292+ let Some ( line) = status. strip_suffix ( b"\n " ) else {
293+ return false ;
294+ } ;
295+ let line = line. strip_suffix ( b"\r " ) . unwrap_or ( line) ;
296+ let Ok ( line) = std:: str:: from_utf8 ( line) else {
297+ return false ;
298+ } ;
299+ let Some ( ( version, rest) ) = line. split_once ( ' ' ) else {
300+ return false ;
301+ } ;
302+ if version != "HTTP/1.0" && version != "HTTP/1.1" {
303+ return false ;
304+ }
305+ let code = rest. split ( ' ' ) . next ( ) . unwrap_or_default ( ) ;
306+ code. len ( ) == 3 && code. bytes ( ) . all ( |b| b. is_ascii_digit ( ) )
307+ }
308+
237309#[ cfg( target_os = "linux" ) ]
238310fn self_connected_tcp_probe ( ) -> TcpStream {
239311 with_runtime ( async {
@@ -261,6 +333,105 @@ fn service_readiness_rejects_tcp_self_connection() {
261333 assert ! ( !is_service_tcp_connection( & stream) ) ;
262334}
263335
336+ #[ test]
337+ fn service_readiness_rejects_non_http_listener ( ) {
338+ let listener = std:: net:: TcpListener :: bind ( ( "127.0.0.1" , 0 ) ) . unwrap ( ) ;
339+ let port = listener. local_addr ( ) . unwrap ( ) . port ( ) ;
340+ let started = Instant :: now ( ) ;
341+ assert ! (
342+ !is_service_http_ready( port, Instant :: now( ) + Duration :: from_millis( 300 ) ) ,
343+ "a listener that never answers HTTP must not count as service readiness"
344+ ) ;
345+ assert ! ( started. elapsed( ) >= Duration :: from_millis( 250 ) ) ;
346+ drop ( listener) ;
347+ }
348+
349+ #[ test]
350+ fn service_readiness_accepts_http_responder ( ) {
351+ let listener = std:: net:: TcpListener :: bind ( ( "127.0.0.1" , 0 ) ) . unwrap ( ) ;
352+ let port = listener. local_addr ( ) . unwrap ( ) . port ( ) ;
353+ let handle = std:: thread:: spawn ( move || {
354+ let mut stream = listener. accept ( ) . expect ( "accept readiness probe" ) . 0 ;
355+ let mut request = [ 0u8 ; 64 ] ;
356+ let _ = stream. read ( & mut request) ;
357+ stream
358+ . write_all ( b"HTTP/1.1 204 No Content\r \n Content-Length: 0\r \n Connection: close\r \n \r \n " )
359+ . expect ( "answer readiness probe" ) ;
360+ } ) ;
361+ assert ! ( is_service_http_ready(
362+ port,
363+ Instant :: now( ) + Duration :: from_secs( 2 )
364+ ) ) ;
365+ handle. join ( ) . expect ( "responder thread" ) ;
366+ }
367+
368+ #[ test]
369+ fn service_readiness_rejects_truncated_http_prefix ( ) {
370+ let listener = std:: net:: TcpListener :: bind ( ( "127.0.0.1" , 0 ) ) . unwrap ( ) ;
371+ let port = listener. local_addr ( ) . unwrap ( ) . port ( ) ;
372+ let handle = std:: thread:: spawn ( move || {
373+ let mut stream = listener. accept ( ) . expect ( "accept probe" ) . 0 ;
374+ let mut request = [ 0u8 ; 64 ] ;
375+ let _ = stream. read ( & mut request) ;
376+ stream. write_all ( b"HTTP/" ) . expect ( "write prefix" ) ;
377+ } ) ;
378+ assert ! ( !is_service_http_ready(
379+ port,
380+ Instant :: now( ) + Duration :: from_secs( 2 )
381+ ) ) ;
382+ handle. join ( ) . expect ( "prefix thread" ) ;
383+ }
384+
385+ #[ test]
386+ fn service_readiness_rejects_malformed_status_line ( ) {
387+ let listener = std:: net:: TcpListener :: bind ( ( "127.0.0.1" , 0 ) ) . unwrap ( ) ;
388+ let port = listener. local_addr ( ) . unwrap ( ) . port ( ) ;
389+ let handle = std:: thread:: spawn ( move || {
390+ let mut stream = listener. accept ( ) . expect ( "accept probe" ) . 0 ;
391+ let mut request = [ 0u8 ; 64 ] ;
392+ let _ = stream. read ( & mut request) ;
393+ stream
394+ . write_all ( b"HTTP/1.1 NOT_A_CODE Nope\r \n " )
395+ . expect ( "write malformed status" ) ;
396+ } ) ;
397+ assert ! ( !is_service_http_ready(
398+ port,
399+ Instant :: now( ) + Duration :: from_secs( 2 )
400+ ) ) ;
401+ handle. join ( ) . expect ( "malformed thread" ) ;
402+ }
403+
404+ #[ test]
405+ fn service_readiness_rejects_slow_drip_status_line ( ) {
406+ let listener = std:: net:: TcpListener :: bind ( ( "127.0.0.1" , 0 ) ) . unwrap ( ) ;
407+ let port = listener. local_addr ( ) . unwrap ( ) . port ( ) ;
408+ let handle = std:: thread:: spawn ( move || {
409+ let mut stream = listener. accept ( ) . expect ( "accept probe" ) . 0 ;
410+ let mut request = [ 0u8 ; 64 ] ;
411+ let _ = stream. read ( & mut request) ;
412+ // Never finish the status line: the probe must stop at its own deadline
413+ // instead of granting every byte a fresh read timeout.
414+ for chunk in [ b"H" . as_slice ( ) , b"T" , b"T" , b"P" , b"/" , b"1" , b"." , b"1" ] {
415+ if stream. write_all ( chunk) . is_err ( ) {
416+ break ;
417+ }
418+ std:: thread:: sleep ( Duration :: from_millis ( 100 ) ) ;
419+ }
420+ std:: thread:: sleep ( Duration :: from_millis ( 500 ) ) ;
421+ } ) ;
422+ let started = Instant :: now ( ) ;
423+ assert ! ( !is_service_http_ready(
424+ port,
425+ Instant :: now( ) + Duration :: from_millis( 400 )
426+ ) ) ;
427+ assert ! (
428+ started. elapsed( ) < Duration :: from_millis( 1200 ) ,
429+ "probe must honour the cumulative deadline, took {:?}" ,
430+ started. elapsed( )
431+ ) ;
432+ handle. join ( ) . expect ( "slow drip thread" ) ;
433+ }
434+
264435#[ test]
265436fn service_readiness_accepts_real_listener_connection ( ) {
266437 let listener = std:: net:: TcpListener :: bind ( ( "127.0.0.1" , 0 ) ) . unwrap ( ) ;
@@ -295,9 +466,7 @@ impl ServiceProcess {
295466 ) {
296467 let deadline = Instant :: now ( ) + timeout;
297468 loop {
298- if TcpStream :: connect ( ( "127.0.0.1" , port) )
299- . is_ok_and ( |stream| is_service_tcp_connection ( & stream) )
300- {
469+ if is_service_http_ready ( port, deadline) {
301470 return ;
302471 }
303472 if let Some ( status) = self . child . try_wait ( ) . expect ( "poll service" ) {
0 commit comments