Merge pull request #622 from axodotdev/feat/livereload

feat: add livereload to dev

Author: liv

Cargo.lock

@@ -40,6 +40,7 @@ thiserror = "1.0.37"
 tokio = { version = "1.20.1", features = ["full"] }
 toml = "0.5.9"
 tower-http = { version = "0.3.0", features = ["fs", "trace"] }
+tower-livereload = "0.8.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["fmt"] }
 url = "2.3.1"

Cargo.toml

@@ -124,8 +124,12 @@ impl Dev {
             Build::new(self.project_root.clone(), self.config_path.clone()).run()?;
         }
 
-        // Spawn the serve process out into a separate thread so that we can loop through received events on this thread
-        let _ = std::thread::spawn(move || Serve::new(self.port).run());
+        let (ws_tx, ws_rx) = std::sync::mpsc::channel();
+        // Spawn the serve process out into a separate thread so that we can loop through received
+        // events on this thread.
+        let _thread_handle = std::thread::spawn(move || {
+            Serve::new(self.port).run_with_livereload(ws_rx).unwrap();
+        });
         let addr = SocketAddr::from(([127, 0, 0, 1], self.port.unwrap_or(7979)));
         let msg = if config.build.path_prefix.is_some() {
             format!(
@@ -167,6 +171,12 @@ impl Dev {
                 {
                     eprintln!("{:?}", Report::new(e));
                     continue;
+                } else {
+                    // Reload page (this goes into the serve thread, which has spawned a subthread
+                    // to handle messages)
+                    ws_tx
+                        .send(())
+                        .expect("error when sending livereload message");
                 }
             }
         }

src/commands/dev.rs

@@ -1,5 +1,7 @@
 use camino::{Utf8Path, Utf8PathBuf};
 use std::net::SocketAddr;
+use std::sync::mpsc::Receiver;
+use std::thread;
 
 use oranda::config::Config;
 use oranda::errors::*;
@@ -8,6 +10,7 @@ use axum::{http::StatusCode, routing::get_service, Router};
 
 use clap::Parser;
 use tower_http::services::ServeDir;
+use tower_livereload::LiveReloadLayer;
 
 #[derive(Debug, Default, Parser)]
 pub struct Serve {
@@ -23,19 +26,27 @@ impl Serve {
     }
 
     pub fn run(&self) -> Result<()> {
-        let workspace_config_path = &Utf8PathBuf::from("./oranda-workspace.json");
-        let config = if workspace_config_path.exists() {
-            Config::build(workspace_config_path)?
+        let config = Self::build_config()?;
+        if Utf8Path::new(&config.build.dist_dir).is_dir() {
+            self.serve(&config.build.dist_dir, &config.build.path_prefix, None)?;
+            Ok(())
         } else {
-            Config::build(&Utf8PathBuf::from("./oranda.json"))?
-        };
+            Err(OrandaError::BuildNotFound {
+                dist_dir: config.build.dist_dir.to_string(),
+            })
+        }
+    }
+
+    pub fn run_with_livereload(&self, rx: Receiver<()>) -> Result<()> {
+        let config = Self::build_config()?;
         if Utf8Path::new(&config.build.dist_dir).is_dir() {
-            if let Some(prefix) = config.build.path_prefix {
-                tracing::debug!("`path_prefix` configured: {}", &prefix);
-                self.serve_prefix(&config.build.dist_dir, &prefix)?;
-            } else {
-                self.serve(&config.build.dist_dir)?;
-            }
+            let livereload = LiveReloadLayer::new();
+            self.serve(
+                &config.build.dist_dir,
+                &config.build.path_prefix,
+                Some((livereload, rx)),
+            )?;
+
             Ok(())
         } else {
             Err(OrandaError::BuildNotFound {
@@ -45,7 +56,12 @@ impl Serve {
     }
 
     #[tokio::main]
-    async fn serve(&self, dist_dir: &str) -> Result<()> {
+    async fn serve(
+        &self,
+        dist_dir: &str,
+        path_prefix: &Option<String>,
+        livereload: Option<(LiveReloadLayer, Receiver<()>)>,
+    ) -> Result<()> {
         let serve_dir =
             get_service(ServeDir::new(dist_dir)).handle_error(|error: std::io::Error| async move {
                 (
@@ -54,37 +70,45 @@ impl Serve {
                 )
             });
 
-        let app = Router::new().nest_service("/", serve_dir);
-
-        let addr = SocketAddr::from(([127, 0, 0, 1], self.port));
-        let msg = format!("Your project is available at: http://{}", addr);
-        tracing::info!(success = true, "{}", &msg);
-        axum::Server::bind(&addr)
-            .serve(app.into_make_service())
-            .await
-            .expect("failed to start server");
-        Ok(())
-    }
+        let prefix_route = if let Some(prefix) = path_prefix {
+            format!("/{}", prefix)
+        } else {
+            "/".to_string()
+        };
+        let mut app = Router::new().nest_service(&prefix_route, serve_dir);
+        if let Some(livereload) = livereload {
+            let (livereload, rx) = livereload;
+            let reloader = livereload.reloader();
+            app = app.layer(livereload);
 
-    #[tokio::main]
-    async fn serve_prefix(&self, dist_dir: &str, prefix: &str) -> Result<()> {
-        let serve_dir =
-            get_service(ServeDir::new(dist_dir)).handle_error(|error: std::io::Error| async move {
-                (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    format!("Unhandled internal error: {}", error),
-                )
+            // Because the server will later block this thread, spawn another thread to handle
+            // reload request messages.
+            thread::spawn(move || loop {
+                rx.recv().expect("broken pipe");
+                reloader.reload();
             });
-        let prefix_route = format!("/{}", prefix);
-        let app = Router::new().nest_service(&prefix_route, serve_dir);
+        }
 
         let addr = SocketAddr::from(([127, 0, 0, 1], self.port));
-        let msg = format!("Your project is available at: http://{}/{}", addr, prefix);
+        let msg = format!(
+            "Your project is available at: http://{}/{}",
+            addr,
+            path_prefix.as_ref().unwrap_or(&String::new())
+        );
         tracing::info!(success = true, "{}", &msg);
         axum::Server::bind(&addr)
             .serve(app.into_make_service())
             .await
             .expect("failed to start server");
         Ok(())
     }
+
+    fn build_config() -> Result<Config> {
+        let workspace_config_path = &Utf8PathBuf::from("./oranda-workspace.json");
+        if workspace_config_path.exists() {
+            Config::build(workspace_config_path)
+        } else {
+            Config::build(&Utf8PathBuf::from("./oranda.json"))
+        }
+    }
 }