Use same struct for InputHash and to pass task data to the runner

3 files changed, 34 insertions, 43 deletions

diff --git a/src/executor.rs b/src/executor.rs
index 39a7cc9..8b7965f 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -19,22 +19,11 @@ const BASE_ARGS: &[(&str, &str)] = &[
 	("destdir", "/build/dest"),
 ];
 
-#[derive(Clone, Debug, Serialize)]
-struct TaskInput<'ctx> {
-	pub inherit: Option<&'ctx InputHash>,
-	pub depends: &'ctx HashMap<DependencyHash, Dependency>,
-	pub output: &'ctx HashMap<String, String>,
-	pub command: &'ctx str,
+fn input_hash(task: &runner::TaskInput) -> InputHash {
+	InputHash(StringHash(
+		cjson::digest::<InputHasher, _>(task).unwrap().into(),
+	))
 }
-
-impl<'ctx> TaskInput<'ctx> {
-	fn input_hash(&self) -> InputHash {
-		InputHash(StringHash(
-			cjson::digest::<InputHasher, _>(self).unwrap().into(),
-		))
-	}
-}
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 struct TaskMeta {
 	pub id: TaskID,
@@ -167,15 +156,14 @@ impl<'ctx> Executor<'ctx> {
 			})
 			.collect();
 
-		let (inherit_chain, inherit_hash) =
-			if let Some(inherit_dep) = self.ctx.get_inherit_depend(task_ref) {
+		let inherit_chain = self
+			.ctx
+			.get_inherit_depend(task_ref)
+			.map(|inherit_dep| {
 				let inherit_meta = &self.tasks_done[&inherit_dep];
-				let mut inherit_chain = inherit_meta.inherit.clone();
-				inherit_chain.push(inherit_meta.input_hash);
-				(inherit_chain, Some(&inherit_meta.input_hash))
-			} else {
-				(Vec::new(), None)
-			};
+				[inherit_meta.inherit.as_slice(), &[inherit_meta.input_hash]].concat()
+			})
+			.unwrap_or_default();
 
 		let command = self
 			.eval_command(&task_def, &task_ref.args)
@@ -183,13 +171,13 @@ impl<'ctx> Executor<'ctx> {
 				format!("Failed to evaluate command template for task {}", task_ref)
 			})?;
 
-		let input_hash = TaskInput {
-			inherit: inherit_hash,
-			depends: &task_deps,
-			output: &task_output,
-			command: &command,
-		}
-		.input_hash();
+		let input = runner::TaskInput {
+			command,
+			inherit: inherit_chain,
+			depends: task_deps,
+			output: task_output,
+		};
+		let input_hash = input_hash(&input);
 
 		// Use cached result
 		if let Ok(meta) = TaskMeta::load(&input_hash) {
@@ -205,11 +193,8 @@ impl<'ctx> Executor<'ctx> {
 
 		let task = runner::Task {
 			label: format!("{}{:?}", task_ref.id, task_ref.args.0),
-			command,
+			input,
 			input_hash,
-			inherit: inherit_chain.clone(),
-			depends: task_deps.clone(),
-			output: task_output,
 		};
 
 		let output = runner.run(&task)?;
@@ -217,8 +202,8 @@ impl<'ctx> Executor<'ctx> {
 		let meta = TaskMeta {
 			id: task_ref.id.clone(),
 			args: task_ref.args.clone(),
-			inherit: inherit_chain,
-			depends: task_deps,
+			inherit: task.input.inherit,
+			depends: task.input.depends,
 			input_hash,
 			output,
 		};
diff --git a/src/runner/mod.rs b/src/runner/mod.rs
index b0b16e7..9c93adf 100644
--- a/src/runner/mod.rs
+++ b/src/runner/mod.rs
@@ -6,15 +6,20 @@ use std::collections::HashMap;
 use crate::{types::*, util::error::*};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct Task {
-	pub label: String,
+pub struct TaskInput {
 	pub command: String,
-	pub input_hash: InputHash,
 	pub inherit: Vec<InputHash>,
 	pub depends: HashMap<DependencyHash, Dependency>,
 	pub output: HashMap<String, String>,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Task {
+	pub label: String,
+	pub input: TaskInput,
+	pub input_hash: InputHash,
+}
+
 pub trait Runner {
 	fn run(&self, task: &Task) -> Result<HashMap<String, ArchiveHash>>;
 }
diff --git a/src/runner/runc/run.rs b/src/runner/runc/run.rs
index 7351849..4c356a1 100644
--- a/src/runner/runc/run.rs
+++ b/src/runner/runc/run.rs
@@ -38,7 +38,7 @@ fn init_task(task: &runner::Task) -> Result<()> {
 	]))?;
 	fs::mkdir(paths::join(&[&task_tmp_dir, paths::TASK_TMP_ROOTFS_SUBDIR]))?;
 
-	if task.inherit.is_empty() {
+	if task.input.inherit.is_empty() {
 		mount::mount::<_, _, _, str>(
 			Some(task_layer_dir.as_str()),
 			mount_target.as_str(),
@@ -49,6 +49,7 @@ fn init_task(task: &runner::Task) -> Result<()> {
 		.with_context(|| format!("Failed to bind mount to {:?}", mount_target))?;
 	} else {
 		let lower = task
+			.input
 			.inherit
 			.iter()
 			.rev()
@@ -138,7 +139,7 @@ fn unpack_dependencies(task: &runner::Task) -> Result<()> {
 
 	fs::mkdir(&downloads_dir)?;
 
-	for dep in task.depends.values() {
+	for dep in task.input.depends.values() {
 		match dep {
 			Dependency::Fetch { name, .. } => {
 				fs::copy(
@@ -200,7 +201,7 @@ fn collect_one_output(task: &runner::Task, path: &str) -> Result<Option<ArchiveH
 fn collect_output(task: &runner::Task) -> Result<HashMap<String, ArchiveHash>> {
 	let mut ret = HashMap::new();
 
-	for (name, path) in &task.output {
+	for (name, path) in &task.input.output {
 		if let Some(hash) = collect_one_output(task, path)? {
 			ret.insert(name.clone(), hash);
 		}
@@ -218,7 +219,7 @@ pub fn handle_task(task: runner::Task) -> Result<HashMap<String, ArchiveHash>> {
 
 	let task_tmp_dir = paths::task_tmp_dir(&task.input_hash);
 
-	spec::generate_spec(task.command.as_str())
+	spec::generate_spec(task.input.command.as_str())
 		.save(paths::join(&[&task_tmp_dir, "config.json"]))
 		.map_err(Error::new)
 		.context("Failed to save runtime config")?;