Support optional command priorities.

Author: twittner

justfile

@@ -28,11 +28,11 @@ build-contracts:
 
 [private]
 build-port-alloc:
-  cargo build --release -p test-utils --bin run --bin port-alloc --features ports
+  cargo build --release -p test-utils --bin run --bin port-alloc --no-default-features --features ports
 
 [private]
 build-test-utils:
-  cargo build --release -p test-utils --all-features
+  cargo build --release -p test-utils
 
 ####################
 ###CHECK COMMANDS###
@@ -147,23 +147,23 @@ verify_blocks *ARGS:
 ####TEST COMMANDS###
 ####################
 test *ARGS: build-port-alloc
-  target/release/run --with target/release/port-alloc cargo nextest run -- {{ARGS}}
+  target/release/run --spawn target/release/port-alloc cargo nextest run -- {{ARGS}}
   @if [ "{{ARGS}}" == "" ]; then cargo test --doc; fi
 
 test-contracts: build-contracts
   forge test
 
 test_ci *ARGS: build-port-alloc
   env {{LOG_LEVELS}} NO_COLOR=1 target/release/run \
-    --with target/release/port-alloc \
+    --spawn target/release/port-alloc \
     -- cargo nextest run --workspace {{ARGS}}
   env {{LOG_LEVELS}} NO_COLOR=1 cargo test --doc {{ARGS}}
 
 test-individually: build-port-alloc
   @for pkg in $(cargo metadata --no-deps --format-version 1 | jq -r '.packages[].name'); do \
     echo "Testing $pkg"; \
     target/release/run \
-        --with target/release/port-alloc \
+        --spawn target/release/port-alloc \
         -- cargo nextest run --no-tests=pass -p $pkg || exit 1; \
   done
 
@@ -172,11 +172,10 @@ test-contract-deploy *ARGS:
 
 test-all: build_release build-test-utils
     env RUST_LOG=timeboost_builder::submit=info,warn target/release/run \
-        --exec "scripts/test-contract-deploy --keep-anvil" \
-        --with "target/release/block-maker --port 55000 --committee test-configs/c0/committee.toml" \
-        --with "target/release/yapper --keyset-file test-configs/c0/committee.toml" \
-        target/release/run-committee -- \
-            --max-duration 30 \
-            --configs test-configs/local/ \
-            --committee 0 \
-            --timeboost target/release/timeboost
+        --spawn "1:anvil --port 8545" \
+        --run   "2:sleep 3" \
+        --run   "3:scripts/deploy-test-contract" \
+        --spawn "4:target/release/block-maker --port 55000 --committee test-configs/c0/committee.toml" \
+        --spawn "4:target/release/yapper --keyset-file test-configs/c0/committee.toml" \
+        --spawn "5:target/release/run-committee --configs test-configs/local/ --committee 0 --timeboost target/release/timeboost" \
+        sleep -- 30

scripts/deploy-test-contract

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+MANAGER_MNEMONIC="attend year erase basket blind adapt stove broccoli isolate unveil acquire category"
+MANAGER_ACCOUNT_INDEX=0
+MANAGER_ADDRESS="0x36561082951eed7ffD59cFD82D70570C57072d02"
+FAUCET_PRIVATE_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+URL="http://localhost:8545"
+DEPLOYMENT_FILE=$(mktemp -t timeboost-deployment-XXXXX)
+
+# Fund manager account && create deployment file
+cast send --value 1ether --private-key "$FAUCET_PRIVATE_KEY" "$MANAGER_ADDRESS"
+env RUST_LOG=info cargo run --release --bin deploy -- \
+    -m "$MANAGER_MNEMONIC" \
+    -i "$MANAGER_ACCOUNT_INDEX" \
+    -u "$URL" \
+    -o "$DEPLOYMENT_FILE"
+
+# Extract the deployed KeyManager address
+km_addr=$(sed -nr 's/^key_manager.*=.*"(.+)"/\1/p' "$DEPLOYMENT_FILE")
+
+# Update the contract
+env RUST_LOG=info cargo run --release --bin register -- \
+    -m "$MANAGER_MNEMONIC" \
+    -i "$MANAGER_ACCOUNT_INDEX" \
+    -u "$URL" \
+    -k "$km_addr" \
+    -c "test-configs/c0/committee.toml"
+
+# Clean up the temporary deployment file
+rm -f "$DEPLOYMENT_FILE"

test-utils/src/binaries/run-committee.rs

@@ -50,8 +50,7 @@ async fn main() -> Result<()> {
             .arg("false")
             .arg("--config")
             .arg(entry.path())
-            .arg("--ignore-stamp")
-            .kill_on_drop(true);
+            .arg("--ignore-stamp");
         commands.push(cmd);
     }
 

test-utils/src/binaries/run.rs

@@ -17,48 +17,63 @@ use tokio::{
 
 #[derive(Parser, Debug)]
 struct Args {
-    /// Commands to run to completion first.
-    #[clap(long, short)]
-    exec: Vec<String>,
+    /// Commands to run to completion.
+    #[clap(long, short, value_parser = parse_command_line)]
+    run: Vec<Commandline>,
 
     /// Commands to run concurrently.
-    #[clap(long, short)]
-    with: Vec<String>,
+    #[clap(long, short, value_parser = parse_command_line)]
+    spawn: Vec<Commandline>,
 
-    /// Optional timeout in seconds.
+    /// Optional timeout main command in seconds.
     #[clap(long, short)]
     timeout: Option<u64>,
 
+    #[clap(long, short)]
+    verbose: bool,
+
     /// Main command to execute.
     main: Vec<String>,
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let args = Args::parse();
+    let mut args = Args::parse();
+    args.spawn.iter_mut().for_each(|c| c.sync = false);
+
+    let mut commands = args.run;
+    commands.append(&mut args.spawn);
+    commands.sort();
 
     let mut term = signal(SignalKind::terminate())?;
     let mut intr = signal(SignalKind::interrupt())?;
+    let mut helpers = JoinSet::<Result<ExitStatus>>::new();
 
-    for exe in &args.exec {
-        let mut pg = ProcessGroup::spawn(exe.split_whitespace())?;
-        let status = select! {
-            s = pg.wait()   => s?,
-            _ = term.recv() => return Ok(()),
-            _ = intr.recv() => return Ok(()),
-        };
-        if !status.success() {
-            bail!("{exe:?} failed with {:?}", status.code());
+    for commandline in commands {
+        if args.verbose {
+            if commandline.sync {
+                eprintln!("running command: {}", commandline.args)
+            } else {
+                eprintln!("spawning command: {}", commandline.args)
+            }
+        }
+        let mut pg = ProcessGroup::spawn(commandline.args.split_whitespace())?;
+        if commandline.sync {
+            let status = select! {
+                s = pg.wait()   => s?,
+                _ = term.recv() => return Ok(()),
+                _ = intr.recv() => return Ok(()),
+            };
+            if !status.success() {
+                bail!("{:?} failed with {:?}", commandline.args, status.code());
+            }
+        } else {
+            helpers.spawn(async move {
+                let mut pg = ProcessGroup::spawn(commandline.args.split_whitespace())?;
+                let status = pg.wait().await?;
+                Ok(status)
+            });
         }
-    }
-
-    let mut helpers = JoinSet::<Result<ExitStatus>>::new();
-    for w in args.with {
-        helpers.spawn(async move {
-            let mut pg = ProcessGroup::spawn(w.split_whitespace())?;
-            let status = pg.wait().await?;
-            Ok(status)
-        });
     }
 
     let mut main = ProcessGroup::spawn(args.main)?;
@@ -88,6 +103,22 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+struct Commandline {
+    prio: u8,
+    args: String,
+    sync: bool,
+}
+
+fn parse_command_line(s: &str) -> Result<Commandline> {
+    let (p, a) = s.split_once(':').unwrap_or(("0", s));
+    Ok(Commandline {
+        prio: p.parse()?,
+        args: a.to_string(),
+        sync: true,
+    })
+}
+
 /// Every command is spawned into its own, newly created process group.
 struct ProcessGroup(Child, Pid);