Introduce "fetch" task type

No actual fetching for now, fetch tasks always succeed immediately. The
runner ignores fetch tasks for unpacking.

4 files changed, 49 insertions, 19 deletions

diff --git a/examples/binutils.yml b/examples/binutils.yml
new file mode 100644
index 0000000..75cfcc9
--- /dev/null
+++ b/examples/binutils.yml
@@ -0,0 +1,11 @@
+tasks:
+  fetch:
+    fetch:
+      name: 'binutils-2.37.tar.xz'
+      sha256: '820d9724f020a3e69cb337893a0b63c2db161dadcb0e06fc11dc29eb1e84a32c'
+
+  build:
+    depends:
+      - task: 'binutils:fetch'
+    run: |
+      echo 'foo'
diff --git a/src/executor.rs b/src/executor.rs
index 35255ab..ef77c23 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -129,8 +129,11 @@ impl<'a> Executor<'a> {
 			.collect()
 	}
 
-	fn run_one(&mut self, runner: &impl runner::Runner) -> runner::Result<()> {
-		let task_ref = self.tasks_runnable.pop().expect("No runnable tasks left");
+	fn run_one(
+		&self,
+		task_ref: &TaskRef,
+		runner: &impl runner::Runner,
+	) -> runner::Result<TaskOutput> {
 		let task_def = self.tasks.get(&task_ref.id).expect("Invalid TaskRef");
 		let task_deps = self.task_deps(&task_def);
 
@@ -141,27 +144,37 @@ impl<'a> Executor<'a> {
 		}
 		.input_hash();
 
-		let TaskAction::Run(run) = &task_def.action;
-
-		let task = runner::Task {
-			id: task_ref.clone(),
-			run: run.clone(),
-			depends: self.task_deps_with_actions(&task_def),
-			env: self.env.clone(),
+		let output_hash = match &task_def.action {
+			TaskAction::Fetch { .. } => {
+				// Fetch tasks are not implemented yet,
+				// we just return the input hash
+				input_hash
+			}
+			TaskAction::Run(run) => {
+				let task = runner::Task {
+					id: task_ref.clone(),
+					run: run.clone(),
+					depends: self.task_deps_with_actions(&task_def),
+					env: self.env.clone(),
+				};
+
+				runner.run(&task)?
+			}
 		};
 
-		let output_hash = runner.run(&task)?;
 		let output = TaskOutput {
-			id: task.id.clone(),
+			id: task_ref.clone(),
 			depends: task_deps,
 			input_hash,
 			output_hash,
 		};
-
 		save_output(&output)?;
 
-		let rdeps = self.rdeps.get(&task.id);
-		self.tasks_done.insert(task_ref, output);
+		Ok(output)
+	}
+
+	fn update_runnable(&mut self, task_ref: &TaskRef) {
+		let rdeps = self.rdeps.get(task_ref);
 
 		for rdep in rdeps.unwrap_or(&Vec::new()) {
 			if !self.tasks_blocked.contains(rdep) {
@@ -172,13 +185,14 @@ impl<'a> Executor<'a> {
 				self.tasks_runnable.push(rdep.clone());
 			}
 		}
-
-		Ok(())
 	}
 
 	pub fn run(&mut self, runner: &impl runner::Runner) -> runner::Result<()> {
-		while !self.tasks_runnable.is_empty() {
-			self.run_one(runner)?;
+		while let Some(task_ref) = self.tasks_runnable.pop() {
+			let output = self.run_one(&task_ref, runner)?;
+			self.tasks_done.insert(task_ref.clone(), output);
+
+			self.update_runnable(&task_ref);
 		}
 
 		assert!(self.tasks_blocked.is_empty(), "No runnable tasks left");
diff --git a/src/runner/runc/run.rs b/src/runner/runc/run.rs
index 3ca20af..c632732 100644
--- a/src/runner/runc/run.rs
+++ b/src/runner/runc/run.rs
@@ -85,7 +85,10 @@ fn output_filename(hash: &OutputHash) -> PathBuf {
 }
 
 fn unpack_dependencies(task: &runner::Task) -> Result<(), Error> {
-	for dep in task.depends.keys() {
+	for (dep, action) in &task.depends {
+		if !matches!(action, TaskAction::Run(_)) {
+			continue;
+		}
 		let filename = output_filename(dep);
 		let file = File::open(filename)?;
 		tar::unpack_filter(file, "build/tmp/runc/depends", |entry| {
diff --git a/src/types.rs b/src/types.rs
index c3cb53a..3f9c07c 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -54,6 +54,8 @@ impl Display for TaskRef {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub enum TaskAction {
+	#[serde(rename = "fetch")]
+	Fetch { name: String, sha256: String },
 	#[serde(rename = "run")]
 	Run(String),
 }