stama 1.1.1

A terminal user interface for monitoring and managing slurm jobs.
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
129
130
131

use serde::{Deserialize, Serialize};

/// This module contains the SallocEntry struct, which is used to store the
/// paramters for the salloc command.
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct SallocEntry {
    pub preset_name: String,
    pub account: String,
    pub partition: String,
    pub nodes: String,
    pub cpus_per_node: String,
    pub memory: String,
    pub time_limit: String,
    pub other_options: String,
}

// ====================================================================
//  CONSTRUCTOR
// ====================================================================

impl SallocEntry {
    /// Create a new SallocEntry with default values.
    pub fn new() -> Self {
        SallocEntry {
            preset_name: "new".to_string(), // "new" is the default preset name
            account: String::new(),
            partition: String::new(),
            nodes: String::new(),
            cpus_per_node: String::new(),
            memory: String::new(),
            time_limit: "01:00:00".to_string(),
            other_options: String::new(),
        }
    }
}

impl Default for SallocEntry {
    fn default() -> Self {
        Self::new()
    }
}

// ====================================================================
//  METHODS
// ====================================================================

impl SallocEntry {
    /// Start the salloc command with the parameters
    /// stored in this SallocEntry.
    pub fn start(&self) -> String {
        let mut cmd = "salloc".to_string();
        if !self.account.is_empty() {
            cmd.push_str(&format!(" --account={}", self.account));
        }
        if !self.partition.is_empty() {
            cmd.push_str(&format!(" --partition={}", self.partition));
        }
        if !self.nodes.is_empty() {
            cmd.push_str(&format!(" -N {}", self.nodes));
        }
        if !self.cpus_per_node.is_empty() {
            cmd.push_str(&format!(" --ntasks-per-node={}", self.cpus_per_node));
        }
        if !self.memory.is_empty() {
            cmd.push_str(&format!(" --mem={}", self.memory));
        }
        if !self.time_limit.is_empty() {
            cmd.push_str(&format!(" --time={}", self.time_limit));
        }
        if !self.other_options.is_empty() {
            cmd.push_str(&format!(" {}", self.other_options));
        }
        if !self.preset_name.is_empty() {
            cmd.push_str(&format!(" --job-name={}", self.preset_name));
        }
        cmd
    }
}

// ====================================================================
//  TESTS
// ====================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn test_start_default_entry() {
        // a default entry only has a preset name ("new")
        // and a time limit ("01:00:00")
        let entry = SallocEntry::new();
        assert_eq!(entry.start(), "salloc --time=01:00:00 --job-name=new");
    }

    #[test]
    fn test_start_all_fields_set() {
        let entry = SallocEntry {
            preset_name: "myjob".to_string(),
            account: "acct".to_string(),
            partition: "gpu".to_string(),
            nodes: "2".to_string(),
            cpus_per_node: "8".to_string(),
            memory: "16G".to_string(),
            time_limit: "02:30:00".to_string(),
            other_options: "--exclusive".to_string(),
        };
        assert_eq!(
            entry.start(),
            "salloc --account=acct --partition=gpu -N 2 \
             --ntasks-per-node=8 --mem=16G --time=02:30:00 \
             --exclusive --job-name=myjob"
        );
    }

    #[test]
    fn test_start_empty_optional_fields() {
        let entry = SallocEntry {
            preset_name: String::new(),
            account: String::new(),
            partition: String::new(),
            nodes: String::new(),
            cpus_per_node: String::new(),
            memory: String::new(),
            time_limit: String::new(),
            other_options: String::new(),
        };
        assert_eq!(entry.start(), "salloc");
    }
}