@browsersync/bslive 0.0.7 → 0.0.9

package/crates/bsnext_example/src/lit.rs

@@ -0,0 +1,37 @@
+use bsnext_input::route::{Route, RouteKind};
+use bsnext_input::server_config::Identity;
+use bsnext_input::{
+    server_config::{self},
+    Input,
+};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct LitExample;
+
+impl LitExample {
+    pub fn into_input(self, identity: Option<Identity>) -> Input {
+        let server = server_config::ServerConfig {
+            identity: identity.unwrap_or_else(Identity::named),
+            routes: vec![
+                Route {
+                    path: "/".to_string(),
+                    kind: RouteKind::Html {
+                        html: include_str!("../../../examples/lit/index.html").to_owned(),
+                    },
+                    ..Default::default()
+                },
+                Route {
+                    path: "/lit.js".to_string(),
+                    kind: RouteKind::Raw {
+                        raw: include_str!("../../../examples/lit/lit.js").to_owned(),
+                    },
+                    ..Default::default()
+                },
+            ],
+            watchers: vec![],
+        };
+        Input {
+            servers: vec![server],
+        }
+    }
+}

package/crates/bsnext_example/src/md.rs

@@ -0,0 +1,18 @@
+use bsnext_input::server_config::Identity;
+use bsnext_input::{md, Input};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct MdExample;
+
+impl MdExample {
+    pub fn into_input(self, identity: Option<Identity>) -> Input {
+        let input_str = include_str!("../../../examples/md-single/md-single.md");
+        let mut input = md::md_to_input(input_str).expect("example cannot fail?");
+        let server = input
+            .servers
+            .first_mut()
+            .expect("example must have 1 server");
+        server.identity = identity.unwrap_or_else(Identity::named);
+        input
+    }
+}

package/crates/bsnext_fs/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "bsnext_fs"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+notify = "6.1.1"
+pin-project-lite = "0.2.14"
+glob-match = { version = "0.2.1" }
+
+actix = { workspace = true }
+actix-rt = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+futures = { workspace = true }
+futures-util = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+thiserror = { workspace = true }
+tempfile = { workspace = true }

package/crates/bsnext_fs/src/actor.rs

@@ -0,0 +1,122 @@
+use crate::buffered_debounce::BufferedStreamOpsExt;
+use crate::inner_fs_event_handler::{InnerChangeEvent, MultipleInnerChangeEvent};
+use crate::stream::StreamOpsExt;
+use crate::{watcher, Debounce, FsEvent, FsEventContext};
+use actix::{Actor, Addr, AsyncContext, Recipient, Running};
+use actix_rt::Arbiter;
+use futures_util::StreamExt;
+
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use crate::filter::Filter;
+use tokio::sync::{broadcast, mpsc};
+use tokio_stream::wrappers::ReceiverStream;
+
+pub struct FsWatcher {
+    pub watcher: Option<notify::FsEventWatcher>,
+    raw_fs_stream: Arc<broadcast::Sender<InnerChangeEvent>>,
+    pub receivers: Vec<Recipient<FsEvent>>,
+    pub ctx: FsEventContext,
+    pub debounce: Debounce,
+    pub filters: Vec<Filter>,
+    pub cwd: PathBuf,
+}
+
+impl FsWatcher {
+    pub fn new(cwd: &Path, id: u64) -> Self {
+        // todo: does this need to be a broadcast::channel? would an unbounded mpsc be better?
+        let (raw_fs_sender, _) = broadcast::channel::<InnerChangeEvent>(1000);
+
+        Self {
+            watcher: None,
+            raw_fs_stream: Arc::new(raw_fs_sender),
+            receivers: vec![],
+            ctx: FsEventContext::Other { id },
+            cwd: cwd.to_path_buf(),
+            filters: vec![],
+            debounce: Default::default(),
+        }
+    }
+
+    pub fn for_input(cwd: &Path, id: u64) -> Self {
+        let mut s = Self::new(cwd, id);
+        s.ctx = FsEventContext::InputFile { id };
+        s
+    }
+
+    pub fn with_debounce(&mut self, d: Debounce) {
+        self.debounce = d
+    }
+
+    pub fn with_filter(&mut self, f: Filter) {
+        self.filters.push(f)
+    }
+
+    fn setup_fs_streams(&mut self, a: Addr<FsWatcher>) {
+        let raw_fs_events_sender = self.raw_fs_stream.clone();
+        let (debounce_sender, debounce_receiver) = mpsc::channel::<InnerChangeEvent>(1);
+
+        Arbiter::current().spawn({
+            let debounce = self.debounce;
+            async move {
+                match debounce {
+                    Debounce::Trailing { duration } => {
+                        let stream = ReceiverStream::new(debounce_receiver).debounce(duration);
+                        let mut debounced_stream = Box::pin(stream);
+                        while let Some(v) = debounced_stream.next().await {
+                            a.do_send(v);
+                        }
+                    }
+                    Debounce::Buffered { duration } => {
+                        let stream =
+                            ReceiverStream::new(debounce_receiver).buffered_debounce(duration);
+                        let mut debounced_stream = Box::pin(stream);
+                        while let Some(v) = debounced_stream.next().await {
+                            a.do_send(MultipleInnerChangeEvent { events: v })
+                        }
+                    }
+                }
+            }
+        });
+
+        // Listen for noisy FS events and pump them into the broadcast channel
+        Arbiter::current().spawn({
+            async move {
+                let debounce_sender = debounce_sender.clone();
+                let mut raw_fs_receiver = raw_fs_events_sender.subscribe();
+                while let Ok(raw_event) = raw_fs_receiver.recv().await {
+                    tracing::trace!(?raw_event);
+                    match debounce_sender.send(raw_event).await {
+                        Ok(_) => {}
+                        Err(e) => tracing::error!(?e),
+                    }
+                }
+            }
+        });
+    }
+}
+
+impl Actor for FsWatcher {
+    type Context = actix::Context<Self>;
+
+    fn started(&mut self, ctx: &mut Self::Context) {
+        tracing::trace!(actor.name = "FsWatcher", actor.lifecyle = "started");
+        let self_address = ctx.address();
+        let rx2 = self.raw_fs_stream.clone();
+        match watcher::create_watcher(rx2, &self.cwd) {
+            Ok(watcher) => self.watcher = Some(watcher),
+            Err(e) => tracing::error!(?e, "could not create watcher"),
+        }
+        self.setup_fs_streams(self_address);
+    }
+
+    fn stopping(&mut self, _ctx: &mut Self::Context) -> Running {
+        tracing::trace!(actor.name = "FsWatcher", actor.lifecyle = "stopping");
+        Running::Stop
+    }
+
+    fn stopped(&mut self, _ctx: &mut Self::Context) {
+        tracing::trace!(actor.name = "FsWatcher", actor.lifecyle = "stopped");
+    }
+}

package/crates/bsnext_fs/src/buffered_debounce.rs

@@ -0,0 +1,166 @@
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use std::fmt::Debug;
+use std::time::Duration;
+
+use futures::{Future, Stream};
+use pin_project_lite::pin_project;
+
+use tokio::time::{Instant, Sleep};
+
+use tracing::trace;
+
+pin_project! {
+    #[must_use = "streams do nothing unless polled"]
+    pub struct BufferedDebounce<St: Stream> {
+        #[pin]
+        dropped_count: usize,
+        #[pin]
+        value: St,
+        #[pin]
+        delay: Sleep,
+        #[pin]
+        debounce_time: Duration,
+        #[pin]
+        last_state: Vec<St::Item>,
+        #[pin]
+        child_ended: bool
+    }
+}
+
+pub trait BufferedStreamOpsExt: Stream {
+    fn buffered_debounce(self, debounce_time: Duration) -> BufferedDebounce<Self>
+    where
+        Self: Sized + Unpin,
+    {
+        BufferedDebounce::new(self, debounce_time)
+    }
+}
+
+impl<T: ?Sized> BufferedStreamOpsExt for T where T: Stream {}
+
+impl<St> BufferedDebounce<St>
+where
+    St: Stream + Unpin,
+{
+    #[allow(dead_code)]
+    fn new(stream: St, debounce_time: Duration) -> BufferedDebounce<St> {
+        BufferedDebounce {
+            value: stream,
+            dropped_count: 0,
+            delay: tokio::time::sleep(debounce_time),
+            debounce_time,
+            last_state: vec![],
+            child_ended: false,
+        }
+    }
+}
+
+impl<St, Item> Stream for BufferedDebounce<St>
+where
+    St: Stream<Item = Item>,
+    Item: Clone + Unpin + Debug + 'static,
+{
+    type Item = Vec<St::Item>;
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut me = self.project();
+        trace!("+ polled!");
+
+        match me.value.poll_next(cx) {
+            Poll::Ready(Some(v)) => {
+                trace!("recorded a child value");
+                me.last_state.push(v);
+                *me.dropped_count += 1;
+
+                trace!("resetting the deadline to be `debounce_time` from `now`");
+                let dur = *me.debounce_time;
+                me.delay.as_mut().reset(Instant::now() + dur);
+
+                trace!("wake to ensure we're polled again");
+                cx.waker().wake_by_ref();
+                return Poll::Pending;
+            }
+            Poll::Ready(None) => {
+                trace!("child ended, nothing more to do?");
+                *me.child_ended = true;
+            }
+            Poll::Pending => {
+                trace!("child was pending, nothing to do");
+            }
+        }
+
+        match me.delay.poll(cx) {
+            Poll::Ready(_) => {
+                trace!("timer elapsed");
+                if !me.last_state.is_empty() {
+                    trace!("buffered {} events", me.dropped_count);
+                    let v = me.last_state.drain(..).collect::<Vec<_>>();
+                    *me.dropped_count = 0;
+                    trace!("sending value");
+                    Poll::Ready(Some(v))
+                } else if *me.child_ended {
+                    Poll::Ready(None)
+                } else {
+                    Poll::Pending
+                }
+            }
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use tokio::sync::mpsc;
+    use tokio::time::sleep;
+    use tokio::time::Instant;
+    use tokio_stream::wrappers::ReceiverStream;
+    use tokio_stream::StreamExt;
+
+    #[tokio::test]
+    async fn test_buffered_debounce_stream() {
+        let (tx, rx) = mpsc::channel::<&str>(10);
+        let handle = tokio::spawn(async move {
+            let events = ["A", "B", "C", "D", "E", "F"];
+
+            // 6 events all happening together
+            for evt in events {
+                tx.send(evt).await.unwrap();
+            }
+
+            // a gap in events, just under the debounce duration
+            sleep(Duration::from_millis(200)).await;
+
+            tx.send("G").await.unwrap();
+            tx.send("H").await.unwrap();
+            tx.send("I").await.unwrap();
+            tx.send("J").await.unwrap();
+
+            // drop the sender to complete the stream
+            drop(tx);
+        });
+
+        let start_time = Instant::now();
+        let stream = Box::pin(
+            ReceiverStream::new(rx)
+                .buffered_debounce(Duration::from_millis(100))
+                .collect::<Vec<_>>(),
+        );
+
+        let results = stream.await;
+        let end_time = Instant::now();
+        let total_duration = end_time
+            .checked_duration_since(start_time)
+            .expect("checked");
+
+        println!("{:?}", results);
+        println!("duration: {:?}", total_duration);
+
+        assert!(handle.await.is_ok());
+        assert_eq!(
+            vec![vec!["A", "B", "C", "D", "E", "F"], vec!["G", "H", "I", "J"]],
+            results
+        );
+    }
+}

package/crates/bsnext_fs/src/filter.rs

@@ -0,0 +1,30 @@
+use crate::PathDescription;
+use glob_match::glob_match;
+
+#[derive(Debug, Clone)]
+pub enum Filter {
+    None,
+    Extension { ext: String },
+    Glob { glob: String },
+}
+
+impl PathFilter for Filter {
+    fn filter(&self, pd: &PathDescription) -> bool {
+        match self {
+            Filter::None => false,
+            Filter::Extension { ext } => pd
+                .absolute
+                .extension()
+                .is_some_and(|x| x.to_string_lossy() == *ext),
+            Filter::Glob { glob } => {
+                let target = pd.relative.unwrap_or(pd.absolute);
+                let did_match = glob_match(glob, target.to_string_lossy().to_string().as_str());
+                did_match
+            }
+        }
+    }
+}
+
+pub trait PathFilter {
+    fn filter(&self, pd: &PathDescription) -> bool;
+}

package/crates/bsnext_fs/src/inner_fs_event_handler.rs

@@ -0,0 +1,94 @@
+use crate::actor::FsWatcher;
+use crate::filter::PathFilter;
+use crate::{
+    BufferedChangeEvent, ChangeEvent, FsEvent, FsEventKind, PathDescription, PathDescriptionOwned,
+};
+use actix::Handler;
+use std::collections::BTreeSet;
+use std::path::PathBuf;
+use std::time::Instant;
+
+#[derive(actix::Message, Hash, PartialEq, Eq, Ord, PartialOrd, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct InnerChangeEvent {
+    pub absolute_path: PathBuf,
+}
+
+impl Handler<InnerChangeEvent> for FsWatcher {
+    type Result = ();
+    fn handle(&mut self, msg: InnerChangeEvent, _ctx: &mut Self::Context) -> Self::Result {
+        tracing::debug!(?self.ctx, "InnerChangeEvent for FsWatcher");
+        tracing::debug!("  └ sending to {} receivers", self.receivers.len());
+        let relative = match msg.absolute_path.strip_prefix(&self.cwd) {
+            Ok(stripped) => stripped.to_path_buf(),
+            Err(e) => {
+                tracing::debug!(?e, "could not extract the CWD from a path");
+                msg.absolute_path.clone()
+            }
+        };
+        for x in &self.receivers {
+            x.do_send(FsEvent {
+                kind: FsEventKind::Change(ChangeEvent {
+                    absolute_path: msg.absolute_path.clone(),
+                    path: relative.clone(),
+                }),
+                ctx: self.ctx.clone(),
+            })
+        }
+    }
+}
+
+#[derive(actix::Message, Hash, PartialEq, Eq, Ord, PartialOrd, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct MultipleInnerChangeEvent {
+    pub events: Vec<InnerChangeEvent>,
+}
+
+impl Handler<MultipleInnerChangeEvent> for FsWatcher {
+    type Result = ();
+    fn handle(&mut self, msg: MultipleInnerChangeEvent, _ctx: &mut Self::Context) -> Self::Result {
+        tracing::debug!(?self.ctx, "MultipleInnerChangeEvent for FsWatcher");
+        tracing::debug!("  └ got {} events to process", msg.events.len());
+        let now = Instant::now();
+        let unique = msg.events.iter().collect::<BTreeSet<_>>();
+        let original_len = msg.events.len();
+        let unique_len = unique.len();
+        tracing::debug!("  └ {} unique", unique.len());
+
+        let filtered = unique
+            .iter()
+            .map(|inner| PathDescription {
+                absolute: &inner.absolute_path,
+                relative: inner.absolute_path.strip_prefix(&self.cwd).ok(),
+            })
+            .filter(|pd| {
+                if self.filters.is_empty() {
+                    true
+                } else {
+                    self.filters.iter().any(|filter| filter.filter(pd))
+                }
+            })
+            .collect::<Vec<PathDescription>>();
+
+        tracing::debug!("  └ accepted {} after filtering", filtered.len());
+
+        let time = Instant::now() - now;
+        tracing::debug!("took {}ms to process event", time.as_millis());
+
+        if filtered.is_empty() {
+            tracing::debug!("no changes to send. original: {original_len}, filtered: {unique_len}");
+            return;
+        }
+
+        for recipient in &self.receivers {
+            let evt = FsEventKind::ChangeBuffered(BufferedChangeEvent {
+                // this might look expensive, but in reality not expecting more than 1 receiver
+                events: filtered.iter().map(PathDescriptionOwned::from).collect(),
+            });
+            recipient.do_send(FsEvent {
+                kind: evt,
+                ctx: self.ctx.clone(),
+            })
+        }
+    }
+}

package/crates/bsnext_fs/src/lib.rs

@@ -0,0 +1,141 @@
+pub mod actor;
+mod buffered_debounce;
+pub mod filter;
+pub mod inner_fs_event_handler;
+pub mod remove_path_handler;
+pub mod stop_handler;
+mod stream;
+#[cfg(test)]
+mod test;
+pub mod watch_path_handler;
+mod watcher;
+
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+// use tokio_stream::StreamExt;
+
+#[derive(Debug, Copy, Clone)]
+pub enum Debounce {
+    Trailing { duration: Duration },
+    Buffered { duration: Duration },
+}
+
+impl Default for Debounce {
+    fn default() -> Self {
+        Self::Trailing {
+            duration: Duration::from_millis(300),
+        }
+    }
+}
+
+impl Debounce {
+    pub fn trailing_ms(ms: u64) -> Self {
+        Self::Trailing {
+            duration: Duration::from_millis(ms),
+        }
+    }
+    pub fn buffered_ms(ms: u64) -> Self {
+        Self::Buffered {
+            duration: Duration::from_millis(ms),
+        }
+    }
+}
+
+impl Debounce {
+    pub fn duration(&self) -> &Duration {
+        match self {
+            Debounce::Trailing { duration } => duration,
+            Debounce::Buffered { duration } => duration,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum FsEventContext {
+    InputFile { id: u64 },
+    Other { id: u64 },
+}
+
+impl FsEventContext {
+    pub fn id(&self) -> u64 {
+        match self {
+            FsEventContext::InputFile { id } => *id,
+            FsEventContext::Other { id } => *id,
+        }
+    }
+}
+
+impl Default for FsEventContext {
+    fn default() -> Self {
+        Self::Other { id: 1 }
+    }
+}
+
+#[derive(actix::Message, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct FsEvent {
+    pub kind: FsEventKind,
+    pub ctx: FsEventContext,
+}
+
+#[derive(Debug, Clone)]
+pub enum FsEventKind {
+    Change(ChangeEvent),
+    ChangeBuffered(BufferedChangeEvent),
+    PathAdded(PathAddedEvent),
+    PathRemoved(PathRemovedEvent),
+}
+
+#[derive(actix::Message, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct ChangeEvent {
+    pub absolute_path: PathBuf,
+    pub path: PathBuf,
+}
+
+#[derive(Debug, Clone)]
+pub struct PathDescription<'a> {
+    pub absolute: &'a Path,
+    pub relative: Option<&'a Path>,
+}
+
+#[derive(Debug, Clone)]
+pub struct PathDescriptionOwned {
+    pub absolute: PathBuf,
+    pub relative: Option<PathBuf>,
+}
+
+impl<'a> From<&'a PathDescription<'_>> for PathDescriptionOwned {
+    fn from(value: &'a PathDescription<'_>) -> Self {
+        Self {
+            relative: value.relative.map(ToOwned::to_owned),
+            absolute: value.absolute.to_owned(),
+        }
+    }
+}
+
+#[derive(actix::Message, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct BufferedChangeEvent {
+    pub events: Vec<PathDescriptionOwned>,
+}
+
+#[derive(actix::Message, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct PathAddedEvent {
+    pub path: PathBuf,
+    pub debounce: Debounce,
+}
+
+#[derive(actix::Message, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct PathRemovedEvent {
+    pub path: PathBuf,
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum FsWatchError {
+    #[error("Watcher error, original error: {0}")]
+    Watcher(#[from] notify::Error),
+}

package/crates/bsnext_fs/src/remove_path_handler.rs

@@ -0,0 +1,46 @@
+use crate::actor::FsWatcher;
+use crate::{FsEvent, FsEventKind, FsWatchError, PathRemovedEvent};
+use actix::Handler;
+use notify::Watcher;
+use std::path::PathBuf;
+
+#[derive(actix::Message)]
+#[rtype(result = "Result<(), FsWatchError>")]
+pub struct RemoveWatchPath {
+    pub path: PathBuf,
+}
+
+impl Handler<RemoveWatchPath> for FsWatcher {
+    type Result = Result<(), FsWatchError>;
+
+    fn handle(&mut self, msg: RemoveWatchPath, _ctx: &mut Self::Context) -> Self::Result {
+        tracing::trace!(path = ?msg.path, "-> RemoveWatchPath");
+        if let Some(watcher) = self.watcher.as_mut() {
+            match watcher.unwatch(&msg.path) {
+                Ok(_) => {
+                    tracing::info!(?msg.path, "removed!");
+                    let relative = match msg.path.strip_prefix(&self.cwd) {
+                        Ok(stripped) => stripped.to_path_buf(),
+                        Err(e) => {
+                            tracing::debug!(?e, "could not extract the CWD from a path");
+                            msg.path.clone()
+                        }
+                    };
+                    for recip in &self.receivers {
+                        let evt = FsEventKind::PathRemoved(PathRemovedEvent {
+                            path: relative.clone(),
+                        });
+                        recip.do_send(FsEvent {
+                            kind: evt,
+                            ctx: self.ctx.clone(),
+                        })
+                    }
+                }
+                Err(e) => {
+                    tracing::debug!(?e, "could not remove");
+                }
+            }
+        }
+        Ok(())
+    }
+}

package/crates/bsnext_fs/src/stop_handler.rs

@@ -0,0 +1,15 @@
+use crate::actor::FsWatcher;
+use actix::{ActorContext, Handler};
+
+#[derive(actix::Message, Debug, Clone)]
+#[rtype(result = "()")]
+pub struct StopWatcher;
+
+impl Handler<StopWatcher> for FsWatcher {
+    type Result = ();
+
+    fn handle(&mut self, _msg: StopWatcher, ctx: &mut Self::Context) -> Self::Result {
+        self.watcher = None;
+        ctx.stop();
+    }
+}