Introduce Context struct

TaskRef etc. get a lifetime that is bound to the Context lifetime. This
way we can reduce cloning significantly.

1 files changed, 38 insertions, 36 deletions

diff --git a/src/executor.rs b/src/executor.rs
index a953271..adf461e 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -3,8 +3,9 @@ use std::collections::{HashMap, HashSet};
 use serde::{Deserialize, Serialize};
 
 use crate::{
+	context::*,
 	paths, resolve, runner,
-	task::{self, *},
+	task::*,
 	types::*,
 	util::{cjson, error::*, fs},
 };
@@ -22,16 +23,16 @@ const TASK_ENV: &[(&str, &str)] = &[
 ];
 
 #[derive(Clone, Debug, Serialize)]
-struct TaskInput<'a> {
-	pub id: &'a TaskRef,
-	pub inherit: Option<&'a InputHash>,
-	pub depends: &'a HashMap<DependencyHash, Dependency>,
-	pub output: &'a HashMap<String, String>,
-	pub run: &'a str,
-	pub env: &'a HashMap<String, String>,
+struct TaskInput<'ctx> {
+	pub id: &'ctx TaskRef<'ctx>,
+	pub inherit: Option<&'ctx InputHash>,
+	pub depends: &'ctx HashMap<DependencyHash, Dependency>,
+	pub output: &'ctx HashMap<String, String>,
+	pub run: &'ctx str,
+	pub env: &'ctx HashMap<String, String>,
 }
 
-impl<'a> TaskInput<'a> {
+impl<'ctx> TaskInput<'ctx> {
 	fn input_hash(&self) -> InputHash {
 		InputHash(StringHash(
 			cjson::digest::<InputHasher, _>(self).unwrap().into(),
@@ -41,7 +42,7 @@ impl<'a> TaskInput<'a> {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 struct TaskMeta {
-	pub id: TaskRef,
+	pub id: TaskID,
 	pub inherit: Vec<InputHash>,
 	pub depends: HashMap<DependencyHash, Dependency>,
 	pub input_hash: InputHash,
@@ -71,24 +72,24 @@ impl TaskMeta {
 }
 
 #[derive(Debug)]
-pub struct Executor<'a> {
-	tasks: &'a TaskMap,
-	tasks_blocked: HashSet<TaskRef>,
-	tasks_runnable: Vec<TaskRef>,
-	tasks_done: HashMap<TaskRef, TaskMeta>,
-	rdeps: HashMap<TaskRef, Vec<TaskRef>>,
+pub struct Executor<'ctx> {
+	ctx: &'ctx Context,
+	tasks_blocked: HashSet<TaskRef<'ctx>>,
+	tasks_runnable: Vec<TaskRef<'ctx>>,
+	tasks_done: HashMap<TaskRef<'ctx>, TaskMeta>,
+	rdeps: HashMap<TaskRef<'ctx>, Vec<TaskRef<'ctx>>>,
 	env: HashMap<String, String>,
 }
 
-impl<'a> Executor<'a> {
-	pub fn new(tasks: &'a TaskMap, taskset: HashSet<TaskRef>) -> Result<Self> {
+impl<'ctx> Executor<'ctx> {
+	pub fn new(ctx: &'ctx Context, taskset: HashSet<TaskRef<'ctx>>) -> Result<Self> {
 		let env: HashMap<String, String> = TASK_ENV
 			.iter()
 			.map(|(k, v)| (k.to_string(), v.to_string()))
 			.collect();
 
 		let mut exc = Executor {
-			tasks,
+			ctx,
 			tasks_blocked: HashSet::new(),
 			tasks_runnable: Vec::new(),
 			tasks_done: HashMap::new(),
@@ -97,10 +98,8 @@ impl<'a> Executor<'a> {
 		};
 
 		for task in taskset {
-			let task_def = tasks.get(&task.id).expect("Invalid TaskRef");
-
 			let mut has_depends = false;
-			for dep in get_dependent_tasks(task_def) {
+			for dep in ctx.get_dependent_tasks(&task) {
 				let rdep = exc.rdeps.entry(dep.clone()).or_default();
 				rdep.push(task.clone());
 				has_depends = true;
@@ -120,30 +119,33 @@ impl<'a> Executor<'a> {
 
 	// Treats both "depends" and "inherit" as dependencies
 	fn deps_satisfied(&self, task_ref: &TaskRef) -> bool {
-		let task = self.tasks.get(&task_ref.id).expect("Invalid TaskRef");
-
-		get_dependent_tasks(task).all(|dep| self.tasks_done.contains_key(&dep))
+		self.ctx
+			.get_dependent_tasks(task_ref)
+			.into_iter()
+			.all(|dep| self.tasks_done.contains_key(&dep))
 	}
 
-	fn task_deps(&self, task: &TaskDef) -> HashMap<DependencyHash, Dependency> {
-		task.fetch
+	fn task_deps(&self, task: &TaskRef) -> HashMap<DependencyHash, Dependency> {
+		let task_def = &self.ctx[task.id];
+		task_def
+			.fetch
 			.iter()
 			.map(|Fetch { name, sha256 }| Dependency::Fetch {
 				name: name.clone(),
 				sha256: *sha256,
 			})
 			.chain(
-				resolve::runtime_depends(self.tasks, task.build_depends.iter().map(output_ref))
+				resolve::runtime_depends(self.ctx, self.ctx.get_build_depends(task))
 					.expect("invalid runtime depends of build_depends")
 					.iter()
-					.filter_map(|dep| self.tasks_done[&dep.task].output.get(&dep.output))
+					.filter_map(|dep| self.tasks_done[&dep.task].output.get(dep.output))
 					.map(|&output| Dependency::BuildTask { output }),
 			)
 			.chain(
-				resolve::runtime_depends(self.tasks, task.target_depends.iter().map(output_ref))
+				resolve::runtime_depends(self.ctx, self.ctx.get_target_depends(task))
 					.expect("invalid runtime depends of target_depends")
 					.iter()
-					.filter_map(|dep| self.tasks_done[&dep.task].output.get(&dep.output))
+					.filter_map(|dep| self.tasks_done[&dep.task].output.get(dep.output))
 					.map(|&output| Dependency::TargetTask { output }),
 			)
 			.map(|dep| (dep.dependency_hash(), dep))
@@ -151,8 +153,8 @@ impl<'a> Executor<'a> {
 	}
 
 	fn run_one(&self, task_ref: &TaskRef, runner: &impl runner::Runner) -> Result<TaskMeta> {
-		let task_def = self.tasks.get(&task_ref.id).expect("Invalid TaskRef");
-		let task_deps = self.task_deps(&task_def);
+		let task_def = &self.ctx[&task_ref.id];
+		let task_deps = self.task_deps(&task_ref);
 		let task_output = task_def
 			.output
 			.iter()
@@ -166,7 +168,7 @@ impl<'a> Executor<'a> {
 		let env = self.env.clone();
 
 		let (inherit_chain, inherit_hash) = if let Some(inherit_dep) = &task_def.inherit {
-			let inherit_meta = &self.tasks_done[&task::task_ref(&inherit_dep.task)];
+			let inherit_meta = &self.tasks_done[&self.ctx.inherit_ref(inherit_dep)];
 			let mut inherit_chain = inherit_meta.inherit.clone();
 			inherit_chain.push(inherit_meta.input_hash);
 			(inherit_chain, Some(&inherit_meta.input_hash))
@@ -197,7 +199,7 @@ impl<'a> Executor<'a> {
 		fs::mkdir(&state_dir)?;
 
 		let task = runner::Task {
-			id: task_ref.clone(),
+			id: task_ref.id.clone(),
 			run: task_def.action.run.clone(),
 			input_hash,
 			inherit: inherit_chain.clone(),
@@ -209,7 +211,7 @@ impl<'a> Executor<'a> {
 		let output = runner.run(&task)?;
 
 		let meta = TaskMeta {
-			id: task_ref.clone(),
+			id: task_ref.id.clone(),
 			inherit: inherit_chain,
 			depends: task_deps,
 			input_hash,