add timestamps to incremental rendering

packages/router/src/ssr.rs

@@ -4,17 +4,22 @@
 
 use crate::prelude::*;
 use dioxus::prelude::*;
+use rustc_hash::FxHasher;
 use std::{
-    io::{Read, Write},
+    hash::BuildHasherDefault,
+    io::Write,
     num::NonZeroUsize,
     path::{Path, PathBuf},
     str::FromStr,
+    time::{Duration, SystemTime},
 };
 
 /// Something that can render a HTML page from a body.
 pub trait RenderHTML {
-    /// Render a HTML page from a body.
-    fn render_html(&self, body: &str) -> String;
+    /// Render the HTML before the body
+    fn render_before_body<R: Write>(&self, to: &mut R) -> Result<(), IncrementalRendererError>;
+    /// Render the HTML after the body
+    fn render_after_body<R: Write>(&self, to: &mut R) -> Result<(), IncrementalRendererError>;
 }
 
 /// The default page renderer
@@ -45,8 +50,14 @@ impl Default for DefaultRenderer {
 }
 
 impl RenderHTML for DefaultRenderer {
-    fn render_html(&self, body: &str) -> String {
-        format!("{}{}{}", self.before_body, body, self.after_body)
+    fn render_before_body<R: Write>(&self, to: &mut R) -> Result<(), IncrementalRendererError> {
+        to.write_all(self.before_body.as_bytes())?;
+        Ok(())
+    }
+
+    fn render_after_body<R: Write>(&self, to: &mut R) -> Result<(), IncrementalRendererError> {
+        to.write_all(self.after_body.as_bytes())?;
+        Ok(())
     }
 }
 
@@ -54,6 +65,7 @@ impl RenderHTML for DefaultRenderer {
 pub struct IncrementalRendererConfig<R: RenderHTML> {
     static_dir: PathBuf,
     memory_cache_limit: usize,
+    invalidate_after: Option<Duration>,
     render: R,
 }
 
@@ -68,7 +80,8 @@ impl<R: RenderHTML> IncrementalRendererConfig<R> {
     pub fn new(render: R) -> Self {
         Self {
             static_dir: PathBuf::from("./static"),
-            memory_cache_limit: 100,
+            memory_cache_limit: 10000,
+            invalidate_after: None,
             render,
         }
     }
@@ -85,13 +98,21 @@ impl<R: RenderHTML> IncrementalRendererConfig<R> {
         self
     }
 
+    /// Set the invalidation time.
+    pub fn invalidate_after(mut self, invalidate_after: Duration) -> Self {
+        self.invalidate_after = Some(invalidate_after);
+        self
+    }
+
     /// Build the incremental renderer.
     pub fn build(self) -> IncrementalRenderer<R> {
         IncrementalRenderer {
             static_dir: self.static_dir,
             memory_cache: NonZeroUsize::new(self.memory_cache_limit)
-                .map(|limit| lru::LruCache::new(limit)),
+                .map(|limit| lru::LruCache::with_hasher(limit, Default::default())),
+            invalidate_after: self.invalidate_after,
             render: self.render,
+            ssr_renderer: dioxus_ssr::Renderer::new(),
         }
     }
 }
@@ -99,7 +120,10 @@ impl<R: RenderHTML> IncrementalRendererConfig<R> {
 /// An incremental renderer.
 pub struct IncrementalRenderer<R: RenderHTML> {
     static_dir: PathBuf,
-    memory_cache: Option<lru::LruCache<String, String>>,
+    memory_cache:
+        Option<lru::LruCache<String, (SystemTime, Vec<u8>), BuildHasherDefault<FxHasher>>>,
+    invalidate_after: Option<Duration>,
+    ssr_renderer: dioxus_ssr::Renderer,
     render: R,
 }
 
@@ -109,80 +133,157 @@ impl<R: RenderHTML> IncrementalRenderer<R> {
         IncrementalRendererConfig::new(renderer)
     }
 
-    fn render_uncached<Rt>(&self, route: Rt) -> String
+    fn track_timestamps(&self) -> bool {
+        self.invalidate_after.is_some()
+    }
+
+    fn render_and_cache<Rt>(
+        &mut self,
+        route: Rt,
+        output: &mut impl Write,
+    ) -> Result<(), IncrementalRendererError>
     where
         Rt: Routable,
         <Rt as FromStr>::Err: std::fmt::Display,
     {
+        let route_str = route.to_string();
         let mut vdom = VirtualDom::new_with_props(RenderPath, RenderPathProps { path: route });
         let _ = vdom.rebuild();
 
-        let body = dioxus_ssr::render(&vdom);
+        let mut html_buffer = WriteBuffer { buffer: Vec::new() };
+        self.render.render_before_body(&mut html_buffer)?;
+        self.ssr_renderer.render_to(&mut html_buffer, &mut vdom)?;
+        self.render.render_after_body(&mut html_buffer)?;
+        let html_buffer = html_buffer.buffer;
 
-        self.render.render_html(&body)
+        output.write_all(&html_buffer)?;
+
+        self.add_to_cache(route_str, html_buffer)
     }
 
-    fn add_to_cache(&mut self, route: String, html: String) {
+    fn add_to_cache(
+        &mut self,
+        route: String,
+        html: Vec<u8>,
+    ) -> Result<(), IncrementalRendererError> {
         let file_path = self.route_as_path(&route);
         if let Some(parent) = file_path.parent() {
             if !parent.exists() {
-                std::fs::create_dir_all(parent).unwrap();
+                std::fs::create_dir_all(parent)?;
             }
         }
-        let file = std::fs::File::create(dbg!(file_path)).unwrap();
+        let file = std::fs::File::create(file_path)?;
         let mut file = std::io::BufWriter::new(file);
-        file.write_all(html.as_bytes()).unwrap();
+        file.write_all(&html)?;
         self.add_to_memory_cache(route, html);
+        Ok(())
     }
 
-    fn add_to_memory_cache<K: AsRef<str> + ToString, V: ToString>(&mut self, route: K, html: V) {
+    fn add_to_memory_cache(&mut self, route: String, html: Vec<u8>) {
         if let Some(cache) = self.memory_cache.as_mut() {
-            if cache.contains(route.as_ref()) {
-                cache.promote(route.as_ref())
-            } else {
-                cache.put(route.to_string(), html.to_string());
-            }
+            cache.put(route.to_string(), (SystemTime::now(), html));
         }
     }
 
-    fn search_cache(&mut self, route: String) -> Option<String> {
-        if let Some(cache_hit) = self
+    fn promote_memory_cache<K: AsRef<str>>(&mut self, route: K) {
+        if let Some(cache) = self.memory_cache.as_mut() {
+            cache.promote(route.as_ref())
+        }
+    }
+
+    fn search_cache(
+        &mut self,
+        route: String,
+        output: &mut impl Write,
+    ) -> Result<bool, IncrementalRendererError> {
+        if let Some((timestamp, cache_hit)) = self
             .memory_cache
             .as_mut()
-            .and_then(|cache| cache.get(&route).cloned())
+            .and_then(|cache| cache.get(&route))
         {
-            Some(cache_hit)
-        } else {
-            let file_path = self.route_as_path(&route);
-            if let Ok(file) = std::fs::File::open(file_path) {
-                let mut file = std::io::BufReader::new(file);
-                let mut html = String::new();
-                file.read_to_string(&mut html).ok()?;
-                self.add_to_memory_cache(route, html.clone());
-                Some(html)
+            if let (Ok(elapsed), Some(invalidate_after)) =
+                (timestamp.elapsed(), self.invalidate_after)
+            {
+                if elapsed < invalidate_after {
+                    log::trace!("memory cache hit {:?}", route);
+                    output.write_all(cache_hit)?;
+                    return Ok(true);
+                }
             } else {
-                None
+                log::trace!("memory cache hit {:?}", route);
+                output.write_all(cache_hit)?;
+                return Ok(true);
             }
         }
+        if let Some(file_path) = self.find_file(&route) {
+            if let Ok(file) = std::fs::File::open(file_path.full_path) {
+                let mut file = std::io::BufReader::new(file);
+                std::io::copy(&mut file, output)?;
+                log::trace!("file cache hit {:?}", route);
+                self.promote_memory_cache(&route);
+                return Ok(true);
+            }
+        }
+        Ok(false)
     }
 
     /// Render a route or get it from cache.
-    pub fn render<Rt>(&mut self, route: Rt) -> String
+    pub fn render<Rt>(
+        &mut self,
+        route: Rt,
+        output: &mut impl Write,
+    ) -> Result<(), IncrementalRendererError>
     where
         Rt: Routable,
         <Rt as FromStr>::Err: std::fmt::Display,
     {
         // check if this route is cached
-        if let Some(html) = self.search_cache(route.to_string()) {
-            return html;
+        if !self.search_cache(route.to_string(), output)? {
+            // if not, create it
+            self.render_and_cache(route, output)?;
+            log::trace!("cache miss");
         }
 
-        // if not, create it
-        println!("cache miss");
-        let html = self.render_uncached(route.clone());
-        self.add_to_cache(route.to_string(), html.clone());
+        Ok(())
+    }
 
-        html
+    fn find_file(&self, route: &str) -> Option<ValidCachedPath> {
+        let mut file_path = self.static_dir.clone();
+        for segment in route.split('/') {
+            file_path.push(segment);
+        }
+        if let Some(deadline) = self.invalidate_after {
+            // find the first file that matches the route and is a html file
+            file_path.push("index");
+            if let Ok(dir) = std::fs::read_dir(file_path) {
+                let mut file = None;
+                for entry in dir.flatten() {
+                    if let Some(cached_path) = ValidCachedPath::try_from_path(entry.path()) {
+                        if let Ok(elapsed) = cached_path.timestamp.elapsed() {
+                            if elapsed < deadline {
+                                file = Some(cached_path);
+                                continue;
+                            }
+                        }
+                        // if the timestamp is invalid or passed, delete the file
+                        if let Err(err) = std::fs::remove_file(entry.path()) {
+                            log::error!("Failed to remove file: {}", err);
+                        }
+                    }
+                }
+                file
+            } else {
+                None
+            }
+        } else {
+            file_path.push("index.html");
+            file_path.exists().then_some({
+                ValidCachedPath {
+                    full_path: file_path,
+                    timestamp: SystemTime::now(),
+                }
+            })
+        }
     }
 
     fn route_as_path(&self, route: &str) -> PathBuf {
@@ -190,13 +291,18 @@ impl<R: RenderHTML> IncrementalRenderer<R> {
         for segment in route.split('/') {
             file_path.push(segment);
         }
-        file_path.push("index");
+        if self.track_timestamps() {
+            file_path.push("index");
+            file_path.push(timestamp());
+        } else {
+            file_path.push("index");
+        }
         file_path.set_extension("html");
         file_path
     }
 
     /// Pre-cache all static routes.
-    pub fn pre_cache_static<Rt>(&mut self)
+    pub fn pre_cache_static_routes<Rt>(&mut self) -> Result<(), IncrementalRendererError>
     where
         Rt: Routable,
         <Rt as FromStr>::Err: std::fmt::Display,
@@ -225,7 +331,7 @@ impl<R: RenderHTML> IncrementalRenderer<R> {
             if is_static {
                 match Rt::from_str(&full_path) {
                     Ok(route) => {
-                        let _ = self.render(route);
+                        let _ = self.render(route, &mut std::io::sink())?;
                     }
                     Err(e) => {
                         log::error!("Error pre-caching static route: {}", e);
@@ -233,9 +339,65 @@ impl<R: RenderHTML> IncrementalRenderer<R> {
                 }
             }
         }
+
+        Ok(())
     }
 }
 
+struct WriteBuffer {
+    buffer: Vec<u8>,
+}
+
+impl std::fmt::Write for WriteBuffer {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.buffer.extend_from_slice(s.as_bytes());
+        Ok(())
+    }
+}
+
+impl Write for WriteBuffer {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.buffer.write(buf)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.buffer.flush()
+    }
+}
+
+struct ValidCachedPath {
+    full_path: PathBuf,
+    timestamp: std::time::SystemTime,
+}
+
+impl ValidCachedPath {
+    fn try_from_path(value: PathBuf) -> Option<Self> {
+        if value.extension() != Some(std::ffi::OsStr::new("html")) {
+            return None;
+        }
+        let timestamp = decode_timestamp(&value.file_stem()?.to_str()?)?;
+        let full_path = value;
+        Some(Self {
+            full_path,
+            timestamp,
+        })
+    }
+}
+
+fn decode_timestamp(timestamp: &str) -> Option<std::time::SystemTime> {
+    let timestamp = u64::from_str_radix(timestamp, 16).ok()?;
+    Some(std::time::UNIX_EPOCH + std::time::Duration::from_secs(timestamp))
+}
+
+fn timestamp() -> String {
+    let datetime = std::time::SystemTime::now();
+    let timestamp = datetime
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    format!("{:x}", timestamp)
+}
+
 #[inline_props]
 fn RenderPath<R>(cx: Scope, path: R) -> Element
 where
@@ -249,3 +411,14 @@ where
         }
     }
 }
+
+/// An error that can occur while rendering a route or retrieving a cached route.
+#[derive(Debug, thiserror::Error)]
+pub enum IncrementalRendererError {
+    /// An formatting error occurred while rendering a route.
+    #[error("RenderError: {0}")]
+    RenderError(#[from] std::fmt::Error),
+    /// An IO error occurred while rendering a route.
+    #[error("IoError: {0}")]
+    IoError(#[from] std::io::Error),
+}