feat: implement worker lifecycle and sandbox

tests/support/fake_child.rs

@@ -0,0 +1,118 @@
+#![forbid(unsafe_code)]
+#![allow(missing_docs)]
+
+use std::{
+    env,
+    fs::{self, OpenOptions},
+    io::{self, Read as _, Write as _},
+    net::TcpStream,
+    os::unix::fs::OpenOptionsExt as _,
+    path::{Path, PathBuf},
+    process::ExitCode,
+    thread,
+    time::Duration,
+};
+
+fn main() -> ExitCode {
+    match execute() {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(error) => {
+            let _ignored = writeln!(io::stderr().lock(), "fake child: {error}");
+            ExitCode::FAILURE
+        }
+    }
+}
+
+fn execute() -> Result<(), Box<dyn std::error::Error>> {
+    let mut arguments = env::args_os().skip(1);
+    let behavior = arguments.next().ok_or("missing behavior")?;
+    if behavior == "exit-success" {
+        return Ok(());
+    }
+    if behavior == "network-probe" {
+        let address = arguments.next().ok_or("missing probe address")?;
+        TcpStream::connect(address.to_str().ok_or("probe address is not UTF-8")?)?;
+        return Ok(());
+    }
+    let request = PathBuf::from(arguments.next().ok_or("missing request path")?);
+    let response = PathBuf::from(arguments.next().ok_or("missing response path")?);
+    match behavior.to_str().ok_or("behavior is not UTF-8")? {
+        "success" => write_response(&request, &response, false, true),
+        "mismatch" => write_response(&request, &response, true, true),
+        "temporary-only" => write_response(&request, &response, false, false),
+        "no-response" => Ok(()),
+        "sleep" => {
+            let milliseconds = arguments
+                .next()
+                .ok_or("missing sleep milliseconds")?
+                .to_str()
+                .ok_or("sleep value is not UTF-8")?
+                .parse::<u64>()?;
+            thread::sleep(Duration::from_millis(milliseconds));
+            write_response(&request, &response, false, true)
+        }
+        "flood" => {
+            let count = arguments
+                .next()
+                .ok_or("missing flood byte count")?
+                .to_str()
+                .ok_or("flood value is not UTF-8")?
+                .parse::<usize>()?;
+            write_repeated(io::stdout().lock(), b'o', count)?;
+            write_repeated(io::stderr().lock(), b'e', count)?;
+            write_response(&request, &response, false, true)
+        }
+        _ => Err("unknown behavior".into()),
+    }
+}
+
+fn write_repeated(mut writer: impl io::Write, byte: u8, mut remaining: usize) -> io::Result<()> {
+    let buffer = vec![byte; 64 * 1024];
+    while remaining > 0 {
+        let count = remaining.min(buffer.len());
+        writer.write_all(&buffer[..count])?;
+        remaining -= count;
+    }
+    writer.flush()
+}
+
+fn write_response(
+    request_path: &Path,
+    response_path: &Path,
+    mismatch: bool,
+    publish: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mut request_bytes = Vec::new();
+    fs::File::open(request_path)?.read_to_end(&mut request_bytes)?;
+    let request: serde_json::Value = serde_json::from_slice(&request_bytes)?;
+    let invocation_id = if mismatch {
+        serde_json::Value::String("ffffffffffffffffffffffffffffffff".to_owned())
+    } else {
+        request["invocation_id"].clone()
+    };
+    let response = serde_json::json!({
+        "protocol_version": request["protocol_version"],
+        "invocation_id": invocation_id,
+        "operation": request["operation"],
+        "result": {
+            "status": "success",
+            "data": {
+                "ready": true,
+                "components": {}
+            }
+        }
+    });
+    let bytes = serde_json::to_vec(&response)?;
+    let temporary = response_path.with_file_name("response.json.tmp");
+    let mut file = OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .mode(0o600)
+        .open(&temporary)?;
+    file.write_all(&bytes)?;
+    file.sync_all()?;
+    if publish {
+        fs::rename(temporary, response_path)?;
+    }
+    Ok(())
+}