Rename host api files

The struct names were changed, so rename the files accordingly.

crates/fj-host/src/host.rs

@@ -1,141 +1,88 @@
-use std::thread::{self, JoinHandle};
+use std::thread::JoinHandle;
 
-use crossbeam_channel::{self, Receiver, Sender};
-use fj_interop::processed_shape::ProcessedShape;
+use crossbeam_channel::Sender;
 use fj_operations::shape_processor::ShapeProcessor;
 use winit::event_loop::EventLoopProxy;
 
-use crate::{Error, HostCommand, Model, Watcher};
+use crate::{EventLoopClosed, HostThread, Model, ModelEvent};
 
-// Use a zero-sized error type to silence `#[warn(clippy::result_large_err)]`.
-// The only error from `EventLoopProxy::send_event` is `EventLoopClosed<T>`,
-// so we don't need the actual value. We just need to know there was an error.
-pub(crate) struct EventLoopClosed;
-
-pub(crate) struct HostThread {
-    shape_processor: ShapeProcessor,
-    event_loop_proxy: EventLoopProxy<ModelEvent>,
+/// A host for watching models and responding to model updates
+pub struct Host {
     command_tx: Sender<HostCommand>,
-    command_rx: Receiver<HostCommand>,
+    host_thread: Option<JoinHandle<Result<(), EventLoopClosed>>>,
+    model_loaded: bool,
 }
 
-impl HostThread {
-    // Spawn a background thread that will process models for an event loop.
-    pub(crate) fn spawn(
+impl Host {
+    /// Create a host with a shape processor and a send channel to the event
+    /// loop.
+    pub fn new(
         shape_processor: ShapeProcessor,
         event_loop_proxy: EventLoopProxy<ModelEvent>,
-    ) -> (Sender<HostCommand>, JoinHandle<Result<(), EventLoopClosed>>) {
-        let (command_tx, command_rx) = crossbeam_channel::unbounded();
-        let command_tx_2 = command_tx.clone();
+    ) -> Self {
+        let (command_tx, host_thread) =
+            HostThread::spawn(shape_processor, event_loop_proxy);
 
-        let host_thread = Self {
-            shape_processor,
-            event_loop_proxy,
+        Self {
             command_tx,
-            command_rx,
-        };
-
-        let join_handle = host_thread.spawn_thread();
-
-        (command_tx_2, join_handle)
+            host_thread: Some(host_thread),
+            model_loaded: false,
+        }
     }
 
-    fn spawn_thread(mut self) -> JoinHandle<Result<(), EventLoopClosed>> {
-        thread::Builder::new()
-            .name("host".to_string())
-            .spawn(move || -> Result<(), EventLoopClosed> {
-                let mut model: Option<Model> = None;
-                let mut _watcher: Option<Watcher> = None;
+    /// Send a model to the host for evaluation and processing.
+    pub fn load_model(&mut self, model: Model) {
+        self.command_tx
+            .try_send(HostCommand::LoadModel(model))
+            .expect("Host channel disconnected unexpectedly");
+        self.model_loaded = true;
+    }
 
-                while let Ok(command) = self.command_rx.recv() {
-                    match command {
-                        HostCommand::LoadModel(new_model) => {
-                            // Right now, `fj-app` will only load a new model
-                            // once. The gui does not have a feature to load a
-                            // new model after the initial load. If that were
-                            // to change, there would be a race condition here
-                            // if the prior watcher sent `TriggerEvaluation`
-                            // before it and the model were replaced.
-                            match Watcher::watch_model(
-                                new_model.watch_path(),
-                                self.command_tx.clone(),
-                            ) {
-                                Ok(watcher) => {
-                                    _watcher = Some(watcher);
-                                    self.send_event(ModelEvent::StartWatching)?;
-                                }
+    /// Whether a model has been sent to the host yet
+    pub fn is_model_loaded(&self) -> bool {
+        self.model_loaded
+    }
 
-                                Err(err) => {
-                                    self.send_event(ModelEvent::Error(err))?;
-                                    continue;
-                                }
-                            }
-                            self.process_model(&new_model)?;
-                            model = Some(new_model);
-                        }
-                        HostCommand::TriggerEvaluation => {
-                            self.send_event(ModelEvent::ChangeDetected)?;
-                            if let Some(model) = &model {
-                                self.process_model(model)?;
-                            }
-                        }
+    /// Check if the host thread has exited with a panic. This method runs at
+    /// each tick of the event loop. Without an explicit check, an operation
+    /// will appear to hang forever (e.g. processing a model).  An error
+    /// will be printed to the terminal, but the gui will not notice until
+    /// a new `HostCommand` is issued on the disconnected channel.
+    ///
+    /// # Panics
+    ///
+    /// This method panics on purpose so the main thread can exit on an
+    /// unrecoverable error.
+    pub fn propagate_panic(&mut self) {
+        if self.host_thread.is_none() {
+            unreachable!("Constructor requires host thread")
+        }
+        if let Some(host_thread) = &self.host_thread {
+            // The host thread should not finish while this handle holds the
+            // `command_tx` channel open, so an exit means the thread panicked.
+            if host_thread.is_finished() {
+                let host_thread = self.host_thread.take().unwrap();
+                match host_thread.join() {
+                    Ok(_) => {
+                        unreachable!(
+                            "Host thread cannot exit until host handle disconnects"
+                        )
+                    }
+                    // The error value has already been reported by the panic
+                    // in the host thread, so just ignore it here.
+                    Err(_) => {
+                        panic!("Host thread panicked")
                     }
                 }
-
-                Ok(())
-            })
-            .expect("Cannot create OS thread for host")
-    }
-
-    // Evaluate and process a model.
-    fn process_model(&mut self, model: &Model) -> Result<(), EventLoopClosed> {
-        let evaluation = match model.evaluate() {
-            Ok(evaluation) => evaluation,
-
-            Err(err) => {
-                self.send_event(ModelEvent::Error(err))?;
-                return Ok(());
-            }
-        };
-
-        self.send_event(ModelEvent::Evaluated)?;
-
-        match self.shape_processor.process(&evaluation.shape) {
-            Ok(shape) => self.send_event(ModelEvent::ProcessedShape(shape))?,
-
-            Err(err) => {
-                self.send_event(ModelEvent::Error(err.into()))?;
             }
         }
-
-        Ok(())
-    }
-
-    // Send a message to the event loop.
-    fn send_event(&mut self, event: ModelEvent) -> Result<(), EventLoopClosed> {
-        self.event_loop_proxy
-            .send_event(event)
-            .map_err(|_| EventLoopClosed)?;
-
-        Ok(())
     }
 }
 
-/// An event emitted by the host thread
-#[derive(Debug)]
-pub enum ModelEvent {
-    /// A new model is being watched
-    StartWatching,
-
-    /// A change in the model has been detected
-    ChangeDetected,
-
-    /// The model has been evaluated
-    Evaluated,
-
-    /// The model has been processed
-    ProcessedShape(ProcessedShape),
-
-    /// An error
-    Error(Error),
+/// Commands that can be sent to a host
+pub enum HostCommand {
+    /// Load a model to be evaluated and processed
+    LoadModel(Model),
+    /// Used by a `Watcher` to trigger evaluation when a model is edited
+    TriggerEvaluation,
 }