gflow 0.4.14

A lightweight, single-node job scheduler written in Rust.
Documentation 
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

use anyhow::{Context, Result};
use gflow::{client::Client, core::job::JobState, utils::parse_job_ids};

pub async fn handle_cancel(client: &Client, ids: &str, dry_run: bool) -> Result<()> {
    let job_ids = parse_job_ids(ids)?;

    if dry_run {
        perform_dry_run(client, &job_ids).await?;
    } else {
        for job_id in &job_ids {
            client.cancel_job(*job_id).await?;
            println!("Job {} cancelled.", job_id);
        }
    }

    Ok(())
}

async fn perform_dry_run(client: &Client, job_ids: &[u32]) -> Result<()> {
    for &job_id in job_ids {
        let job = client
            .get_job(job_id)
            .await?
            .context(format!("Job {} not found", job_id))?;

        let can_cancel = job.state.can_transition_to(JobState::Cancelled);

        if can_cancel {
            println!("{}\t{}\tok", job_id, job.state);
        } else {
            println!("{}\t{}\tinvalid", job_id, job.state);
            continue;
        }

        // Find dependent jobs that would be affected
        let all_jobs = client.list_jobs().await?;
        for dep_job in all_jobs
            .iter()
            .filter(|j| j.depends_on == Some(job_id))
            .filter(|j| matches!(j.state, JobState::Queued | JobState::Hold))
        {
            println!("{}\t{}\tblocked\t{}", dep_job.id, dep_job.state, job_id);
        }
    }

    Ok(())
}