@browsersync/bslive 0.0.5 → 0.0.9

package/crates/bsnext_output/src/pretty.rs

@@ -0,0 +1,147 @@
+use crate::OutputWriter;
+use bsnext_core::dto::{
+    ExternalEvents, FileChanged, FilesChangedDTO, IdentityDTO, InputAccepted, ServerChange,
+    ServerChangeSetItem, ServersStarted, StoppedWatching, Watching,
+};
+use std::io::Write;
+use std::path::PathBuf;
+
+pub struct PrettyPrint;
+
+impl OutputWriter for PrettyPrint {
+    fn handle_event<W: Write>(&self, sink: &mut W, evt: &ExternalEvents) -> anyhow::Result<()> {
+        match &evt {
+            ExternalEvents::ServersStarted(servers_started) => {
+                print_server_started(sink, servers_started)
+            }
+            ExternalEvents::StartupFailed(_input_err) => {
+                unreachable!("StartupFailed")
+            }
+            ExternalEvents::Watching(watching) => print_watching(sink, watching),
+            ExternalEvents::WatchingStopped(watching) => print_stopped_watching(sink, watching),
+            ExternalEvents::InputAccepted(input_accepted) => {
+                print_input_accepted(sink, input_accepted)
+            }
+            ExternalEvents::FileChanged(file_changed) => print_file_changed(sink, file_changed),
+            ExternalEvents::FilesChanged(files_changed) => print_files_changed(sink, files_changed),
+            ExternalEvents::InputFileChanged(file_changed) => {
+                print_input_file_changed(sink, file_changed)
+            }
+        }
+    }
+}
+
+pub fn print_file_changed<W: Write>(w: &mut W, evt: &FileChanged) -> anyhow::Result<()> {
+    writeln!(w, "[change] {}", evt.path)?;
+    Ok(())
+}
+
+pub fn print_files_changed<W: Write>(w: &mut W, evt: &FilesChangedDTO) -> anyhow::Result<()> {
+    match evt.paths.len() {
+        0 | 1 | 2 => {
+            writeln!(w, "[multi-change] {}", short_file_list(&evt.paths))?;
+        }
+        3.. => {
+            let other = evt.paths.len() - 2;
+            let subset = evt.paths.iter().take(2).collect::<Vec<_>>();
+            writeln!(
+                w,
+                "[multi-change] {} (and {} others)",
+                short_file_list(&subset),
+                other
+            )?;
+        }
+    }
+    Ok(())
+}
+
+fn short_file_list<A: AsRef<str>>(paths: &[A]) -> String {
+    let file_names = paths
+        .iter()
+        .filter_map(|p| {
+            PathBuf::from(p.as_ref())
+                .file_name()
+                .map(|filename| filename.to_string_lossy().to_string())
+        })
+        .collect::<Vec<_>>();
+    file_names.join(", ")
+}
+
+pub fn print_input_file_changed<W: Write>(w: &mut W, evt: &FileChanged) -> anyhow::Result<()> {
+    writeln!(w, "[change:input] {}", evt.path)?;
+    Ok(())
+}
+
+pub fn print_input_accepted<W: Write>(w: &mut W, evt: &InputAccepted) -> anyhow::Result<()> {
+    writeln!(w, "[input] {}", evt.path)?;
+    Ok(())
+}
+
+pub fn print_watching<W: Write>(w: &mut W, evt: &Watching) -> anyhow::Result<()> {
+    for x in &evt.paths {
+        writeln!(w, "[watching {}] {}", evt.debounce, x)?;
+    }
+    Ok(())
+}
+
+pub fn print_stopped_watching<W: Write>(w: &mut W, evt: &StoppedWatching) -> anyhow::Result<()> {
+    for x in &evt.paths {
+        writeln!(w, "[watching:stopped] {}", x)?;
+    }
+    Ok(())
+}
+
+fn print_server_started<W>(w: &mut W, servers_started: &ServersStarted) -> anyhow::Result<()>
+where
+    W: Write,
+{
+    let ServersStarted {
+        servers_resp,
+        changeset,
+    } = servers_started;
+
+    for ServerChangeSetItem { change, identity } in &changeset.items {
+        let running = servers_resp
+            .servers
+            .iter()
+            .find(|x| x.identity == *identity);
+        match change {
+            ServerChange::Stopped { bind_address } => match &identity {
+                IdentityDTO::Both { name, bind_address } => {
+                    writeln!(w, "[server removed] [{name}] http://{bind_address}")?;
+                }
+                IdentityDTO::Address { bind_address } => {
+                    writeln!(w, "[server removed] http://{bind_address}")?;
+                }
+                IdentityDTO::Named { name } => {
+                    writeln!(w, "[server removed] [{name}] http://{}", bind_address)?;
+                }
+            },
+            ServerChange::Started => match &identity {
+                IdentityDTO::Both { name, bind_address } => {
+                    if running.is_some() {
+                        writeln!(w, "[server added] [{}] http://{}", name, bind_address)?;
+                    }
+                }
+                IdentityDTO::Address { bind_address } => {
+                    if running.is_some() {
+                        writeln!(w, "[server added] http://{}", bind_address)?;
+                    }
+                }
+                IdentityDTO::Named { name } => {
+                    if let Some(running) = running {
+                        writeln!(
+                            w,
+                            "[server added] [{}] http://{}",
+                            name, &running.socket_addr
+                        )?;
+                    } else {
+                        unreachable!("?");
+                    }
+                }
+            },
+            ServerChange::Patched => {}
+        }
+    }
+    Ok(())
+}

package/crates/bsnext_resp/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "bsnext_resp"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tracing = { workspace = true }
+axum = { workspace = true }
+http = { workspace = true }
+bytes = { workspace = true }
+http-body-util = { workspace = true }

package/crates/bsnext_resp/src/js/snippet.html

@@ -0,0 +1 @@
+<script type="module" src="/__bs_js"></script>

package/crates/bsnext_resp/src/js/ws.js

@@ -0,0 +1 @@
+// todo

package/crates/bsnext_resp/src/lib.rs

@@ -0,0 +1,79 @@
+use axum::body::Body;
+use axum::extract::Request;
+use axum::middleware::Next;
+use axum::response::IntoResponse;
+use bytes::Bytes;
+use http::header::{ACCEPT, CONTENT_LENGTH, CONTENT_TYPE};
+use http::{Response, StatusCode};
+use tracing::{span, Level};
+
+pub struct RespMod;
+
+impl RespMod {
+    pub fn accepts_html(req: &Request) -> bool {
+        req.headers()
+            .get(ACCEPT)
+            .and_then(|v| v.to_str().ok().map(|s| s.contains("text/html")))
+            .unwrap_or(false)
+    }
+    pub fn is_html<T>(res: &Response<T>) -> bool {
+        res.headers()
+            .get(CONTENT_TYPE)
+            .and_then(|v| v.to_str().ok().map(|s| s.contains("text/html")))
+            .unwrap_or(false)
+    }
+}
+
+pub async fn response_modifications_layer(
+    req: Request,
+    next: Next,
+) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let span = span!(parent: None, Level::TRACE, "resp-mod", uri=req.uri().path());
+    let _guard = span.enter();
+    let accepts_html = RespMod::accepts_html(&req);
+
+    let mut r = next.run(req).await;
+    let is_html = RespMod::is_html(&r);
+    if let (true, true) = (accepts_html, is_html) {
+        use http_body_util::BodyExt;
+        r.headers_mut()
+            .insert("x-bslive-inject", "true".parse().unwrap());
+        let (mut parts, body) = r.into_parts();
+
+        let bytes = match body.collect().await {
+            Ok(collected) => collected.to_bytes(),
+            Err(err) => {
+                return Err((
+                    StatusCode::BAD_REQUEST,
+                    format!("failed to read body: {err}"),
+                ))
+            }
+        };
+
+        if let Ok(body) = std::str::from_utf8(&bytes) {
+            tracing::trace!("replacing body content");
+            let next_body = body.replace(
+                "</body>",
+                format!(
+                    "<!-- source: snippet.html-->\
+                {}\
+                \
+                <!-- end: snippet.html-->
+                </body>",
+                    include_str!("js/snippet.html")
+                )
+                .as_str(),
+            );
+            let as_bytes = Bytes::from(next_body);
+            parts.headers.insert(CONTENT_LENGTH, as_bytes.len().into());
+            Ok(Response::from_parts(parts, Body::from(as_bytes)))
+        } else {
+            tracing::trace!("could not decode from bytes");
+            dbg!(&parts.headers);
+            Ok((parts, bytes).into_response())
+        }
+    } else {
+        tracing::trace!("not collecting body");
+        Ok(r.into_response())
+    }
+}

package/crates/bsnext_system/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "bsnext_system"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bsnext_input = { path = "../bsnext_input" }
+bsnext_tracing = { path = "../bsnext_tracing" }
+bsnext_core = { path = "../bsnext_core" }
+bsnext_fs = { path = "../bsnext_fs" }
+bsnext_example = { path = "../bsnext_example" }
+rand = "0.8.5"
+
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+clap = { workspace = true }
+tokio = { workspace = true }
+serde = { workspace = true }
+serde_yaml = { workspace = true }
+actix = { workspace = true }
+actix-rt = { workspace = true }
+tracing = { workspace = true }
+random_word = { workspace = true }
+tempfile = { workspace = true }
+
+[dev-dependencies]
+insta = { version = "1.38.0", features = ["yaml"] }

package/crates/bsnext_system/src/args.rs

@@ -0,0 +1,43 @@
+use crate::Example;
+use bsnext_input::target::TargetKind;
+use bsnext_tracing::{LogLevel, OutputFormat};
+
+#[derive(clap::Parser, Debug)]
+pub struct Args {
+    #[arg(short, long, value_enum)]
+    pub log_level: Option<LogLevel>,
+
+    #[arg(short, long, value_enum)]
+    pub format: Option<OutputFormat>,
+
+    /// Input files
+    #[arg(short, long)]
+    pub input: Vec<String>,
+
+    /// Write input to disk
+    #[arg(long)]
+    pub write: bool,
+
+    /// Write input to disk
+    #[arg(long, requires = "write")]
+    pub target: Option<TargetKind>,
+
+    #[arg(long, value_enum)]
+    pub example: Option<Example>,
+
+    /// create a temp folder for examples instead of using the current dir
+    #[arg(long, requires = "example")]
+    pub temp: bool,
+
+    /// create a temp folder for examples instead of using the current dir
+    #[arg(long, requires = "example")]
+    pub name: Option<String>,
+
+    /// Only works with `--example` - specify a port instead of a random one    
+    #[arg(short, long)]
+    pub port: Option<u16>,
+
+    /// Paths to watch, incompatible with `-i` option
+    #[arg(trailing_var_arg = true, allow_hyphen_values = true, long)]
+    pub paths: Vec<String>,
+}

package/crates/bsnext_system/src/lib.rs

@@ -0,0 +1,227 @@
+use crate::monitor::{
+    to_route_watchables, to_server_watchables, AnyWatchable, Monitor, MonitorInput,
+};
+use actix::{Actor, Addr, AsyncContext, Handler, Running};
+
+use bsnext_input::Input;
+use std::collections::HashMap;
+
+use actix_rt::Arbiter;
+use bsnext_core::dto::{ExternalEvents, ServersStarted};
+use std::path::PathBuf;
+
+use bsnext_example::Example;
+
+use crate::startup::{DidStart, StartupContext, StartupError, StartupResult, SystemStart};
+use bsnext_core::servers_supervisor::actor::ServersSupervisor;
+use bsnext_core::servers_supervisor::get_servers_handler::GetServersMessage;
+use bsnext_core::servers_supervisor::input_changed_handler::InputChanged;
+
+use bsnext_fs::actor::FsWatcher;
+
+use crate::monitor_any_watchables::MonitorAnyWatchables;
+use start_kind::StartKind;
+use tokio::sync::mpsc::Sender;
+use tokio::sync::oneshot;
+
+pub mod args;
+mod monitor;
+mod monitor_any_watchables;
+pub mod start_kind;
+pub mod startup;
+
+pub struct BsSystem {
+    self_addr: Option<Addr<BsSystem>>,
+    servers_addr: Option<Addr<ServersSupervisor>>,
+    events_sender: Option<Sender<ExternalEvents>>,
+    input_monitors: Vec<Addr<FsWatcher>>,
+    any_monitors: HashMap<AnyWatchable, Monitor>,
+    cwd: Option<PathBuf>,
+}
+
+impl Default for BsSystem {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Handler<StopSystem> for BsSystem {
+    type Result = ();
+
+    fn handle(&mut self, _msg: StopSystem, _ctx: &mut Self::Context) -> Self::Result {
+        todo!("can the system as a whole be stopped?")
+    }
+}
+
+impl BsSystem {
+    pub fn new() -> Self {
+        BsSystem {
+            self_addr: None,
+            servers_addr: None,
+            events_sender: None,
+            input_monitors: vec![],
+            any_monitors: Default::default(),
+            cwd: None,
+        }
+    }
+
+    fn accept_input(&mut self, input: &Input) {
+        let route_watchables = to_route_watchables(input);
+        let server_watchables = to_server_watchables(input);
+
+        tracing::debug!(
+            "accepting {} route watchables, and {} server watchables",
+            route_watchables.len(),
+            server_watchables.len()
+        );
+
+        let Some(self_address) = &self.self_addr else {
+            unreachable!("?")
+        };
+
+        let Some(cwd) = &self.cwd else {
+            unreachable!("can this occur?")
+        };
+
+        // todo: clean up this merging
+        let mut routes = route_watchables
+            .iter()
+            .map(|r| AnyWatchable::Route(r.to_owned()))
+            .collect::<Vec<_>>();
+
+        let servers = server_watchables
+            .iter()
+            .map(|w| AnyWatchable::Server(w.to_owned()))
+            .collect::<Vec<_>>();
+
+        routes.extend(servers);
+
+        self_address.do_send(MonitorAnyWatchables {
+            watchables: routes,
+            cwd: cwd.clone(),
+        });
+    }
+
+    fn inform_servers(&mut self, input: Input) {
+        let Some(servers_addr) = &self.servers_addr else {
+            unreachable!("self.servers_addr cannot exist?");
+        };
+        Arbiter::current().spawn({
+            let addr = servers_addr.clone();
+            let events_sender = self.events_sender.as_ref().unwrap().clone();
+            async move {
+                let results = addr.send(InputChanged { input }).await;
+                let Ok(changeset) = results else {
+                    unreachable!("?1")
+                };
+                let servers = addr.send(GetServersMessage).await;
+                let Ok(servers_resp) = servers else {
+                    unreachable!("?2")
+                };
+
+                let output = ExternalEvents::ServersStarted(ServersStarted {
+                    servers_resp,
+                    changeset,
+                });
+                match events_sender.send(output).await {
+                    Ok(_) => tracing::trace!("Ok"),
+                    Err(_) => tracing::trace!("Err"),
+                };
+            }
+        });
+    }
+
+    fn ext_evt(&mut self, evt: ExternalEvents) {
+        if let Some(sender) = &self.events_sender {
+            Arbiter::current().spawn({
+                let events_sender = sender.clone();
+                async move {
+                    match events_sender.send(evt).await {
+                        Ok(_) => {}
+                        Err(_) => tracing::error!("could not send"),
+                    }
+                }
+            });
+        }
+    }
+}
+
+impl Actor for BsSystem {
+    type Context = actix::Context<Self>;
+
+    fn started(&mut self, ctx: &mut Self::Context) {
+        tracing::trace!(actor.name = "BsSystem", actor.lifecyle = "started");
+        self.self_addr = Some(ctx.address());
+    }
+
+    fn stopping(&mut self, _ctx: &mut Self::Context) -> Running {
+        tracing::trace!(actor.name = "BsSystem", actor.lifecyle = "stopping");
+        Running::Stop
+    }
+
+    fn stopped(&mut self, _ctx: &mut Self::Context) {
+        tracing::trace!(actor.name = "BsSystem", actor.lifecyle = "stopped");
+        self.self_addr = None;
+        self.servers_addr = None;
+        self.events_sender = None;
+    }
+}
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct StopSystem;
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct Start {
+    pub kind: StartKind,
+    pub cwd: Option<PathBuf>,
+    pub ack: oneshot::Sender<()>,
+    pub events_sender: Sender<ExternalEvents>,
+    pub startup_oneshot_sender: oneshot::Sender<StartupResult>,
+}
+
+impl Handler<Start> for BsSystem {
+    type Result = ();
+
+    fn handle(&mut self, msg: Start, ctx: &mut Self::Context) -> Self::Result {
+        self.events_sender = Some(msg.events_sender.clone());
+        self.cwd = msg.cwd;
+
+        let Some(cwd) = &self.cwd else {
+            unreachable!("?")
+        };
+
+        let servers = ServersSupervisor::new(msg.ack);
+        // store the servers addr for later
+        self.servers_addr = Some(servers.start());
+
+        let start_context = StartupContext::from_cwd(self.cwd.as_ref());
+
+        match msg.kind.input(&start_context) {
+            Ok((input, Some(path))) => {
+                ctx.address().do_send(MonitorInput {
+                    path: path.clone(),
+                    cwd: cwd.clone(),
+                });
+
+                self.accept_input(&input);
+                self.inform_servers(input);
+            }
+            Ok((input, None)) => {
+                self.accept_input(&input);
+                self.inform_servers(input);
+            }
+            Err(e) => {
+                msg.startup_oneshot_sender
+                    .send(Err(StartupError::InputError(e)))
+                    .expect("oneshot must succeed");
+                return;
+            }
+        }
+
+        msg.startup_oneshot_sender
+            .send(Ok(DidStart::Started))
+            .expect("oneshot started must succeed")
+    }
+}