error handling

src/callers/clairs.rs

@@ -2,6 +2,7 @@ use crate::{
     commands::bcftools::{bcftools_keep_pass, BcftoolsConfig},
     runners::{run_wait, DockerRun},
 };
+use anyhow::Context;
 use std::{fs, path::Path};
 use tracing::info;
 
@@ -63,7 +64,7 @@ impl ClairS {
         }
     }
 
-    pub fn run(&mut self) {
+    pub fn run(&mut self) -> anyhow::Result<()> {
         // Create out dir
         if !Path::new(&self.output_dir).exists() {
             fs::create_dir_all(&self.output_dir).expect("Failed to create output directory");
@@ -102,10 +103,15 @@ impl ClairS {
                 "-s",
                 &format!("{}_diag", self.id),
             ]);
-            let report = run_wait(&mut docker_run).unwrap();
+            let report = run_wait(&mut docker_run).context(format!(
+                "Error while running ClairS in docker for  {} and {}",
+                &self.diag_bam, &self.mrd_bam
+            ))?;
+
+            let log_file = format!("{}/clairs_", self.log_dir);
             report
-                .save_to_file(&format!("{}/clairs_", self.log_dir))
-                .unwrap();
+                .save_to_file(&log_file)
+                .context(format!("Error while writing logs into {log_file}"))?;
         } else {
             info!("ClairS output vcf already exists");
         }
@@ -117,10 +123,13 @@ impl ClairS {
                 &self.vcf_passed,
                 BcftoolsConfig::default(),
             )
-            .unwrap();
+            .context(format!(
+                "Error while running bcftools keep PASS for {}", &self.output_vcf
+            ))?;
+            let log_file = format!("{}/bcftools_pass", self.log_dir);
             report
-                .save_to_file(&format!("{}/bcftools_pass", self.log_dir))
-                .unwrap();
+                .save_to_file(&log_file)
+                .context(format!("Error while writing logs into {log_file}"))?;
         }
         if !Path::new(&self.indel_vcf_passed).exists() {
             let report = bcftools_keep_pass(
@@ -128,10 +137,15 @@ impl ClairS {
                 &self.indel_vcf_passed,
                 BcftoolsConfig::default(),
             )
-            .unwrap();
+            .context(format!(
+                "Error while running bcftools keep PASS for {}", &self.output_indel
+            ))?;
+
+            let log_file = format!("{}/bcftools_pass", self.log_dir);
             report
-                .save_to_file(&format!("{}/bcftools_pass", self.log_dir))
-                .unwrap();
+                .save_to_file(&log_file)
+                .context(format!("Error while writing logs into {log_file}"))?;
         }
+        Ok(())
     }
 }

src/callers/deep_variant.rs

@@ -1,3 +1,4 @@
+use anyhow::Context;
 use log::info;
 use std::{fs, path::Path};
 
@@ -65,11 +66,12 @@ impl DeepVariant {
         }
     }
 
-    pub fn run(&self) {
+    pub fn run(&self) -> anyhow::Result<()> {
         // Create out dir
         if !Path::new(&self.output_dir).exists() {
             fs::create_dir_all(&self.output_dir).expect("Failed to create output directory");
         }
+
         if !Path::new(&self.log_dir).exists() {
             fs::create_dir_all(&self.log_dir).expect("Failed to create log directory");
         }
@@ -104,8 +106,13 @@ impl DeepVariant {
                 "--sample_name",
                 &format!("{}_{}", self.id, self.time_point),
             ]);
-            let report = run_wait(&mut docker_run).unwrap();
-            report.save_to_file(&format!("{}/deepvariant_", self.log_dir)).unwrap();
+            let report = run_wait(&mut docker_run).context(format!(
+                "Erreur while running DeepVariant for {} {}",
+                self.id, self.time_point
+            ))?;
+            report
+                .save_to_file(&format!("{}/deepvariant_", self.log_dir))
+                .context("Can't save DeepVariant logs")?;
         }
 
         // Keep PASS
@@ -121,5 +128,6 @@ impl DeepVariant {
                 .save_to_file(&format!("{}/bcftools_pass_", self.log_dir))
                 .unwrap();
         }
+        Ok(())
     }
 }

src/callers/nanomonsv.rs

@@ -1,5 +1,6 @@
 use std::{fs, path::Path, thread};
 
+use anyhow::Context;
 use log::info;
 
 use crate::{
@@ -56,16 +57,18 @@ impl NanomonSV {
         }
     }
 
-    pub fn run(&mut self) {
+    pub fn run(&mut self) -> anyhow::Result<()> {
         // Create direcories
         if !Path::new(&self.diag_out_dir).exists() {
-            fs::create_dir_all(&self.diag_out_dir).unwrap();
+            fs::create_dir_all(&self.diag_out_dir)
+                .context(format!("Can't create {}", &self.diag_out_dir))?;
         }
         if !Path::new(&self.mrd_out_dir).exists() {
-            fs::create_dir_all(&self.mrd_out_dir).unwrap();
+            fs::create_dir_all(&self.mrd_out_dir)
+                .context(format!("Can't create {}", &self.mrd_out_dir))?;
         }
         if !Path::new(&self.log_dir).exists() {
-            fs::create_dir_all(&self.log_dir).unwrap();
+            fs::create_dir_all(&self.log_dir).context(format!("Can't create {}", &self.log_dir))?;
         }
 
         // Parse
@@ -123,7 +126,9 @@ impl NanomonSV {
                 None,
                 self.config.clone(),
             )
-            .unwrap();
+            .context(format!(
+                "Error while running NanomonSV get for {mrd_result_vcf}"
+            ))?;
             report
                 .save_to_file(&format!("{}/nanomonsv_get_mrd_", self.log_dir))
                 .unwrap();
@@ -137,7 +142,9 @@ impl NanomonSV {
                 Some(&mrd_out_prefix),
                 self.config.clone(),
             )
-            .unwrap();
+            .context(format!(
+                "Error while running NanomonSV get for {diag_result_vcf}"
+            ))?;
             report
                 .save_to_file(&format!("{}/nanomonsv_get_diag_", self.log_dir,))
                 .unwrap();
@@ -152,6 +159,89 @@ impl NanomonSV {
                 .save_to_file(&format!("{}/bcftools_pass_", self.log_dir,))
                 .unwrap();
         }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct NanomonSVSolo {
+    pub id: String,
+    pub bam: String,
+    pub time_point: String,
+    pub out_dir: String,
+    pub log: String,
+    pub log_dir: String,
+    pub config: NanomonSVConfig,
+}
+
+impl NanomonSVSolo {
+    pub fn new(id: &str, bam: &str, time_point: &str, config: NanomonSVConfig) -> Self {
+        let out_dir = format!("{}/{id}/{time_point}/nanomonsv", &config.result_dir);
+        let log_dir = format!("{}/{id}/log/nanomonsv", &config.result_dir);
+        NanomonSVSolo {
+            id: id.to_string(),
+            bam: bam.to_string(),
+            out_dir,
+            time_point: time_point.to_string(),
+            log: String::default(),
+            log_dir,
+            config,
+        }
+    }
+
+    pub fn run(&mut self) -> anyhow::Result<()> {
+        // Create direcories
+        if !Path::new(&self.out_dir).exists() {
+            fs::create_dir_all(&self.out_dir).context(format!("Can't create {}", &self.out_dir))?;
+        }
+
+        if !Path::new(&self.log_dir).exists() {
+            fs::create_dir_all(&self.log_dir).context(format!("Can't create {}", &self.log_dir))?;
+        }
+
+        // Parse
+        info!("Nanomonsv Parse");
+        let out_prefix = format!("{}/{}_{}", self.out_dir, self.id, self.time_point);
+
+        let info_vcf = format!("{out_prefix}.bp_info.sorted.bed.gz");
+        if !Path::new(&info_vcf).exists() {
+            let report = nanomonsv_parse(&self.bam, &out_prefix, self.config.clone()).context(
+                format!("Error while running NanomonSV parse for {}", self.bam),
+            )?;
+            let log_file = format!("{}/nanomonsv_parse_{}_", self.log_dir, self.time_point);
+            report
+                .save_to_file(&log_file)
+                .context(format!("Can't write logs into {log_file}"))?;
+        }
+
+        // Get
+        info!("Nanomonsv Get");
+        let result_vcf = format!("{out_prefix}.nanomonsv.result.vcf");
+
+        if !Path::new(&result_vcf).exists() {
+            let report = nanomonsv_get(&self.bam, &out_prefix, None, None, self.config.clone())
+                .context(format!(
+                    "Error while running NanomonSV get for {result_vcf}"
+                ))?;
+            let log_file = format!("{}/nanomonsv_get_{}_", self.log_dir, self.time_point);
+            report
+                .save_to_file(&log_file)
+                .context(format!("Error while writing log into {log_file}"))?;
+        }
+
+        let vcf_passed = format!("{out_prefix}_nanomonsv_PASSED.vcf.gz");
+        if !Path::new(&vcf_passed).exists() {
+            let report = bcftools_keep_pass(&result_vcf, &vcf_passed, BcftoolsConfig::default())
+                .context(format!(
+                    "Error while running bcftools keep PASS for {result_vcf}"
+                ))?;
+
+            let log_file = format!("{}/bcftools_pass_", self.log_dir);
+            report
+                .save_to_file(&log_file)
+                .context(format!("Error while writing log into {log_file}"))?;
+        }
+        Ok(())
     }
 }
 

src/collection/mod.rs

@@ -531,10 +531,10 @@ impl CollectionsTasks {
     pub fn run(self) -> anyhow::Result<()> {
         match self {
             CollectionsTasks::Align(case) => {
-                BasecallAlign::init(case.clone(), Config::default())?.run_pipe()?;
+                BasecallAlign::init(case.clone(), Config::default())?.run_pipe()
             }
             CollectionsTasks::DemuxAlign(cases) => {
-                BasecallAlign::from_mux(cases, Config::default())?;
+                BasecallAlign::from_mux(cases, Config::default())
             }
             CollectionsTasks::DeepVariant {
                 id,
@@ -542,7 +542,7 @@ impl CollectionsTasks {
                 bam,
                 config,
             } => {
-                DeepVariant::new(&id, &time_point, &bam, config).run();
+                DeepVariant::new(&id, &time_point, &bam, config).run()
             }
             CollectionsTasks::ClairS {
                 id,
@@ -550,7 +550,7 @@ impl CollectionsTasks {
                 mrd_bam,
                 config,
             } => {
-                ClairS::new(&id, &diag_bam, &mrd_bam, config).run();
+                ClairS::new(&id, &diag_bam, &mrd_bam, config).run()
             }
             CollectionsTasks::NanomonSV {
                 id,
@@ -558,7 +558,7 @@ impl CollectionsTasks {
                 mrd_bam,
                 config,
             } => {
-                NanomonSV::new(&id, &diag_bam, &mrd_bam, config).run();
+                NanomonSV::new(&id, &diag_bam, &mrd_bam, config).run()
             }
             CollectionsTasks::WholeScan {
                 id,
@@ -566,20 +566,19 @@ impl CollectionsTasks {
                 bam,
                 config,
             } => {
-                WholeScan::new(id, time_point, bam, config)?.run()?;
+                WholeScan::new(id, time_point, bam, config)?.run()
             }
             CollectionsTasks::Variants { id, config } => {
-                Variants::new(id, config).run()?;
+                Variants::new(id, config).run()
             }
             CollectionsTasks::Assemble {
                 id,
                 time_point,
                 config,
             } => {
-                Assembler::new(id, time_point, config).run()?;
+                Assembler::new(id, time_point, config).run()
             }
         }
-        Ok(())
     }
 
     pub fn get_order(&self) -> u8 {

src/lib.rs

@@ -116,8 +116,7 @@ mod tests {
             result_dir: "/data/test".to_string(),
             ..DeepVariantConfig::default()
         };
-        DeepVariant::new("test_a", "diag", "/data/test_data/subset.bam", config).run();
-        Ok(())
+        DeepVariant::new("test_a", "diag", "/data/test_data/subset.bam", config).run()
     }
 
     #[test_log::test]
@@ -126,8 +125,7 @@ mod tests {
             result_dir: "/data/test".to_string(),
             ..ClairSConfig::default()
         };
-        ClairS::new("test_a", "/data/test_data/subset.bam", "/data/test_data/subset_mrd.bam", config).run();
-        Ok(())
+        ClairS::new("test_a", "/data/test_data/subset.bam", "/data/test_data/subset_mrd.bam", config).run()
     }
 
     #[test_log::test]
@@ -136,8 +134,7 @@ mod tests {
             result_dir: "/data/test".to_string(),
             ..NanomonSVConfig::default()
         };
-        NanomonSV::new("test_a", "/data/test_data/subset.bam", "/data/test_data/subset_mrd.bam", config).run();
-        Ok(())
+        NanomonSV::new("test_a", "/data/test_data/subset.bam", "/data/test_data/subset_mrd.bam", config).run()
     }
 
     // cargo test run -- --nocapture; ~/run_scripts/notify_finish.sh &