flow runner drain: drain the running runner by a request file 4dd392d16454

## Unreleased

- **A Windows runner updates itself (#83, #85):** `flow runner update` on Windows checks a PE build, renames `flow.exe` to `flow.prev.exe` and `flow.new.exe` into its place with `MoveFileExW` (retrying while a virus scanner holds a new file; a running program cannot rename its own file, so a copy of it, `flow __rename`, does), tells the running runner through an `update.request` file in its home (no SIGUSR1 there), and the runner leaves and exits 75 so a Task Scheduler task set to restart on failure starts the new build, which proves itself by reaching the hub. Tried in the Windows VM: install, leave, exit 75, restart, proven. A rollback runs the restored build and ends with it. Spec §11.5.3.

- **`flow` builds for Windows (#83, step 2 begun):** `cargo build --target x86_64-pc-windows-gnu` gives a `flow.exe` that offers the WASM tier: the syscall tier, the guest helpers and the egress proxy are Linux's only (a Windows build says the syscall tier "runs only on Linux"), cache pruning by reads stays on Linux, and file modes, links and sizes go through a small `portable` module (modes are not kept on Windows). Its claims report free disk (`GetDiskFreeSpaceExW`); load and kernel are not measured there yet, and a Windows runner does not update itself. `dist` builds `flow-windows-x86_64.exe` too. Nothing changes on Linux or Android. Tried in the Windows VM on Earth: `flow.exe tiers` offers wasm, a local `flow run` of a 120-step WASM job passes, and registered as runner `windows-1` (label `windows`) it ran andymccall/windows-runner-demo's job from the hub (run #1). Helpers start from the running binary's path on Windows (`/proc/self/exe` on Linux and Android).

- **The syscall tier's loopback reaches TCP (#73):** with `network "loopback"`, a job may open IPv4 and IPv6 sockets, which in its own network namespace reach only its `lo`, so a server it starts on 127.0.0.1 answers it (a conformance suite over an emulator's HTTP control port, which skipped every test on narvi-1). With `network "isolated"` sockets other than `AF_UNIX` are still refused.

`runtime "wasm"` sandbox and `runs-on "windows"`. To keep it running, a

Task Scheduler task at start-up with that command (restarting on failure)

does; set it to restart on failure, as a runner that leaves for a new build

## Commands

    flow hash FILE             # BLAKE3, for pinning in flow.toml

    flow runner                # claim and run jobs for the hub in flow.toml

    flow runner update --from FILE [--dry-run]   # install a new flow build in place of this one (spec §11.5.3)

## A Flow home

    /// Measure this machine as a runner does: its speed score (100 on the

    /// reference machine) and class, free disk and load (spec §11.1)

    Bench,

    /// Install a new flow build in place of this one (docs/jetstream.md

    /// §8.2): check it, keep this one as flow.prev, and have the running

    /// runner leave with notice so its unit starts the new build. A build

            println!("registered as {} (runner {}); start it with `flow runner`", got.name, got.id);

            Ok(())

        }

        Cmd::Runner { cmd: Some(RunnerCmd::Update { from, notice, dry_run, allow_older, exe }) } => {

            let home = Home::locate(cli.home.as_deref())?;

            let exe = match exe {

        let mut update_asked: Option<Instant> = None;

        let mut update_said = String::new();

        loop {

            if UPDATE.swap(false, std::sync::atomic::Ordering::SeqCst) || crate::update::requested(&home.root) {

                let p = crate::update::pending(&home.root);

                let notice = Duration::from_secs(p.as_ref().map_or(0, |p| p.notice_secs));

    false

}

/// Whether the runner has been asked, by file, to leave for a new build

/// (and forget the asking).

pub fn requested(home: &Path) -> bool {

/// Note this process as the home's runner, for `flow runner update` to tell.

pub fn note_runner(home: &Path) {

    let _ = std::fs::remove_file(home.join(REQUEST));

    let _ = std::fs::write(home.join(PID), std::process::id().to_string());

}

            .contains("not a Windows"));

        assert_eq!(beside(Path::new("C:/flow/flow.exe"), PREV), Path::new("C:/flow/flow.prev.exe"));

        assert_eq!(beside(Path::new("/usr/local/bin/flow"), NEW), Path::new("/usr/local/bin/flow.new"));

    }

    #[test]

  systemd kills what is left. A new binary is installed by replacing it

  and restarting the unit (`systemctl restart --no-block`): the old runner

  finishes its job, and `Restart=always` starts the new one.

### 11.5.2 Handing back (oxygenflow#76)