gflow 0.4.15

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
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
121
122
123
124
125
126
127
128

use super::cli::Commands;
use clap::CommandFactory;

pub mod attach;
pub mod close_sessions;
pub mod hold;
pub mod log;
pub mod redo;
pub mod release;
pub mod show;
pub mod update;

pub async fn handle_commands(
    config_path: &Option<std::path::PathBuf>,
    command: Commands,
) -> anyhow::Result<()> {
    match command {
        Commands::Attach { job } => {
            attach::handle_attach(config_path, &job).await?;
        }
        Commands::Log { job, first, last } => {
            log::handle_log(config_path, &job, first, last).await?;
        }
        Commands::Hold { job } => {
            hold::handle_hold(config_path, job).await?;
        }
        Commands::Release { job } => {
            release::handle_release(config_path, job).await?;
        }
        Commands::Update {
            job,
            command,
            script,
            gpus,
            conda_env,
            clear_conda_env,
            priority,
            time_limit,
            clear_time_limit,
            memory_limit,
            clear_memory_limit,
            gpu_memory_limit,
            clear_gpu_memory_limit,
            depends_on,
            depends_on_all,
            depends_on_any,
            auto_cancel_on_dep_failure,
            no_auto_cancel_on_dep_failure,
            max_concurrent,
            clear_max_concurrent,
            max_retries,
            clear_max_retries,
            params,
        } => {
            let update_params = update::UpdateJobParams {
                job_ids_str: job,
                command,
                script,
                gpus,
                conda_env,
                clear_conda_env,
                priority,
                time_limit,
                clear_time_limit,
                memory_limit,
                clear_memory_limit,
                gpu_memory_limit,
                clear_gpu_memory_limit,
                depends_on,
                depends_on_all,
                depends_on_any,
                auto_cancel_on_dep_failure,
                no_auto_cancel_on_dep_failure,
                max_concurrent,
                clear_max_concurrent,
                max_retries,
                clear_max_retries,
                params,
            };
            update::handle_update(config_path, update_params).await?;
        }
        Commands::Show { job } => {
            show::handle_show(config_path, job).await?;
        }
        Commands::Redo {
            job,
            gpus,
            priority,
            depends_on,
            time,
            memory,
            gpu_memory,
            conda_env,
            clear_deps,
            cascade,
        } => {
            redo::handle_redo(
                config_path,
                &job,
                gpus,
                priority,
                depends_on,
                time,
                memory,
                gpu_memory,
                conda_env,
                clear_deps,
                cascade,
            )
            .await?;
        }
        Commands::CloseSessions {
            jobs,
            state,
            pattern,
            all,
        } => {
            close_sessions::handle_close_sessions(config_path, &jobs, &state, &pattern, all)
                .await?;
        }
        Commands::Completion { shell } => {
            let mut cmd = super::cli::GJob::command();
            let _ = crate::multicall::completion::generate_to_stdout(shell, &mut cmd, "gjob");
        }
    }

    Ok(())
}