gflow 0.4.13

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

use anyhow::Result;
use clap::CommandFactory;
use gflow::client::Client;
use gflow::config::Config;

pub mod reserve_cancel;
pub mod reserve_create;
pub mod reserve_get;
pub mod reserve_list;
pub mod set_gpus;
pub mod set_group_max_concurrency;
pub mod show_gpus;

use super::cli;

pub async fn handle_commands(
    client: &Client,
    config: &Config,
    command: cli::Commands,
) -> Result<()> {
    match command {
        cli::Commands::SetGpus { gpu_spec } => {
            set_gpus::handle_set_gpus(client, &gpu_spec).await?;
        }
        cli::Commands::ShowGpus => {
            show_gpus::handle_show_gpus(client).await?;
        }
        cli::Commands::SetLimit {
            job_or_group_id,
            limit,
        } => {
            set_group_max_concurrency::handle_set_group_max_concurrency(
                client,
                &job_or_group_id,
                limit,
            )
            .await?;
        }
        cli::Commands::Reserve { command } => match command {
            cli::ReserveCommands::Create {
                user,
                gpus,
                gpu_spec,
                start,
                duration,
                timezone,
            } => {
                reserve_create::handle_reserve_create(
                    client,
                    config,
                    reserve_create::ReserveCreateParams {
                        user: &user,
                        gpus: gpus.as_ref().copied(),
                        gpu_spec: gpu_spec.as_deref(),
                        start: &start,
                        duration: &duration,
                        timezone: timezone.as_deref(),
                    },
                )
                .await?;
            }
            cli::ReserveCommands::List {
                user,
                status,
                active,
                timeline,
                range,
                from,
                to,
            } => {
                reserve_list::handle_reserve_list(
                    client,
                    config,
                    user,
                    status,
                    active,
                    timeline,
                    reserve_list::TimelineRangeOpts { range, from, to },
                )
                .await?;
            }
            cli::ReserveCommands::Get { id } => {
                reserve_get::handle_reserve_get(client, config, id).await?;
            }
            cli::ReserveCommands::Cancel { id } => {
                reserve_cancel::handle_reserve_cancel(client, id).await?;
            }
        },
        cli::Commands::Completion { shell } => {
            let mut cmd = cli::GCtl::command();
            let _ = crate::multicall::completion::generate_to_stdout(shell, &mut cmd, "gctl");
        }
    }

    Ok(())
}