knishio-cli 0.1.0

KnishIO validator orchestration CLI — Docker control, cell management, benchmarks, and health checks
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Benchmark delegation — locates and runs the knishio-bench binary.

use anyhow::{Context, Result};
use std::path::Path;
use std::process::Stdio;
use tokio::process::Command;

use crate::output;

/// Run `knishio-bench generate` with the given args.
pub async fn generate(
    bench_bin: &Path,
    identities: usize,
    types: &[String],
    metas_per_identity: usize,
    transfers_per_identity: usize,
    rules_per_identity: usize,
    burns_per_identity: usize,
    token_amount: f64,
    output_path: &str,
) -> Result<()> {
    output::info("Generating benchmark plan...");
    let mut cmd = Command::new(bench_bin);
    cmd.arg("generate")
        .arg("--identities")
        .arg(identities.to_string())
        .arg("--types")
        .arg(types.join(","))
        .arg("--metas-per-identity")
        .arg(metas_per_identity.to_string())
        .arg("--transfers-per-identity")
        .arg(transfers_per_identity.to_string())
        .arg("--rules-per-identity")
        .arg(rules_per_identity.to_string())
        .arg("--burns-per-identity")
        .arg(burns_per_identity.to_string())
        .arg("--token-amount")
        .arg(token_amount.to_string())
        .arg("-o")
        .arg(output_path)
        .stdout(Stdio::inherit())
        .stderr(Stdio::inherit());

    let status = cmd.status().await.context("Failed to run knishio-bench")?;
    if status.success() {
        output::success(&format!("Plan written to {}", output_path));
    } else {
        output::error("Benchmark generation failed");
    }
    Ok(())
}

/// Run `knishio-bench execute` with the given args.
pub async fn execute(
    bench_bin: &Path,
    plan_path: &str,
    endpoint: &str,
    concurrency: usize,
    cell_slug: Option<&str>,
) -> Result<()> {
    output::info(&format!("Executing benchmark plan: {}", plan_path));
    let mut cmd = Command::new(bench_bin);
    cmd.arg("execute")
        .arg(plan_path)
        .arg("--endpoint")
        .arg(endpoint)
        .arg("--concurrency")
        .arg(concurrency.to_string())
        .stdout(Stdio::inherit())
        .stderr(Stdio::inherit());

    if let Some(slug) = cell_slug {
        cmd.arg("--cell-slug").arg(slug);
    }

    let status = cmd.status().await.context("Failed to run knishio-bench")?;
    if status.success() {
        output::success("Benchmark complete");
    } else {
        output::error("Benchmark execution failed");
    }
    Ok(())
}

/// Convenience: generate + execute in one shot.
pub async fn run(
    bench_bin: &Path,
    identities: usize,
    types: &[String],
    metas_per_identity: usize,
    transfers_per_identity: usize,
    rules_per_identity: usize,
    burns_per_identity: usize,
    token_amount: f64,
    endpoint: &str,
    concurrency: usize,
    cell_slug: Option<&str>,
) -> Result<()> {
    let plan_path = format!("bench-plan-{}.db", std::process::id());

    generate(
        bench_bin,
        identities,
        types,
        metas_per_identity,
        transfers_per_identity,
        rules_per_identity,
        burns_per_identity,
        token_amount,
        &plan_path,
    )
    .await?;

    execute(bench_bin, &plan_path, endpoint, concurrency, cell_slug).await?;

    // Clean up temp plan file
    let _ = std::fs::remove_file(&plan_path);

    Ok(())
}