@browsersync/bslive 0.0.7 → 0.0.9

package/crates/bsnext_system/src/monitor.rs

@@ -0,0 +1,241 @@
+use crate::BsSystem;
+use actix::{Actor, Addr, AsyncContext};
+use std::hash::Hash;
+
+use bsnext_core::dto;
+use bsnext_core::dto::{ExternalEvents, StoppedWatching, Watching};
+use bsnext_core::servers_supervisor::file_changed_handler::{FileChanged, FilesChanged};
+use bsnext_fs::watch_path_handler::RequestWatchPath;
+use bsnext_fs::{Debounce, FsEvent, FsEventContext, FsEventKind};
+use bsnext_input::route::{
+    DebounceDuration, DirRoute, FilterKind, RouteKind, Spec, SpecOpts, WatchOpts,
+};
+use bsnext_input::server_config::Identity;
+use bsnext_input::Input;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use bsnext_fs::actor::FsWatcher;
+
+use tracing::{span, Level};
+
+#[derive(Debug, Clone)]
+pub struct Monitor {
+    pub(crate) addr: Addr<FsWatcher>,
+    pub(crate) path: PathBuf,
+}
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct MonitorInput {
+    pub path: PathBuf,
+    pub cwd: PathBuf,
+}
+
+impl actix::Handler<MonitorInput> for BsSystem {
+    type Result = ();
+
+    fn handle(&mut self, msg: MonitorInput, ctx: &mut Self::Context) -> Self::Result {
+        let mut input_watcher = bsnext_fs::actor::FsWatcher::for_input(&msg.cwd, 0);
+
+        // todo: does this need to be configurable (eg: by main config)?
+        input_watcher.with_debounce(Debounce::Trailing {
+            duration: Duration::from_millis(300),
+        });
+
+        tracing::trace!("[main.rs] starting input monitor");
+
+        let input_watcher_addr = input_watcher.start();
+        self.input_monitors.push(input_watcher_addr.clone());
+
+        input_watcher_addr.do_send(RequestWatchPath {
+            recipients: vec![ctx.address().recipient()],
+            path: msg.path.to_path_buf(),
+        });
+    }
+}
+
+impl actix::Handler<FsEvent> for BsSystem {
+    type Result = ();
+
+    fn handle(&mut self, msg: FsEvent, _ctx: &mut Self::Context) -> Self::Result {
+        match msg.kind {
+            FsEventKind::ChangeBuffered(buffer_change) => {
+                // let id = msg.ctx_id();
+                let paths = buffer_change
+                    .events
+                    .iter()
+                    .map(|evt| evt.absolute.to_owned())
+                    .collect::<Vec<_>>();
+                let as_strings = paths
+                    .iter()
+                    .map(|p| p.to_string_lossy().to_string())
+                    .collect::<Vec<String>>();
+                if let Some(servers) = &self.servers_addr {
+                    servers.do_send(FilesChanged {
+                        paths: paths.clone(),
+                        id: msg.ctx.id(),
+                    })
+                }
+                let evt = ExternalEvents::FilesChanged(dto::FilesChangedDTO { paths: as_strings });
+                self.ext_evt(evt);
+            }
+            FsEventKind::Change(inner) => {
+                let span = span!(Level::TRACE, "FsWatchEvent", ?inner.absolute_path);
+                let _guard = span.enter();
+                match msg.ctx {
+                    FsEventContext::InputFile { id: _ } => {
+                        tracing::info!("InputFile file changed");
+                        let input = Input::from_input_path(&inner.absolute_path);
+
+                        let Ok(input) = input else {
+                            tracing::debug!("ignoring FsWatchEvent because the input was invalid");
+                            let err = input.unwrap_err();
+                            tracing::error!("{}", err);
+                            return;
+                        };
+
+                        self.accept_input(&input);
+                        self.inform_servers(input);
+
+                        let evt = ExternalEvents::InputFileChanged(
+                            dto::FileChanged::from_path_buf(&inner.path),
+                        );
+                        self.ext_evt(evt);
+                    }
+                    FsEventContext::Other { id } => {
+                        tracing::trace!("Other");
+                        // todo: tie these changed to an input identity?
+                        if let Some(servers) = &self.servers_addr {
+                            servers.do_send(FileChanged {
+                                path: inner.absolute_path.clone(),
+                                id,
+                            })
+                        }
+                        let evt = ExternalEvents::FileChanged(dto::FileChanged::from_path_buf(
+                            &inner.path,
+                        ));
+
+                        self.ext_evt(evt);
+                    }
+                }
+            }
+            FsEventKind::PathAdded(path) => {
+                tracing::trace!(?path.path, "path added");
+                let evt =
+                    ExternalEvents::Watching(Watching::from_path_buf(&path.path, path.debounce));
+                self.ext_evt(evt);
+            }
+            FsEventKind::PathRemoved(path) => {
+                tracing::trace!(?path.path, "path removed");
+                let evt =
+                    ExternalEvents::WatchingStopped(StoppedWatching::from_path_buf(&path.path));
+                self.ext_evt(evt);
+            }
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, PartialOrd, Ord, Eq, Hash, Clone)]
+pub enum AnyWatchable {
+    Server(ServerWatchable),
+    Route(RouteWatchable),
+}
+
+impl AnyWatchable {
+    pub fn spec_opts(&self) -> Option<&SpecOpts> {
+        match self {
+            AnyWatchable::Server(server) => server.spec.opts.as_ref(),
+            AnyWatchable::Route(route) => route.spec.opts.as_ref(),
+        }
+    }
+    pub fn watch_path(&self) -> &Path {
+        match self {
+            AnyWatchable::Server(server) => &server.dir,
+            AnyWatchable::Route(route) => &route.dir,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, PartialOrd, Ord, Eq, Hash, Clone)]
+pub struct ServerWatchable {
+    pub server_identity: Identity,
+    pub dir: PathBuf,
+    pub spec: Spec,
+}
+
+#[derive(Debug, PartialEq, PartialOrd, Ord, Eq, Hash, Clone)]
+pub struct RouteWatchable {
+    pub server_identity: Identity,
+    pub route_path: String,
+    pub dir: PathBuf,
+    pub spec: Spec,
+}
+
+pub fn to_server_watchables(input: &Input) -> Vec<ServerWatchable> {
+    input
+        .servers
+        .iter()
+        .flat_map(|server_config| {
+            server_config.watchers.iter().map(|watcher| {
+                // let spec = to_spec(&r.watch_opts);
+                ServerWatchable {
+                    server_identity: server_config.identity.clone(),
+                    dir: PathBuf::from(&watcher.dir),
+                    spec: Spec {
+                        opts: Some(SpecOpts {
+                            debounce: watcher.debounce_ms.map(DebounceDuration::Ms),
+                            filter: watcher.filter.clone(),
+                        }),
+                    },
+                }
+            })
+        })
+        .collect()
+}
+
+pub fn to_route_watchables(input: &Input) -> Vec<RouteWatchable> {
+    input
+        .servers
+        .iter()
+        .flat_map(|server_config| {
+            server_config
+                .routes
+                .iter()
+                .filter(|r| r.watch_opts.is_enabled())
+                .filter_map(|r| match &r.kind {
+                    RouteKind::Html { .. } => None,
+                    RouteKind::Json { .. } => None,
+                    RouteKind::Raw { .. } => None,
+                    RouteKind::Sse { .. } => None,
+                    RouteKind::Proxy(_) => None,
+                    RouteKind::Dir(DirRoute { dir }) => {
+                        let spec = to_spec(&r.watch_opts);
+                        Some(RouteWatchable {
+                            server_identity: server_config.identity.clone(),
+                            route_path: r.path.to_string(),
+                            dir: PathBuf::from(dir),
+                            spec,
+                        })
+                    }
+                })
+        })
+        .collect()
+}
+
+fn to_spec(wo: &WatchOpts) -> Spec {
+    match wo {
+        WatchOpts::Bool(enabled) if !*enabled => unreachable!("should be handled..."),
+        WatchOpts::Bool(enabled) if *enabled => Spec { opts: None },
+        WatchOpts::InlineGlob(glob) => Spec {
+            opts: Some(SpecOpts {
+                debounce: None,
+                filter: Some(FilterKind::Glob {
+                    glob: glob.to_string(),
+                }),
+            }),
+        },
+        WatchOpts::Spec(spec) => spec.to_owned(),
+        WatchOpts::Bool(_) => todo!("unreachable"),
+    }
+}

package/crates/bsnext_system/src/monitor_any_watchables.rs

@@ -0,0 +1,127 @@
+use crate::monitor::{AnyWatchable, Monitor};
+use crate::BsSystem;
+use actix::{Actor, AsyncContext};
+use bsnext_fs::actor::FsWatcher;
+use bsnext_fs::filter::Filter;
+use bsnext_fs::stop_handler::StopWatcher;
+use bsnext_fs::watch_path_handler::RequestWatchPath;
+use bsnext_fs::Debounce;
+use bsnext_input::route::{DebounceDuration, FilterKind, SpecOpts};
+use std::collections::BTreeSet;
+use std::path::PathBuf;
+use std::time::Duration;
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct MonitorAnyWatchables {
+    pub watchables: Vec<AnyWatchable>,
+    pub cwd: PathBuf,
+}
+
+impl actix::Handler<MonitorAnyWatchables> for BsSystem {
+    type Result = ();
+
+    fn handle(&mut self, msg: MonitorAnyWatchables, ctx: &mut Self::Context) -> Self::Result {
+        tracing::debug!("MonitorAnyWatchables {:?}", msg.watchables);
+        tracing::trace!("MonitorAnyWatchables {:#?}", msg.watchables);
+
+        let existing = self.any_monitors.keys().collect::<BTreeSet<_>>();
+        let incoming = msg.watchables.iter().collect::<BTreeSet<_>>();
+
+        let in_both = incoming.intersection(&existing).collect::<Vec<_>>();
+        let to_add = incoming.difference(&existing).collect::<Vec<_>>();
+        let to_remove = existing.difference(&incoming).collect::<Vec<_>>();
+
+        tracing::debug!("{} watchables exist in current + incoming", in_both.len());
+        tracing::debug!("removing {} watchables", to_remove.len());
+
+        for any_watchable in to_remove {
+            if let Some(mon) = self.any_monitors.get(any_watchable) {
+                mon.addr.do_send(StopWatcher);
+                ctx.notify(DropMonitor((*any_watchable).clone()))
+            }
+        }
+
+        tracing::debug!("adding {} new watchables", to_add.len());
+        for watchable in to_add {
+            let mut input_watcher = match watchable {
+                AnyWatchable::Server(server_watchable) => {
+                    FsWatcher::new(&msg.cwd, server_watchable.server_identity.as_id())
+                }
+                AnyWatchable::Route(route_watchable) => {
+                    FsWatcher::new(&msg.cwd, route_watchable.server_identity.as_id())
+                }
+            };
+
+            if let Some(opts) = &watchable.spec_opts() {
+                // todo: handle the specs here!
+                if let Some(filter) = &opts.filter {
+                    let f = match filter {
+                        FilterKind::Extension { ext } => Filter::Extension {
+                            ext: ext.to_string(),
+                        },
+                        FilterKind::StringGlob(glob) => Filter::Glob {
+                            glob: glob.to_owned(),
+                        },
+                        FilterKind::Glob { glob } => Filter::Glob {
+                            glob: glob.to_owned(),
+                        },
+                    };
+                    input_watcher.with_filter(f);
+                }
+            }
+
+            let duration = match &watchable.spec_opts() {
+                Some(SpecOpts {
+                    debounce: Some(DebounceDuration::Ms(ms)),
+                    ..
+                }) => Duration::from_millis(*ms),
+                _ => Duration::from_millis(300),
+            };
+
+            input_watcher.with_debounce(Debounce::Buffered { duration });
+
+            let input_watcher_addr = input_watcher.start();
+
+            let monitor = Monitor {
+                addr: input_watcher_addr.clone(),
+                path: watchable.watch_path().to_path_buf(),
+            };
+
+            monitor.addr.do_send(RequestWatchPath {
+                recipients: vec![ctx.address().recipient()],
+                path: monitor.path.clone(),
+            });
+
+            ctx.notify(InsertMonitor((*watchable).clone(), monitor))
+        }
+    }
+}
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+struct DropMonitor(AnyWatchable);
+
+impl actix::Handler<DropMonitor> for BsSystem {
+    type Result = ();
+
+    fn handle(&mut self, msg: DropMonitor, _ctx: &mut Self::Context) -> Self::Result {
+        tracing::trace!(watchable=?msg.0, "DropMonitor");
+        self.any_monitors.remove(&msg.0);
+        tracing::trace!("dropped, Monitor count {}", self.any_monitors.len());
+    }
+}
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+struct InsertMonitor(AnyWatchable, Monitor);
+
+impl actix::Handler<InsertMonitor> for BsSystem {
+    type Result = ();
+
+    fn handle(&mut self, msg: InsertMonitor, _ctx: &mut Self::Context) -> Self::Result {
+        tracing::trace!(watchable=?msg.0, "InsertMonitor");
+        self.any_monitors.insert(msg.0, msg.1);
+        tracing::trace!("inserted, Monitor count {}", self.any_monitors.len());
+    }
+}

package/crates/bsnext_system/src/start_kind/snapshots/bsnext_system__start_kind__start_from_paths__test__test-2.snap

@@ -0,0 +1,11 @@
+---
+source: bsnext_system/src/start_kind/start_from_paths.rs
+expression: input
+---
+servers:
+  - bind_address: "0.0.0.0:3000"
+    routes:
+      - path: /
+        watch: true
+        dir: "."
+    watchers: []

package/crates/bsnext_system/src/start_kind/snapshots/bsnext_system__start_kind__start_from_paths__test__test.snap

@@ -0,0 +1,29 @@
+---
+source: bsnext_system/src/start_kind/start_from_paths.rs
+expression: input
+---
+Input {
+    servers: [
+        ServerConfig {
+            identity: Address {
+                bind_address: "0.0.0.0:3000",
+            },
+            routes: [
+                Route {
+                    path: "/",
+                    cors_opts: None,
+                    delay_opts: None,
+                    watch_opts: Bool(
+                        true,
+                    ),
+                    kind: Dir(
+                        DirRoute {
+                            dir: ".",
+                        },
+                    ),
+                },
+            ],
+            watchers: [],
+        },
+    ],
+}

package/crates/bsnext_system/src/start_kind/start_from_example.rs

@@ -0,0 +1,49 @@
+use crate::startup::{StartupContext, SystemStart};
+use bsnext_example::Example;
+use bsnext_input::server_config::Identity;
+use bsnext_input::target::TargetKind;
+use bsnext_input::{fs_write_input, rand_word, DirError, Input, InputError};
+use std::fs;
+use std::path::PathBuf;
+
+#[derive(Debug)]
+pub struct StartFromExample {
+    pub example: Example,
+    pub write_input: bool,
+    pub target_kind: TargetKind,
+    pub port: Option<u16>,
+    pub temp: bool,
+    pub name: Option<String>,
+}
+
+impl SystemStart for StartFromExample {
+    fn input(&self, ctx: &StartupContext) -> Result<(Input, Option<PathBuf>), InputError> {
+        let identity = Identity::from_port_or_named(self.port)?;
+        let input = self.example.into_input(identity);
+        let name = self.name.clone();
+        let dir = if self.temp {
+            let temp_dir = std::env::temp_dir();
+            let word = name.unwrap_or_else(rand_word);
+            let num = rand::random::<f64>();
+            let next_dir = temp_dir.join(format!("bslive-{word}-{num}"));
+            fs::create_dir_all(&next_dir)
+                .map_err(|_e| DirError::CannotCreate {
+                    path: next_dir.clone(),
+                })
+                .and_then(|_pb| {
+                    std::env::set_current_dir(&next_dir).map_err(|_e| DirError::CannotMove {
+                        path: next_dir.clone(),
+                    })
+                })
+                .map(|_| next_dir.clone())?
+        } else {
+            ctx.cwd.to_path_buf()
+        };
+        if self.write_input {
+            let path = fs_write_input(&dir, &input, self.target_kind.clone())?;
+            Ok((input, Some(path)))
+        } else {
+            Ok((input, None))
+        }
+    }
+}

package/crates/bsnext_system/src/start_kind/start_from_inputs.rs

@@ -0,0 +1,67 @@
+use crate::startup::{StartupContext, SystemStart};
+
+use bsnext_input::{Input, InputError};
+use std::path::{Path, PathBuf};
+
+#[derive(Debug)]
+pub struct StartFromInputPaths {
+    pub input_paths: Vec<String>,
+}
+
+impl SystemStart for StartFromInputPaths {
+    fn input(&self, ctx: &StartupContext) -> Result<(Input, Option<PathBuf>), InputError> {
+        let (input, path) = from_yml_paths(&ctx.cwd, &self.input_paths)?;
+        Ok((input, Some(path)))
+    }
+}
+
+fn from_yml_paths<T: AsRef<str>>(cwd: &Path, inputs: &[T]) -> Result<(Input, PathBuf), InputError> {
+    let input_candidates = inputs
+        .iter()
+        .map(|path| cwd.join(path.as_ref()))
+        .collect::<Vec<PathBuf>>();
+
+    let lookups = ["input.yml", "input.yaml"]
+        .iter()
+        .map(|path| cwd.join(path))
+        .collect::<Vec<PathBuf>>();
+
+    let auto_candidates = lookups
+        .iter()
+        .filter(|path| Path::exists(path))
+        .collect::<Vec<&PathBuf>>();
+
+    let exists = input_candidates
+        .iter()
+        .filter(|path| Path::exists(path))
+        .collect::<Vec<&PathBuf>>();
+
+    let missing = input_candidates
+        .iter()
+        .filter(|path| !Path::exists(path))
+        .collect::<Vec<&PathBuf>>();
+
+    if !missing.is_empty() {
+        for path in &missing {
+            tracing::error!(?path, "input file not found");
+        }
+        return Err(InputError::NotFound(
+            missing.first().expect("guarded").to_path_buf(),
+        ));
+    }
+
+    let first_user = exists.first();
+    let first_auto = auto_candidates.first();
+
+    let Some(input_path) = first_user.or(first_auto) else {
+        return Err(InputError::MissingInputs);
+    };
+
+    tracing::info!(?input_path);
+
+    let result = Input::from_input_path(input_path);
+    match result {
+        Ok(input) => Ok((input, input_path.to_path_buf())),
+        Err(e) => Err(InputError::InvalidInput(e.to_string())),
+    }
+}

package/crates/bsnext_system/src/start_kind/start_from_paths.rs

@@ -0,0 +1,51 @@
+use crate::startup::{StartupContext, SystemStart};
+use bsnext_input::paths::from_paths;
+use bsnext_input::server_config::Identity;
+use bsnext_input::target::TargetKind;
+use bsnext_input::{fs_write_input, Input, InputError};
+use std::path::PathBuf;
+
+#[derive(Debug)]
+pub struct StartFromPaths {
+    pub paths: Vec<String>,
+    pub write_input: bool,
+    pub port: Option<u16>,
+}
+
+impl SystemStart for StartFromPaths {
+    fn input(&self, ctx: &StartupContext) -> Result<(Input, Option<PathBuf>), InputError> {
+        let identity = Identity::from_port_or_named(self.port)?;
+        let input = from_paths(&ctx.cwd, &self.paths, identity)?;
+        if self.write_input {
+            let path = fs_write_input(&ctx.cwd, &input, TargetKind::Yaml)?;
+
+            Ok((input, Some(path)))
+        } else {
+            Ok((input, None))
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test() -> anyhow::Result<()> {
+        use tempfile::tempdir;
+        let tmp_dir = tempdir()?;
+        let v = StartFromPaths {
+            paths: vec![".".into()],
+            write_input: false,
+            port: Some(3000),
+        };
+        let ctx = StartupContext {
+            cwd: tmp_dir.path().to_path_buf(),
+        };
+        let i = v.input(&ctx);
+        tmp_dir.close()?;
+        let (input, _) = i.unwrap();
+        insta::assert_debug_snapshot!(input);
+        insta::assert_yaml_snapshot!(input);
+        Ok(())
+    }
+}

package/crates/bsnext_system/src/start_kind.rs

@@ -0,0 +1,56 @@
+use crate::args::Args;
+use crate::start_kind::start_from_example::StartFromExample;
+use crate::start_kind::start_from_inputs::StartFromInputPaths;
+use crate::start_kind::start_from_paths::StartFromPaths;
+use crate::startup::{StartupContext, SystemStart};
+
+use bsnext_input::{Input, InputError};
+use std::path::PathBuf;
+
+pub mod start_from_example;
+pub mod start_from_inputs;
+pub mod start_from_paths;
+
+#[derive(Debug)]
+pub enum StartKind {
+    FromInputs(StartFromInputPaths),
+    FromExample(StartFromExample),
+    FromPaths(StartFromPaths),
+}
+
+impl StartKind {
+    pub fn from_args(args: Args) -> Self {
+        if let Some(example) = args.example {
+            return StartKind::FromExample(StartFromExample {
+                example,
+                write_input: args.write,
+                port: args.port,
+                temp: args.temp,
+                name: args.name,
+                target_kind: args.target.unwrap_or_default(),
+            });
+        }
+
+        if !args.paths.is_empty() {
+            StartKind::FromPaths(StartFromPaths {
+                paths: args.paths,
+                write_input: args.write,
+                port: args.port,
+            })
+        } else {
+            StartKind::FromInputs(StartFromInputPaths {
+                input_paths: args.input.clone(),
+            })
+        }
+    }
+}
+
+impl SystemStart for StartKind {
+    fn input(&self, ctx: &StartupContext) -> Result<(Input, Option<PathBuf>), InputError> {
+        match self {
+            Self::FromInputs(from_inputs) => from_inputs.input(ctx),
+            Self::FromExample(from_example) => from_example.input(ctx),
+            Self::FromPaths(from_paths) => from_paths.input(ctx),
+        }
+    }
+}

package/crates/bsnext_system/src/startup.rs

@@ -0,0 +1,51 @@
+use bsnext_input::{Input, InputError};
+use std::env::current_dir;
+use std::path::PathBuf;
+
+pub type StartupResult = Result<DidStart, StartupError>;
+
+pub struct Startup {
+    pub tasks: Vec<StartupTask>,
+}
+#[derive(Debug)]
+pub struct StartupContext {
+    pub cwd: PathBuf,
+}
+
+impl StartupContext {
+    pub fn from_cwd(cwd: Option<&PathBuf>) -> Self {
+        StartupContext {
+            cwd: cwd.map(ToOwned::to_owned).unwrap_or_else(|| {
+                PathBuf::from(
+                    current_dir()
+                        .expect("if current_dir fails, nothing can work")
+                        .to_string_lossy()
+                        .to_string(),
+                )
+            }),
+        }
+    }
+}
+
+pub trait SystemStart {
+    fn input(&self, ctx: &StartupContext) -> Result<(Input, Option<PathBuf>), InputError>;
+}
+
+impl Default for StartupContext {
+    fn default() -> Self {
+        Self::from_cwd(None)
+    }
+}
+
+#[derive(Debug)]
+pub enum DidStart {
+    Started,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum StartupError {
+    #[error("An input error prevented startup")]
+    InputError(#[from] InputError),
+}
+
+pub enum StartupTask {}

package/crates/bsnext_tracing/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "bsnext_tracing"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tracing-subscriber = { workspace = true }
+clap = { workspace = true }