1 files changed, 77 insertions, 0 deletions
diff --git a/libangelshark/src/runner.rs b/libangelshark/src/runner.rs
new file mode 100644
index 0000000..6d41bd2
--- /dev/null
+++ b/libangelshark/src/runner.rs
@@ -0,0 +1,77 @@
+use crate::{Acm, Message};
+use anyhow::Result;
+use rayon::iter::IntoParallelIterator;
+pub use rayon::iter::ParallelIterator;
+use std::collections::HashMap;
+
+/// Allows for more convenient running of OSSI [Message]s on one or more [Acm]s,
+/// parallelizing over the ACMs and (optionally) caching results for faster future runs.
+///
+/// This is the intended high-level use of Angelshark. It holds a collection of
+/// "jobs", which are tagged with ACM names/labels and their associated logins ([Acm]s) and [Message]s).
+#[derive(Default, Debug, Clone)]
+pub struct AcmRunner(HashMap<String, (Acm, Vec<Message>)>);
+
+impl AcmRunner {
+    /// Constructs a new [AcmRunner] from tagged [Acm]s and [Message]s.
+    pub fn new(acms: Vec<(String, Acm)>, inputs: Vec<(String, Message)>) -> Self {
+        let mut runner = AcmRunner::default();
+        for (name, acm) in acms {
+            runner.register_acm(&name, acm);
+        }
+        for (name, input) in inputs {
+            runner.queue_input(&name, &input);
+        }
+        runner
+    }
+
+    /// Registers an [Acm] as `job_name` in the runner.
+    pub fn register_acm(&mut self, job_name: &str, acm: Acm) -> &mut Self {
+        self.0.insert(job_name.into(), (acm, Vec::new()));
+        self
+    }
+
+    /// Queues a [Message] to be run on an [Acm] registered as `job_name`.
+    pub fn queue_input(&mut self, job_name: &str, input: &Message) -> &mut Self {
+        if let Some((_, inputs)) = self.0.get_mut(job_name) {
+            inputs.push(input.clone());
+        }
+        self
+    }
+
+    /// Runs the queued [Message] inputs on the registered [Acm]s and returns
+    /// the results. The results are returned as an iterator. The iterator must
+    /// be in some way consumed, collected, or iterated over before the runner
+    /// starts running commands, i.e. it is lazy. Once this begins, results are
+    /// computed in parallel over the ACMs. The order of outputs is undefined.
+    pub fn run(self) -> impl ParallelIterator<Item = RunOutput> {
+        self.0
+            .into_par_iter()
+            .filter(|(_, (_, inputs))| !inputs.is_empty())
+            .map(|(job_name, (acm, inputs))| (job_name, acm.run(&inputs)))
+    }
+
+    /// Functionally equivalent to [Self::run] but caches results for 30 minutes
+    /// to make future lookups faster.
+    pub fn run_cached(self) -> impl ParallelIterator<Item = RunOutput> {
+        self.0
+            .into_par_iter()
+            .filter(|(_, (_, inputs))| !inputs.is_empty())
+            .map(|(job_name, (acm, inputs))| (job_name, acm.run_cached(&inputs)))
+    }
+
+    /// Functionally equivalent to [Self::run] but returns manual pages for
+    /// inputs instead of executing them.
+    pub fn manuals(self) -> impl ParallelIterator<Item = ManualOutput> {
+        self.0
+            .into_par_iter()
+            .filter(|(_, (_, inputs))| !inputs.is_empty())
+            .map(|(job_name, (acm, inputs))| (job_name, acm.manual(&inputs)))
+    }
+}
+
+/// Every resulting entry of [AcmRunner::run]
+pub type RunOutput = (String, Result<Vec<Message>>);
+
+/// Every resulting entry of [AcmRunner::manuals]
+pub type ManualOutput = (String, Result<String>);