add filtering jobs by status in cli

Panaetius · Panaetius · commit 70b23ef9ec53 · 2026-03-23T12:45:37.000+01:00
diff --git a/coman/src/cli/app.rs b/coman/src/cli/app.rs
@@ -15,7 +15,7 @@ use crate::{
     cscs::{
         api_client::{
             client::{EdfSpec as EdfSpecEnum, ScriptSpec as ScriptSpecEnum},
-            types::PathType,
+            types::{JobStatus, PathType},
         },
         handlers::{cscs_file_list, cscs_job_list, file_system_roots},
     },
@@ -239,7 +239,10 @@ impl FromStr for JobIdOrName {
 #[derive(Subcommand, Debug)]
 pub enum CscsJobCommands {
     #[clap(alias("ls"), about = "List all jobs [aliases: ls]")]
-    List,
+    List {
+        #[clap(short,long,help="filter by job status (separated by ',', [running, pending, finished, cancelled, failed, timeout, requeued])", value_delimiter=',', num_args=1.., value_enum)]
+        status: Option<Vec<JobStatus>>,
+    },
     #[clap(alias("g"), about = "Get metadata for a specific job [aliases: g]")]
     Get {
         #[arg(help="id or name of the job (name uses newest job of that name)", add = ArgValueCompleter::new(job_id_or_name_completer))]
@@ -330,7 +333,7 @@ fn job_id_or_name_completer(current: &std::ffi::OsStr) -> Vec<CompletionCandidat
     match jn {
         JobIdOrName::Id(id) => {
             tokio::spawn(async move {
-                let jobs = cscs_job_list(None, None).await.unwrap();
+                let jobs = cscs_job_list(None, None, None).await.unwrap();
                 let partial_id = id.to_string();
                 let ids: Vec<_> = jobs
                     .iter()
@@ -345,7 +348,7 @@ fn job_id_or_name_completer(current: &std::ffi::OsStr) -> Vec<CompletionCandidat
         }
         JobIdOrName::Name(name) => {
             tokio::spawn(async move {
-                let jobs = cscs_job_list(None, None).await.unwrap();
+                let jobs = cscs_job_list(None, None, None).await.unwrap();
                 let names: Vec<_> = jobs
                     .into_iter()
                     .map(|j| j.name)
diff --git a/coman/src/cscs/api_client/client.rs b/coman/src/cscs/api_client/client.rs
@@ -20,7 +20,7 @@ use reqwest::Url;
 
 use crate::{
     config::{ComputePlatform, Config},
-    cscs::api_client::types::{FileStat, Job, JobDetail, JobId, PathEntry, S3Upload, System, UserInfo},
+    cscs::api_client::types::{FileStat, Job, JobDetail, JobId, JobStatus, PathEntry, S3Upload, System, UserInfo},
     trace_dbg,
     util::types::DockerImageUrl,
 };
@@ -110,14 +110,23 @@ impl CscsApi {
             .wrap_err("couldn't list CSCS systems")?;
         Ok(result.systems.into_iter().map(|s| s.into()).collect())
     }
-    pub async fn list_jobs(&self, system_name: &str, all_users: Option<bool>) -> Result<Vec<Job>> {
+    pub async fn list_jobs(
+        &self,
+        status: Option<Vec<JobStatus>>,
+        system_name: &str,
+        all_users: Option<bool>,
+    ) -> Result<Vec<Job>> {
         let result = get_compute_system_jobs(&self.client, system_name, all_users)
             .await
             .wrap_err("couldn't fetch cscs jobs")?;
-        Ok(result
+        let mut result: Vec<Job> = result
             .jobs
             .map(|jobs| jobs.into_iter().map(|j| j.into()).collect())
-            .unwrap_or(vec![]))
+            .unwrap_or(vec![]);
+        if let Some(filter) = status {
+            result.retain(|j| filter.contains(&j.status));
+        }
+        Ok(result)
     }
     pub async fn get_job(&self, system_name: &str, job_id: JobId) -> Result<Option<JobDetail>> {
         let jobs = get_compute_system_job(&self.client, system_name, job_id.clone().into_string())
@@ -263,6 +272,7 @@ mod tests {
     use injectorpp::interface::injector::*;
 
     use super::*;
+    use crate::cscs::api_client::types::JobStatus as ApiJobStatus;
 
     fn get_client() -> CscsApi {
         CscsApi {
@@ -409,8 +419,24 @@ mod tests {
                     }),
                     Result<GetJobResponse>
                 ));
-            let result = client.list_jobs("daint", None).await;
+            let result = client.list_jobs(None, "daint", None).await;
             assert_eq!(result.unwrap().len(), 5);
+            let result = client
+                .list_jobs(Some(vec![ApiJobStatus::Running, ApiJobStatus::Pending]), "daint", None)
+                .await;
+            assert_eq!(result.unwrap().len(), 2);
+            let result = client
+                .list_jobs(
+                    Some(vec![
+                        ApiJobStatus::Failed,
+                        ApiJobStatus::Finished,
+                        ApiJobStatus::Cancelled,
+                    ]),
+                    "daint",
+                    None,
+                )
+                .await;
+            assert_eq!(result.unwrap().len(), 3);
         }
     }
 
diff --git a/coman/src/cscs/api_client/types.rs b/coman/src/cscs/api_client/types.rs
@@ -192,7 +192,7 @@ pub enum JobStatus {
 }
 impl From<String> for JobStatus {
     fn from(value: String) -> Self {
-        match value.split_whitespace().next().unwrap() {
+        match value.split_whitespace().next().unwrap().to_uppercase().as_str() {
             "RUNNING" => JobStatus::Running,
             "FAILED" => JobStatus::Failed,
             "COMPLETED" => JobStatus::Finished,
diff --git a/coman/src/cscs/cli.rs b/coman/src/cscs/cli.rs
@@ -71,8 +71,12 @@ pub(crate) async fn cli_cscs_login() -> Result<()> {
     }
     Ok(())
 }
-pub(crate) async fn cli_cscs_job_list(system: Option<String>, platform: Option<ComputePlatform>) -> Result<()> {
-    match cscs_job_list(system, platform).await {
+pub(crate) async fn cli_cscs_job_list(
+    status: Option<Vec<JobStatus>>,
+    system: Option<String>,
+    platform: Option<ComputePlatform>,
+) -> Result<()> {
+    match cscs_job_list(status, system, platform).await {
         Ok(jobs) => {
             let mut table = tabled::Table::new(jobs);
             table.with(tabled::settings::Style::modern());
@@ -90,7 +94,7 @@ async fn maybe_job_id_from_name(
 ) -> Result<JobId> {
     match j {
         JobIdOrName::Id(id) => Ok(id.into()),
-        JobIdOrName::Name(name) => match cscs_job_list(system, platform).await {
+        JobIdOrName::Name(name) => match cscs_job_list(None, system, platform).await {
             Ok(jobs) => {
                 let job = jobs
                     .iter()
diff --git a/coman/src/cscs/handlers.rs b/coman/src/cscs/handlers.rs
@@ -136,13 +136,17 @@ pub async fn cscs_system_set(system_name: String, global: bool) -> Result<()> {
     config.set("cscs.current_system", system_name, global)
 }
 
-pub async fn cscs_job_list(system: Option<String>, platform: Option<ComputePlatform>) -> Result<Vec<Job>> {
+pub async fn cscs_job_list(
+    status: Option<Vec<JobStatus>>,
+    system: Option<String>,
+    platform: Option<ComputePlatform>,
+) -> Result<Vec<Job>> {
     match get_access_token().await {
         Ok(access_token) => {
             let api_client = CscsApi::new(access_token.0, platform).unwrap();
             let config = Config::new().unwrap();
             api_client
-                .list_jobs(&system.unwrap_or(config.values.cscs.current_system), None)
+                .list_jobs(status, &system.unwrap_or(config.values.cscs.current_system), None)
                 .await
         }
         Err(e) => Err(e),
@@ -367,7 +371,7 @@ async fn garbage_collect_ssh(api_client: &CscsApi, current_system: &str) -> Resu
     if !data_dir.exists() {
         return Ok(());
     }
-    let jobs = api_client.list_jobs(current_system, None).await?;
+    let jobs = api_client.list_jobs(None, current_system, None).await?;
     let job_entries: HashSet<_> = jobs
         .iter()
         .filter(|j| j.status == JobStatus::Pending || j.status == JobStatus::Running || j.status == JobStatus::Requeued)
diff --git a/coman/src/cscs/ports.rs b/coman/src/cscs/ports.rs
@@ -113,7 +113,7 @@ impl AsyncFetchWorkloadsPort {
 #[tuirealm::async_trait]
 impl PollAsync<UserEvent> for AsyncFetchWorkloadsPort {
     async fn poll(&mut self) -> ListenerResult<Option<Event<UserEvent>>> {
-        match cscs_job_list(None, None).await {
+        match cscs_job_list(None, None, None).await {
             Ok(jobs) => Ok(Some(Event::User(UserEvent::Cscs(CscsEvent::GotWorkloadData(jobs))))),
             Err(e) => {
                 let _ = trace_dbg!(e);
diff --git a/coman/src/main.rs b/coman/src/main.rs
@@ -107,7 +107,7 @@ async fn main() -> Result<()> {
             } => match cscs_command {
                 CscsCommands::Login => cli_cscs_login().await?,
                 CscsCommands::Job { command } => match command {
-                    CscsJobCommands::List => cli_cscs_job_list(system, platform).await?,
+                    CscsJobCommands::List { status } => cli_cscs_job_list(status, system, platform).await?,
                     CscsJobCommands::Get { job } => cli_cscs_job_detail(job, system, platform).await?,
                     CscsJobCommands::Log { job, stderr } => cli_cscs_job_log(job, stderr, system, platform).await?,
                     CscsJobCommands::Submit {

Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ pub enum JobStatus {`
`192`	`192`	`}`
`193`	`193`	`impl From<String> for JobStatus {`
`194`	`194`	`fn from(value: String) -> Self {`
`195`		`- match value.split_whitespace().next().unwrap() {`
	`195`	`+ match value.split_whitespace().next().unwrap().to_uppercase().as_str() {`
`196`	`196`	`"RUNNING" => JobStatus::Running,`
`197`	`197`	`"FAILED" => JobStatus::Failed,`
`198`	`198`	`"COMPLETED" => JobStatus::Finished,`