running-process 4.8.0__tar.gz → 4.8.2__tar.gz

{running_process-4.8.0 → running_process-4.8.2}/Cargo.lock

@@ -2051,7 +2051,7 @@ dependencies = [
 
 [[package]]
 name = "running-process"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "anyhow",
  "blake3",
@@ -2093,7 +2093,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-probe"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "blake3",
  "crash-handler",
@@ -2116,7 +2116,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-probe-daemon"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "axum",
  "blake3",
@@ -2150,21 +2150,21 @@ dependencies = [
 
 [[package]]
 name = "running-process-probe-interposer-linux"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "running-process-probe-interposer-macos"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "running-process-probe-interposer-windows"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "retour",
  "windows-sys 0.59.0",
@@ -2172,7 +2172,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-probe-worker"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "addr2line",
  "lzma-rs",
@@ -2190,7 +2190,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-py"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "interprocess",
  "libc",
@@ -2205,7 +2205,7 @@ dependencies = [
 
 [[package]]
 name = "running-process-win-gnu-bridge"
-version = "4.8.0"
+version = "4.8.2"
 dependencies = [
  "windows-sys 0.59.0",
 ]

{running_process-4.8.0 → running_process-4.8.2}/Cargo.toml

@@ -7,7 +7,7 @@ members = ["crates/running-process", "crates/running-process-probe", "crates/run
 exclude = ["testbins-tokio"]
 
 [workspace.package]
-version = "4.8.0"
+version = "4.8.2"
 edition = "2021"
 rust-version = "1.85"
 license = "BSD-3-Clause"

{running_process-4.8.0 → running_process-4.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: running_process
-Version: 4.8.0
+Version: 4.8.2
 License-File: LICENSE
 Summary: A Rust-backed subprocess wrapper with split stdout/stderr streaming
 Home-Page: https://github.com/zackees/running-process

{running_process-4.8.0 → running_process-4.8.2}/crates/running-process/Cargo.toml

@@ -167,7 +167,7 @@ sha2 = { version = "0.10", optional = true }
 getrandom = { version = "0.4", optional = true }
 # #633: schema-only dependency for the probe client facade. default-features
 # off keeps the interposer/injection machinery out — see the `probe` feature.
-running-process-probe = { path = "../running-process-probe", version = "4.8.0", default-features = false, optional = true }
+running-process-probe = { path = "../running-process-probe", version = "4.8.2", default-features = false, optional = true }
 # Wave 5 of #165: daemon-feature deps. All optional.
 # tokio: `client-async` (#414) only needs the `rt` (spawn_blocking)
 # and `time` (`tokio::time::timeout`) features; the `daemon` feature

{running_process-4.8.0 → running_process-4.8.2}/crates/running-process/src/bin/running-process-broker-v2.rs

@@ -71,6 +71,41 @@ use running_process::broker::protocol_v2::ServiceDefinitionLoader;
 use running_process::broker::server::deadline_stream::{hello_read_deadline, DeadlineStream};
 use running_process::broker::server::service_def_loader::ServiceDefinitionError;
 
+/// Write a line to stdout, tolerating a reader that has gone away.
+///
+/// `println!` panics if the underlying write fails, and the failure it
+/// hits in practice is `EPIPE` — someone was reading the broker's stdout
+/// and stopped. That is not a broker fault and it is not a reason to
+/// abort: the broker's job is brokering, and its progress chatter is
+/// diagnostic. Panicking there turns "nobody is reading the log" into a
+/// process exit with status 101 and a backtrace that points at the
+/// logging line rather than at the closed pipe, which is a genuinely
+/// misleading thing to hand an operator.
+///
+/// This surfaced during the #532 acceptance work: a test whose reader
+/// thread dropped its end of the pipe made the broker exit 101 on
+/// SIGTERM, and the shutdown path looked defective for as long as it took
+/// to notice the panic came from the `println!` announcing the shutdown.
+///
+/// Errors are dropped rather than reported: the reporting channel for a
+/// failed stdout write would be stderr, which in the case that matters
+/// (a supervisor closing both) has failed too.
+macro_rules! say {
+    ($($arg:tt)*) => {{
+        use std::io::Write as _;
+        let _ = writeln!(std::io::stdout(), $($arg)*);
+    }};
+}
+
+/// [`say!`] for stderr. Same reasoning: a diagnostic that kills the
+/// process when it cannot be delivered is worse than a lost diagnostic.
+macro_rules! say_err {
+    ($($arg:tt)*) => {{
+        use std::io::Write as _;
+        let _ = writeln!(std::io::stderr(), $($arg)*);
+    }};
+}
+
 /// Default program name when `--program` is not passed. Matches the
 /// slice-3c scaffold so existing integration tests keep working.
 const DEFAULT_PROGRAM: &str = "broker-v2-scaffold";
@@ -302,18 +337,18 @@ fn main() -> ExitCode {
     let opts = match parse_cli(&args) {
         Ok(o) => o,
         Err(msg) => {
-            eprintln!("{msg}");
+            say_err!("{msg}");
             return ExitCode::from(2);
         }
     };
 
-    println!(
+    say!(
         "running-process-broker-v2 {} (slice 1 of running-process#532)",
         env!("CARGO_PKG_VERSION")
     );
 
     if opts.no_bind {
-        println!("running-process-broker-v2 --no-bind: skipping listener bind");
+        say!("running-process-broker-v2 --no-bind: skipping listener bind");
         return ExitCode::SUCCESS;
     }
 
@@ -326,7 +361,7 @@ fn main() -> ExitCode {
     // env var is honored for isolated test environments that
     // intentionally exercise privileged startup behavior.
     if let Err(err) = refuse_privileged_run() {
-        eprintln!(
+        say_err!(
             "running-process-broker-v2: refusing privileged startup: {err}. \
              Run as an unprivileged user, or set \
              RUNNING_PROCESS_BROKER_ALLOW_PRIVILEGED=1 for isolated test environments only."
@@ -337,7 +372,7 @@ fn main() -> ExitCode {
     let sid = match user_sid_hash() {
         Ok(s) => s,
         Err(err) => {
-            eprintln!("running-process-broker-v2: user_sid_hash failed: {err}");
+            say_err!("running-process-broker-v2: user_sid_hash failed: {err}");
             return ExitCode::from(1);
         }
     };
@@ -345,7 +380,7 @@ fn main() -> ExitCode {
     let pipe_name = match v2_program_pipe(&opts.program, &sid, SCAFFOLD_PIPE_IDX) {
         Ok(n) => n,
         Err(err) => {
-            eprintln!("running-process-broker-v2: v2_program_pipe failed: {err}");
+            say_err!("running-process-broker-v2: v2_program_pipe failed: {err}");
             return ExitCode::from(1);
         }
     };
@@ -353,7 +388,7 @@ fn main() -> ExitCode {
     let socket_path = match resolve_socket_path(&pipe_name) {
         Ok(p) => p,
         Err(err) => {
-            eprintln!("running-process-broker-v2: resolve_socket_path failed: {err}");
+            say_err!("running-process-broker-v2: resolve_socket_path failed: {err}");
             return ExitCode::from(1);
         }
     };
@@ -366,7 +401,7 @@ fn main() -> ExitCode {
         let path = std::path::Path::new(&socket_path);
         if let Some(parent) = path.parent() {
             if let Err(err) = std::fs::create_dir_all(parent) {
-                eprintln!(
+                say_err!(
                     "running-process-broker-v2: create_dir_all({}) failed: {err}",
                     parent.display()
                 );
@@ -379,7 +414,7 @@ fn main() -> ExitCode {
     let name = match wrap_socket_name(&socket_path) {
         Ok(n) => n,
         Err(err) => {
-            eprintln!("running-process-broker-v2: wrap_socket_name failed: {err}");
+            say_err!("running-process-broker-v2: wrap_socket_name failed: {err}");
             return ExitCode::from(1);
         }
     };
@@ -393,7 +428,7 @@ fn main() -> ExitCode {
             // socket. Surface a directly-actionable message instead of
             // a raw OS error string.
             if is_already_bound_error(&err) {
-                eprintln!(
+                say_err!(
                     "running-process-broker-v2: another broker is already \
                      bound at {socket_path} (program={}). Refusing to \
                      start to avoid double-bind. Stop the other broker \
@@ -403,18 +438,18 @@ fn main() -> ExitCode {
                 );
                 return ExitCode::from(75); // EX_TEMPFAIL — supervisor can retry after the other broker exits
             }
-            eprintln!("running-process-broker-v2: bind failed at {socket_path}: {err}");
+            say_err!("running-process-broker-v2: bind failed at {socket_path}: {err}");
             return ExitCode::from(1);
         }
     };
 
-    println!(
+    say!(
         "running-process-broker-v2 bound at {socket_path} (program={}, mode={})",
         opts.program,
         if opts.once { "once" } else { "loop" }
     );
     if let Err(err) = std::io::stdout().flush() {
-        eprintln!("running-process-broker-v2: stdout flush failed: {err}");
+        say_err!("running-process-broker-v2: stdout flush failed: {err}");
     }
 
     let loader = Arc::new(ServiceDefinitionLoader::default_root());
@@ -431,7 +466,7 @@ fn main() -> ExitCode {
                 // HTTP page is an optional view onto it. Exiting here would
                 // take out working brokering because a diagnostic page could
                 // not bind.
-                eprintln!("running-process-broker-v2: HTTP surface disabled: {err}");
+                say_err!("running-process-broker-v2: HTTP surface disabled: {err}");
                 None
             }
         }
@@ -446,13 +481,13 @@ fn main() -> ExitCode {
     } else {
         #[cfg(unix)]
         if let Err(err) = install_shutdown_signal_handlers() {
-            eprintln!("running-process-broker-v2: install shutdown signal handlers failed: {err}");
+            say_err!("running-process-broker-v2: install shutdown signal handlers failed: {err}");
             return ExitCode::from(1);
         }
 
         #[cfg(windows)]
         if let Err(err) = install_shutdown_console_handler() {
-            eprintln!("running-process-broker-v2: install console control handler failed: {err}");
+            say_err!("running-process-broker-v2: install console control handler failed: {err}");
             return ExitCode::from(1);
         }
 
@@ -486,12 +521,12 @@ fn main() -> ExitCode {
         if let Err(err) =
             broker_http_discovery::unpublish_http_port(&broker_v2_runtime_dir(), &started.program)
         {
-            eprintln!("running-process-broker-v2: could not unpublish HTTP endpoint: {err}");
+            say_err!("running-process-broker-v2: could not unpublish HTTP endpoint: {err}");
         }
     }
 
     if let Err(err) = flush_coverage_profile() {
-        eprintln!("running-process-broker-v2: coverage profile flush failed: {err}");
+        say_err!("running-process-broker-v2: coverage profile flush failed: {err}");
         return ExitCode::from(1);
     }
 
@@ -534,12 +569,12 @@ fn start_http_surface(
         broker_http_discovery::publish_http_port(runtime_dir, program, local.ip(), local.port())
             .map_err(|e| format!("publishing {local} to {}: {e}", runtime_dir.display()))?;
 
-    println!(
+    say!(
         "running-process-broker-v2 http at http://{local} (published to {})",
         path.display()
     );
     if let Err(err) = std::io::stdout().flush() {
-        eprintln!("running-process-broker-v2: stdout flush failed: {err}");
+        say_err!("running-process-broker-v2: stdout flush failed: {err}");
     }
 
     // Detached: the surface is read-only and stateless, so there is nothing
@@ -552,7 +587,7 @@ fn start_http_surface(
                 // One failed accept says nothing about the next. Logging and
                 // continuing keeps a transient error from silently taking the
                 // page down for the life of the broker.
-                eprintln!("running-process-broker-v2: http accept failed: {err}");
+                say_err!("running-process-broker-v2: http accept failed: {err}");
             }
         })
         .map_err(|e| format!("spawning the http thread: {e}"))?;
@@ -574,7 +609,7 @@ fn accept_loop(
     http: Option<Arc<HttpEndpointRegistry>>,
 ) -> ExitCode {
     if let Err(err) = listener.set_nonblocking(ListenerNonblockingMode::Accept) {
-        eprintln!("running-process-broker-v2: set listener nonblocking failed: {err}");
+        say_err!("running-process-broker-v2: set listener nonblocking failed: {err}");
         return ExitCode::from(1);
     }
 
@@ -590,7 +625,7 @@ fn accept_loop(
                 let n = inflight.fetch_add(1, Ordering::SeqCst);
                 if n >= max_inflight {
                     inflight.fetch_sub(1, Ordering::SeqCst);
-                    eprintln!(
+                    say_err!(
                         "running-process-broker-v2: at MAX_INFLIGHT_HANDLERS ({max_inflight}); dropping connection",
                     );
                     drop(stream);
@@ -615,19 +650,17 @@ fn accept_loop(
                                 if let Some(reg) = &http_handler {
                                     reg.track(svc.clone());
                                 }
-                                println!(
-                                    "running-process-broker-v2 Hello service={svc:?} negotiated",
-                                )
+                                say!("running-process-broker-v2 Hello service={svc:?} negotiated",)
                             }
                             Err(err) => {
-                                eprintln!("running-process-broker-v2 Hello handler failed: {err}")
+                                say_err!("running-process-broker-v2 Hello handler failed: {err}")
                             }
                         }
                     });
                 match spawn_result {
                     Ok(handler) => handlers.push(handler),
                     Err(err) => {
-                        eprintln!(
+                        say_err!(
                             "running-process-broker-v2: thread spawn failed: {err}; \
                              dropping connection"
                         );
@@ -637,14 +670,14 @@ fn accept_loop(
                 }
             }
             Ok(None) => {
-                println!("running-process-broker-v2: shutdown requested; draining handlers");
+                say!("running-process-broker-v2: shutdown requested; draining handlers");
                 drain_handlers(&mut handlers, HANDLER_DRAIN_TIMEOUT);
                 return ExitCode::SUCCESS;
             }
             Err(err) => {
                 // accept() errors are typically fatal (listener died);
                 // exit so a supervisor can restart us.
-                eprintln!("running-process-broker-v2: accept failed: {err}");
+                say_err!("running-process-broker-v2: accept failed: {err}");
                 return ExitCode::from(1);
             }
         }
@@ -674,7 +707,7 @@ fn reap_finished_handlers(handlers: &mut Vec<thread::JoinHandle<()>>) {
         if handlers[index].is_finished() {
             let handler = handlers.swap_remove(index);
             if handler.join().is_err() {
-                eprintln!("running-process-broker-v2: handler thread panicked");
+                say_err!("running-process-broker-v2: handler thread panicked");
             }
         } else {
             index += 1;
@@ -692,7 +725,7 @@ fn drain_handlers(handlers: &mut Vec<thread::JoinHandle<()>>, timeout: Duration)
     }
     reap_finished_handlers(handlers);
     if !handlers.is_empty() {
-        eprintln!(
+        say_err!(
             "running-process-broker-v2: handler drain timed out after {timeout:?}; \
              detaching {} handler(s)",
             handlers.len()
@@ -709,25 +742,23 @@ fn accept_one(
 ) -> ExitCode {
     match listener.accept() {
         Ok(mut stream) => {
-            println!("running-process-broker-v2 peer connected (--once)");
+            say!("running-process-broker-v2 peer connected (--once)");
             match handle_hello_with_deadline(&mut stream, &loader) {
                 Ok(svc) => {
                     if let Some(reg) = &http {
                         reg.track(svc.clone());
                     }
-                    println!(
-                        "running-process-broker-v2 Hello for service {svc:?} negotiated; exiting"
-                    );
+                    say!("running-process-broker-v2 Hello for service {svc:?} negotiated; exiting");
                     ExitCode::SUCCESS
                 }
                 Err(err) => {
-                    eprintln!("running-process-broker-v2: Hello handler failed: {err}");
+                    say_err!("running-process-broker-v2: Hello handler failed: {err}");
                     ExitCode::from(1)
                 }
             }
         }
         Err(err) => {
-            eprintln!("running-process-broker-v2: accept failed: {err}");
+            say_err!("running-process-broker-v2: accept failed: {err}");
             ExitCode::from(1)
         }
     }

{running_process-4.8.0 → running_process-4.8.2}/crates/running-process/src/broker/protocol_v2/client_compat.rs

@@ -59,6 +59,31 @@ pub use super::super::adopt::{
 // Re-export every v1 client symbol zccache consumes.
 pub use super::super::client::{BackendConnectionRoute, BrokerClientError, RefusalKind};
 
+/// Classify a v2 broker error the way a v1 consumer classifies a refusal.
+///
+/// The first piece of the `client_compat` swap described above (#532
+/// criterion 5). Consumers branch on [`RefusalKind`] today — zccache maps
+/// `BrokerV2Error` in exactly one place — so the swap needs the v2 error to
+/// answer the same question before anything else can move.
+///
+/// `None` means "not a refusal": a dial failure, a framing error, or an I/O
+/// error is a different category, and flattening those into a `RefusalKind`
+/// would tell a caller the broker said no when in fact it was never reached.
+/// That distinction drives retry behaviour, so it is worth the `Option`.
+///
+/// The mapping itself is deliberately delegated to [`RefusalKind::from_code`]
+/// rather than restated. A second copy of that match is a second thing to
+/// keep in step, and the failure would be silent: a new `ErrorCode` would
+/// classify one way through v1 and another through v2.
+pub fn refusal_kind(error: &super::super::client_v2::BrokerV2Error) -> Option<RefusalKind> {
+    match error {
+        super::super::client_v2::BrokerV2Error::Refused { details, .. } => {
+            Some(RefusalKind::from_code(details.code()))
+        }
+        _ => None,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -66,6 +91,65 @@ mod tests {
     /// Slice 25-A contract: every v1 broker-client + adopt symbol zccache
     /// imports is reachable through the v2 namespace at the same TypeId.
     /// A future upstream rename or fork catches here as a build break.
+    fn refused_v2(
+        code: crate::broker::protocol::ErrorCode,
+    ) -> super::super::super::client_v2::BrokerV2Error {
+        let mut refused = crate::broker::protocol::Refused {
+            reason: "nope".into(),
+            ..Default::default()
+        };
+        refused.set_code(code);
+        super::super::super::client_v2::BrokerV2Error::Refused {
+            reason: "nope".into(),
+            retry_after_ms: 0,
+            details: Box::new(refused),
+        }
+    }
+
+    #[test]
+    fn a_v2_refusal_classifies_the_same_as_a_v1_one() {
+        use crate::broker::protocol::ErrorCode;
+        // The property the swap depends on: a consumer branching on
+        // `RefusalKind` sees the same answer whichever client produced it.
+        // Checked across the whole enum rather than one variant, because a
+        // mapping that is right for `ServiceUnknown` and wrong for
+        // `RateLimited` still compiles and still looks tested.
+        for code in [
+            ErrorCode::ErrorVersionUnsupported,
+            ErrorCode::ErrorVersionBlocked,
+            ErrorCode::ErrorServiceUnknown,
+            ErrorCode::ErrorRateLimited,
+            ErrorCode::ErrorShuttingDown,
+        ] {
+            assert_eq!(
+                refusal_kind(&refused_v2(code)),
+                Some(RefusalKind::from_code(code)),
+                "v2 refusal for {code:?} classified differently from v1"
+            );
+        }
+    }
+
+    #[test]
+    fn an_unknown_code_stays_unknown_rather_than_becoming_a_named_refusal() {
+        use crate::broker::protocol::ErrorCode;
+        // A code this build does not know must arrive as `Other`, not as the
+        // nearest named variant. Guessing here would tell a caller the broker
+        // said something specific that it did not.
+        let kind = refusal_kind(&refused_v2(ErrorCode::Unspecified));
+        assert_eq!(kind, Some(RefusalKind::from_code(ErrorCode::Unspecified)));
+        assert!(matches!(kind, Some(RefusalKind::Other(_))));
+    }
+
+    #[test]
+    fn a_transport_failure_is_not_a_refusal() {
+        // The distinction that drives retry behaviour: the broker saying no
+        // is not the same as never reaching it. Flattening a dial or I/O
+        // error into a `RefusalKind` would report a decision the broker never
+        // made.
+        let io = super::super::super::client_v2::BrokerV2Error::Io(std::io::Error::other("boom"));
+        assert_eq!(refusal_kind(&io), None);
+    }
+
     #[test]
     fn v1_client_adopt_types_are_aliased_under_v2_namespace() {
         use std::any::TypeId;