inherit parents requirements correclty

Author: JensKrumsieck

CHANGELOG.md

@@ -7,7 +7,8 @@
 ## 🐛 Bugfixes
 - fixed a bug with Dockerfile path resolution
 - handle NetworkAccess Requirment in runner
-- ramping up runner conformance from 160/378 to 179/378
+- inherit parents requirements correclty
+- ramping up runner conformance from 160/378 to 183/378
 
 # v0.5.2
 ## 🐛 Bugfixes

crates/cwl-execution/src/environment.rs

@@ -1,7 +1,9 @@
-use crate::{get_available_disk_space, get_available_ram, get_processor_count, util::evaluate_input, validate::set_placeholder_values_in_string};
+use crate::{
+    get_available_disk_space, get_available_ram, get_processor_count, util::evaluate_input, validate::set_placeholder_values_in_string, InputObject,
+};
 use cwl::{
     inputs::CommandInputParameter,
-    requirements::{check_timelimit, EnvVarRequirement, NetworkAccess, ResourceRequirement},
+    requirements::{EnvVarRequirement, NetworkAccess, ResourceRequirement, ToolTimeLimit},
     types::{DefaultValue, EnviromentDefs},
     CWLDocument, StringOrNumber,
 };
@@ -42,7 +44,7 @@ impl RuntimeEnvironment {
 
     pub fn initialize(
         tool: &CWLDocument,
-        input_values: HashMap<String, DefaultValue>,
+        input_values: &InputObject,
         outdir: impl AsRef<Path>,
         tooldir: impl AsRef<Path>,
         tmpdir: impl AsRef<Path>,
@@ -68,23 +70,23 @@ impl RuntimeEnvironment {
 
         runtime.insert(
             "network".to_string(),
-            if tool.get_requirement::<NetworkAccess>().is_some() {
+            if input_values.get_requirement::<NetworkAccess>().is_some() {
                 StringOrNumber::Integer(1)
             } else {
                 StringOrNumber::Integer(0)
             },
         );
 
-        let inputs = collect_inputs(tool, input_values, tooldir)?;
+        let inputs = collect_inputs(tool, &input_values.inputs, tooldir)?;
 
         let mut environment = RuntimeEnvironment {
             runtime,
-            time_limit: check_timelimit(tool).unwrap_or(0),
+            time_limit: input_values.get_requirement::<ToolTimeLimit>().map(|tt| tt.timelimit).unwrap_or(0),
             inputs,
             ..Default::default()
         };
 
-        if let Some(rr) = tool.get_requirement::<ResourceRequirement>() {
+        if let Some(rr) = input_values.get_requirement::<ResourceRequirement>() {
             if let Some(cores) = &rr.cores_min {
                 environment
                     .runtime
@@ -121,8 +123,8 @@ fn evaluate(val: &StringOrNumber, runtime: &RuntimeEnvironment, inputs: &[Comman
     }
 }
 
-pub(crate) fn collect_environment(tool: &CWLDocument) -> HashMap<String, String> {
-    if let Some(env) = tool.get_requirement::<EnvVarRequirement>() {
+pub(crate) fn collect_environment(input_values: &InputObject) -> HashMap<String, String> {
+    if let Some(env) = input_values.get_requirement::<EnvVarRequirement>() {
         match &env.env_def {
             EnviromentDefs::Vec(vec) => vec.iter().map(|i| (i.env_name.clone(), i.env_value.clone())).collect::<HashMap<_, _>>(),
             EnviromentDefs::Map(map) => map.clone(),
@@ -134,12 +136,12 @@ pub(crate) fn collect_environment(tool: &CWLDocument) -> HashMap<String, String>
 
 pub(crate) fn collect_inputs(
     tool: &CWLDocument,
-    input_values: HashMap<String, DefaultValue>,
+    input_values: &HashMap<String, DefaultValue>,
     tool_dir: impl AsRef<Path>,
 ) -> Result<HashMap<String, DefaultValue>, Box<dyn Error>> {
     let mut inputs = HashMap::new();
     for input in &tool.inputs {
-        let mut result_input = evaluate_input(input, &input_values)?;
+        let mut result_input = evaluate_input(input, input_values)?;
         if let DefaultValue::File(f) = &mut result_input {
             if input.load_contents {
                 f.contents = Some(fs::read_to_string(f.location.as_ref().expect("Could not read file"))?);
@@ -157,7 +159,7 @@ pub(crate) fn collect_inputs(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cwl::{clt::CommandLineTool, requirements::{EnvVarRequirement, Requirement}};
+    use cwl::requirements::{EnvVarRequirement, Requirement};
 
     #[test]
     fn test_requirements_overwrite_hints() {
@@ -167,12 +169,13 @@ mod tests {
         let requirement = EnvVarRequirement {
             env_def: EnviromentDefs::Map(HashMap::from([("MY_ENV".to_string(), "REQUIREMENT".to_string())])),
         };
+        let input_values = InputObject {
+            requirements: vec![Requirement::EnvVarRequirement(requirement.clone())],
+            hints: vec![Requirement::EnvVarRequirement(hint.clone())],
+            ..Default::default()
+        };
 
-        let tool = CommandLineTool::default()
-            .with_requirements(vec![Requirement::EnvVarRequirement(requirement)])
-            .with_hints(vec![Requirement::EnvVarRequirement(hint)]);
-
-        let environment = collect_environment(&CWLDocument::CommandLineTool(tool));
+        let environment = collect_environment(&input_values);
 
         assert_eq!(environment["MY_ENV"], "REQUIREMENT".to_string())
     }

crates/cwl-execution/src/expression.rs

@@ -1,4 +1,4 @@
-use crate::{environment::RuntimeEnvironment, split_ranges};
+use crate::{environment::RuntimeEnvironment, split_ranges, InputObject};
 use cwl::{
     clt::{Argument, Command},
     et::{Expression, ExpressionType},
@@ -182,22 +182,20 @@ pub(crate) fn parse_expressions(input: &str) -> Vec<Expression> {
     expressions
 }
 
-pub(crate) fn process_tool_expressions(tool: &mut CWLDocument) -> Result<(), Box<dyn Error>> {
-    if let Some(requirements) = &mut tool.requirements {
-        for requirement in requirements {
-            if let Requirement::InitialWorkDirRequirement(wd_req) = requirement {
-                for listing in &mut wd_req.listing {
-                    if let WorkDirItem::Dirent(dirent) = listing {
-                        dirent.entryname = replace_expressions(&dirent.entryname)?;
-                        dirent.entry = match &mut dirent.entry {
-                            Entry::Source(src) => {
-                                *src = replace_expressions(src)?;
-                                Entry::Source(src.clone())
-                            }
-                            Entry::Include(include) => {
-                                include.include = replace_expressions(&include.include)?;
-                                Entry::Include(include.clone())
-                            }
+pub(crate) fn process_expressions(tool: &mut CWLDocument, input_values: &mut InputObject) -> Result<(), Box<dyn Error>> {
+    for requirement in &mut input_values.requirements {
+        if let Requirement::InitialWorkDirRequirement(wd_req) = requirement {
+            for listing in &mut wd_req.listing {
+                if let WorkDirItem::Dirent(dirent) = listing {
+                    dirent.entryname = replace_expressions(&dirent.entryname)?;
+                    dirent.entry = match &mut dirent.entry {
+                        Entry::Source(src) => {
+                            *src = replace_expressions(src)?;
+                            Entry::Source(src.clone())
+                        }
+                        Entry::Include(include) => {
+                            include.include = replace_expressions(&include.include)?;
+                            Entry::Include(include.clone())
                         }
                     }
                 }
@@ -352,7 +350,8 @@ stderr: $(inputs.dirname)/stderr
         };
         prepare_expression_engine(&runtime).unwrap();
         let mut tool: CWLDocument = serde_yaml::from_str(tool).unwrap();
-        process_tool_expressions(&mut tool).unwrap();
+        let mut input_values = InputObject::default();
+        process_expressions(&mut tool, &mut input_values).unwrap();
         reset_expression_engine().unwrap();
 
         assert!(matches!(tool, CWLDocument::CommandLineTool(_)));

crates/cwl-execution/src/lib.rs

@@ -6,38 +6,43 @@ pub mod staging;
 pub mod util;
 pub mod validate;
 
+use cwl::requirements::{FromRequirement, Requirement};
 use cwl::types::{guess_type, CWLType, DefaultValue, Directory, File, PathItem};
 use cwl::CWLDocument;
 use io::preprocess_path_join;
 use runner::{run_tool, run_workflow};
+use serde::{Deserialize, Serialize};
 use serde_yaml::Value;
 use std::{cell::RefCell, collections::HashMap, error::Error, fmt::Display, fs, num::NonZero, path::Path, process::Command, thread};
 use sysinfo::{Disks, MemoryRefreshKind, System};
 use util::preprocess_cwl;
 
 pub fn execute_cwlfile(cwlfile: impl AsRef<Path>, raw_inputs: &[String], outdir: Option<impl AsRef<Path>>) -> Result<(), Box<dyn Error>> {
     //gather inputs
-    let mut inputs = if raw_inputs.len() == 1 && !raw_inputs[0].starts_with('-') {
+    let mut input_values = if raw_inputs.len() == 1 && !raw_inputs[0].starts_with('-') {
         let yaml = fs::read_to_string(&raw_inputs[0])?;
         serde_yaml::from_str(&yaml).map_err(|e| format!("Could not read job file: {e}"))?
     } else {
-        raw_inputs
-            .chunks_exact(2)
-            .filter_map(|pair| {
-                if let Some(key) = pair[0].strip_prefix("--") {
-                    let raw_value = &pair[1];
-                    let value = match guess_type(raw_value) {
-                        CWLType::File => DefaultValue::File(File::from_location(raw_value)),
-                        CWLType::Directory => DefaultValue::Directory(Directory::from_location(raw_value)),
-                        CWLType::String => DefaultValue::Any(Value::String(raw_value.to_string())),
-                        _ => DefaultValue::Any(serde_yaml::from_str(raw_value).expect("Could not read input")),
-                    };
-                    Some((key.to_string(), value))
-                } else {
-                    None
-                }
-            })
-            .collect::<HashMap<_, _>>()
+        InputObject {
+            inputs: raw_inputs
+                .chunks_exact(2)
+                .filter_map(|pair| {
+                    if let Some(key) = pair[0].strip_prefix("--") {
+                        let raw_value = &pair[1];
+                        let value = match guess_type(raw_value) {
+                            CWLType::File => DefaultValue::File(File::from_location(raw_value)),
+                            CWLType::Directory => DefaultValue::Directory(Directory::from_location(raw_value)),
+                            CWLType::String => DefaultValue::Any(Value::String(raw_value.to_string())),
+                            _ => DefaultValue::Any(serde_yaml::from_str(raw_value).expect("Could not read input")),
+                        };
+                        Some((key.to_string(), value))
+                    } else {
+                        None
+                    }
+                })
+                .collect::<HashMap<_, _>>(),
+            ..Default::default()
+        }
     };
 
     fn correct_path<T: PathItem>(item: &mut T, path_prefix: &Path) {
@@ -69,15 +74,15 @@ pub fn execute_cwlfile(cwlfile: impl AsRef<Path>, raw_inputs: &[String], outdir:
     } else {
         Path::new(".")
     };
-    for value in inputs.values_mut() {
+    for value in input_values.inputs.values_mut() {
         match value {
             DefaultValue::File(file) => correct_path(file, path_prefix),
             DefaultValue::Directory(directory) => correct_path(directory, path_prefix),
             _ => (),
         }
     }
 
-    let output_values = execute(cwlfile, inputs, outdir, None)?;
+    let output_values = execute(cwlfile, input_values, outdir, None)?;
     let json = serde_json::to_string_pretty(&output_values)?;
     println!("{json}");
 
@@ -86,7 +91,7 @@ pub fn execute_cwlfile(cwlfile: impl AsRef<Path>, raw_inputs: &[String], outdir:
 
 pub fn execute(
     cwlfile: impl AsRef<Path>,
-    inputs: HashMap<String, DefaultValue>,
+    input_values: InputObject,
     outdir: Option<impl AsRef<Path>>,
     cwl_doc: Option<&CWLDocument>,
 ) -> Result<HashMap<String, DefaultValue>, Box<dyn Error>> {
@@ -102,19 +107,67 @@ pub fn execute(
     match doc {
         CWLDocument::CommandLineTool(_) | CWLDocument::ExpressionTool(_) => run_tool(
             &mut doc,
-            inputs,
+            input_values,
             Some(&cwlfile.as_ref().to_path_buf()),
             outdir.map(|d| d.as_ref().to_string_lossy().into_owned()),
         ),
         CWLDocument::Workflow(mut workflow) => run_workflow(
             &mut workflow,
-            inputs,
+            input_values,
             Some(&cwlfile.as_ref().to_path_buf()),
             outdir.map(|d| d.as_ref().to_string_lossy().into_owned()),
         ),
     }
 }
 
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
+pub struct InputObject {
+    #[serde(flatten)]
+    pub inputs: HashMap<String, DefaultValue>,
+    #[serde(rename = "cwl:requirements")]
+    #[serde(default)]
+    pub requirements: Vec<Requirement>,
+    #[serde(rename = "cwl:hints")]
+    #[serde(default)]
+    pub hints: Vec<Requirement>,
+}
+
+impl InputObject {
+    pub fn get_requirement<T>(&self) -> Option<&T>
+    where
+        Requirement: FromRequirement<T>,
+    {
+        self.requirements.iter().chain(self.hints.iter()).find_map(|req| Requirement::get(req))
+    }
+
+    pub fn add_requirement(&mut self, requirement: &Requirement) {
+        if self
+            .requirements
+            .iter()
+            .any(|r| std::mem::discriminant(r) == std::mem::discriminant(requirement))
+        {
+            return;
+        }
+        self.requirements.push(requirement.clone());
+    }
+
+    pub fn add_hint(&mut self, hint: &Requirement) {
+        if self.hints.iter().any(|r| std::mem::discriminant(r) == std::mem::discriminant(hint)) {
+            return;
+        }
+        self.hints.push(hint.clone());
+    }
+}
+
+impl From<HashMap<String, DefaultValue>> for InputObject {
+    fn from(inputs: HashMap<String, DefaultValue>) -> Self {
+        Self {
+            inputs,
+            ..Default::default()
+        }
+    }
+}
+
 pub trait ExitCode {
     fn exit_code(&self) -> i32;
 }