Job state handling cleanup

src/jobs/bindiff.rs

@@ -5,7 +5,7 @@ use anyhow::{Error, Result};
 use crate::{
     app::{AppConfig, DiffConfig},
     diff::diff_objs,
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    jobs::{start_job, update_status, Job, JobResult, JobState, Status},
     obj::{elf, ObjInfo},
 };
 
@@ -37,8 +37,8 @@ fn run_build(
     Ok(Box::new(BinDiffResult { first_obj: left_obj, second_obj: right_obj }))
 }
 
-pub fn queue_bindiff(config: Arc<RwLock<AppConfig>>) -> JobState {
-    queue_job("Binary diff", Job::BinDiff, move |status, cancel| {
+pub fn start_bindiff(config: Arc<RwLock<AppConfig>>) -> JobState {
+    start_job("Binary diff", Job::BinDiff, move |status, cancel| {
         run_build(status, cancel, config).map(JobResult::BinDiff)
     })
 }

src/jobs/check_update.rs

@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use self_update::{cargo_crate_version, update::Release};
 
 use crate::{
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    jobs::{start_job, update_status, Job, JobResult, JobState, Status},
     update::{build_updater, BIN_NAME},
 };
 
@@ -26,8 +26,8 @@ fn run_check_update(status: &Status, cancel: Receiver<()>) -> Result<Box<CheckUp
     Ok(Box::new(CheckUpdateResult { update_available, latest_release, found_binary }))
 }
 
-pub fn queue_check_update() -> JobState {
-    queue_job("Check for updates", Job::CheckUpdate, move |status, cancel| {
+pub fn start_check_update() -> JobState {
+    start_job("Check for updates", Job::CheckUpdate, move |status, cancel| {
         run_check_update(status, cancel).map(JobResult::CheckUpdate)
     })
 }

src/jobs/mod.rs

@@ -27,14 +27,72 @@ pub enum Job {
     Update,
 }
 pub static JOB_ID: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Default)]
+pub struct JobQueue {
+    pub jobs: Vec<JobState>,
+}
+
+impl JobQueue {
+    /// Adds a job to the queue.
+    pub fn push(&mut self, state: JobState) { self.jobs.push(state); }
+
+    /// Returns whether a job of the given kind is running.
+    pub fn is_running(&self, kind: Job) -> bool {
+        self.jobs.iter().any(|j| j.kind == kind && j.handle.is_some())
+    }
+
+    /// Returns whether any job is running.
+    pub fn any_running(&self) -> bool {
+        self.jobs.iter().any(|job| {
+            if let Some(handle) = &job.handle {
+                return !handle.is_finished();
+            }
+            false
+        })
+    }
+
+    /// Iterates over all jobs mutably.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut JobState> + '_ { self.jobs.iter_mut() }
+
+    /// Iterates over all finished jobs, returning the job state and the result.
+    pub fn iter_finished(
+        &mut self,
+    ) -> impl Iterator<Item = (&mut JobState, std::thread::Result<JobResult>)> + '_ {
+        self.jobs.iter_mut().filter_map(|job| {
+            if let Some(handle) = &job.handle {
+                if !handle.is_finished() {
+                    return None;
+                }
+                let result = job.handle.take().unwrap().join();
+                return Some((job, result));
+            }
+            None
+        })
+    }
+
+    /// Clears all finished jobs.
+    pub fn clear_finished(&mut self) {
+        self.jobs.retain(|job| {
+            !(job.should_remove
+                && job.handle.is_none()
+                && job.status.read().unwrap().error.is_none())
+        });
+    }
+
+    /// Removes a job from the queue given its ID.
+    pub fn remove(&mut self, id: usize) { self.jobs.retain(|job| job.id != id); }
+}
+
 pub struct JobState {
     pub id: usize,
-    pub job_type: Job,
+    pub kind: Job,
     pub handle: Option<JoinHandle<JobResult>>,
     pub status: Arc<RwLock<JobStatus>>,
     pub cancel: Sender<()>,
     pub should_remove: bool,
 }
+
 #[derive(Default)]
 pub struct JobStatus {
     pub title: String,
@@ -43,6 +101,7 @@ pub struct JobStatus {
     pub status: String,
     pub error: Option<anyhow::Error>,
 }
+
 pub enum JobResult {
     None,
     ObjDiff(Box<ObjDiffResult>),
@@ -60,9 +119,9 @@ fn should_cancel(rx: &Receiver<()>) -> bool {
 
 type Status = Arc<RwLock<JobStatus>>;
 
-fn queue_job(
+fn start_job(
     title: &str,
-    job_type: Job,
+    kind: Job,
     run: impl FnOnce(&Status, Receiver<()>) -> Result<JobResult> + Send + 'static,
 ) -> JobState {
     let status = Arc::new(RwLock::new(JobStatus {
@@ -89,7 +148,7 @@ fn queue_job(
     log::info!("Started job {}", id);
     JobState {
         id,
-        job_type,
+        kind,
         handle: Some(handle),
         status: status_clone,
         cancel: tx,

src/jobs/objdiff.rs

@@ -11,7 +11,7 @@ use time::OffsetDateTime;
 use crate::{
     app::{AppConfig, DiffConfig},
     diff::diff_objs,
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    jobs::{start_job, update_status, Job, JobResult, JobState, Status},
     obj::{elf, ObjInfo},
 };
 
@@ -136,8 +136,8 @@ fn run_build(
     Ok(Box::new(ObjDiffResult { first_status, second_status, first_obj, second_obj, time }))
 }
 
-pub fn queue_build(config: Arc<RwLock<AppConfig>>, diff_config: DiffConfig) -> JobState {
-    queue_job("Object diff", Job::ObjDiff, move |status, cancel| {
+pub fn start_build(config: Arc<RwLock<AppConfig>>, diff_config: DiffConfig) -> JobState {
+    start_job("Object diff", Job::ObjDiff, move |status, cancel| {
         run_build(status, cancel, config, diff_config).map(JobResult::ObjDiff)
     })
 }

src/jobs/update.rs

@@ -9,7 +9,7 @@ use anyhow::{Context, Result};
 use const_format::formatcp;
 
 use crate::{
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    jobs::{start_job, update_status, Job, JobResult, JobState, Status},
     update::{build_updater, BIN_NAME},
 };
 
@@ -53,8 +53,8 @@ fn run_update(status: &Status, cancel: Receiver<()>) -> Result<Box<UpdateResult>
     Ok(Box::from(UpdateResult { exe_path: target_file }))
 }
 
-pub fn queue_update() -> JobState {
-    queue_job("Update app", Job::Update, move |status, cancel| {
+pub fn start_update() -> JobState {
+    start_job("Update app", Job::Update, move |status, cancel| {
         run_update(status, cancel).map(JobResult::Update)
     })
 }