@browsersync/bslive 0.0.7 → 0.0.13

package/crates/bsnext_core/src/not_found/not_found_service.rs

@@ -0,0 +1,35 @@
+use axum::extract::Request;
+use axum::middleware::Next;
+
+use axum::response::{IntoResponse, Response};
+
+use http::header::CONTENT_TYPE;
+use http::{HeaderValue, StatusCode};
+use mime_guess::mime;
+
+use crate::handlers::proxy::AnyAppError;
+
+use bsnext_client::html_with_base;
+use tracing::{span, Level};
+
+pub async fn not_found_loader(req: Request, next: Next) -> Result<Response, AnyAppError> {
+    let span = span!(parent: None, Level::INFO, "not_found", path = req.uri().path());
+    let _guard = span.enter();
+
+    let r = next.run(req).await;
+    if r.status().as_u16() != 404 {
+        return Ok(r);
+    };
+
+    let markup = html_with_base("/__bs_assets/ui/");
+
+    Ok((
+        StatusCode::NOT_FOUND,
+        [(
+            CONTENT_TYPE,
+            HeaderValue::from_static(mime::TEXT_HTML_UTF_8.as_ref()),
+        )],
+        markup,
+    )
+        .into_response())
+}

package/crates/bsnext_core/src/panic_handler.rs

@@ -0,0 +1,32 @@
+use axum::http::{
+    header::{self},
+    Response, StatusCode,
+};
+use bytes::Bytes;
+use http_body_util::Full;
+use std::any::Any;
+
+pub fn handle_panic(err: Box<dyn Any + Send + 'static>) -> Response<Full<Bytes>> {
+    let details = if let Some(s) = err.downcast_ref::<String>() {
+        s.clone()
+    } else if let Some(s) = err.downcast_ref::<&str>() {
+        s.to_string()
+    } else {
+        "Unknown panic message".to_string()
+    };
+
+    let body = serde_json::json!({
+        "error": {
+            "kind": "panic",
+            "details": details,
+        }
+    });
+
+    let body = serde_json::to_string(&body).unwrap();
+
+    Response::builder()
+        .status(StatusCode::INTERNAL_SERVER_ERROR)
+        .header(header::CONTENT_TYPE, "application/json")
+        .body(Full::from(body))
+        .unwrap()
+}

package/crates/bsnext_core/src/raw_loader.rs

@@ -0,0 +1,196 @@
+use std::convert::Infallible;
+
+use axum::extract::{Request, State};
+use axum::middleware::Next;
+use axum::response::{Html, IntoResponse, Response, Sse};
+use axum::routing::any;
+use axum::{middleware, Json, Router};
+use http::header::CONTENT_TYPE;
+
+use crate::meta::MetaData;
+use crate::server::state::ServerState;
+use axum::body::Body;
+use axum::response::sse::Event;
+use bsnext_input::route::{DirRoute, ProxyRoute, RouteKind};
+use bsnext_resp::response_modifications_layer;
+use bytes::Bytes;
+use http::StatusCode;
+use http_body_util::BodyExt;
+use std::sync::Arc;
+use std::time::Duration;
+
+use tokio_stream::StreamExt;
+use tower::ServiceExt;
+
+use crate::common_layers::add_route_layers;
+use tracing::{span, Level};
+
+// use futures_util::stream::{self, Stream};
+
+pub async fn raw_loader(
+    State(app): State<Arc<ServerState>>,
+    req: Request,
+    next: Next,
+) -> impl IntoResponse {
+    let span = span!(parent: None, Level::INFO, "raw_loader", path = req.uri().path());
+    let _guard = span.enter();
+
+    let routes = app.routes.read().await;
+    let mut temp_router = matchit::Router::new();
+    // let mut app = Router::new();
+
+    // which route kinds can be hard-matched first
+    for route in routes.iter() {
+        let path = route.path();
+        match &route.kind {
+            RouteKind::Html { .. }
+            | RouteKind::Json { .. }
+            | RouteKind::Raw { .. }
+            | RouteKind::Sse { .. } => {
+                let existing = temp_router.at_mut(path);
+                if let Ok(prev) = existing {
+                    *prev.value = route.clone();
+                    tracing::trace!("updated mutable route at {}", path)
+                } else if let Err(err) = existing {
+                    match temp_router.insert(path, route.clone()) {
+                        Ok(_) => {
+                            tracing::trace!(path, "+")
+                        }
+                        Err(_) => {
+                            tracing::error!("❌ {:?}", err.to_string())
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    drop(routes);
+
+    let matched = temp_router.at(req.uri().path());
+
+    let Ok(matched) = matched else {
+        return next.run(req).await;
+    };
+
+    let route = matched.value;
+    let _params = matched.params;
+
+    let mut app = Router::new();
+    match &route.kind {
+        RouteKind::Sse { sse } => {
+            let raw = sse.to_owned();
+            app = app.route(
+                req.uri().path(),
+                any(|| async move {
+                    let l = raw
+                        .lines()
+                        .map(|l| l.to_owned())
+                        .map(|l| l.strip_prefix("data:").unwrap_or(&l).to_owned())
+                        .filter(|l| !l.trim().is_empty())
+                        .collect::<Vec<_>>();
+
+                    tracing::trace!(lines.count = l.len(), "sending EventStream");
+
+                    let stream = tokio_stream::iter(l)
+                        .throttle(Duration::from_millis(500))
+                        .map(|chu| Event::default().data(chu))
+                        .map(Ok::<_, Infallible>);
+
+                    Sse::new(stream)
+                }),
+            )
+        }
+        RouteKind::Raw { raw } => {
+            tracing::trace!("-> served Route::Raw {} {} bytes", route.path, raw.len());
+            let moved = raw.clone();
+            let p = req.uri().path().to_owned();
+            app = app.route(
+                req.uri().path(),
+                any(|| async move { text_asset_response(&p, &moved) }),
+            );
+        }
+        RouteKind::Html { html } => {
+            tracing::trace!("-> served Route::Html {} {} bytes", route.path, html.len());
+            let moved = html.clone();
+            app = app.route(req.uri().path(), any(|| async { Html(moved) }));
+        }
+        RouteKind::Json { json } => {
+            tracing::trace!("-> served Route::Json {} {}", route.path, json);
+            let moved = json.to_owned();
+            app = app.route(req.uri().path(), any(|| async move { Json(moved) }));
+        }
+        RouteKind::Dir(DirRoute { dir: _ }) => {
+            unreachable!("should never reach RouteKind::Dir")
+        }
+        RouteKind::Proxy(ProxyRoute { proxy: _ }) => {
+            unreachable!("should never reach RouteKind::Proxy")
+        }
+    }
+
+    app = add_route_layers(app, route);
+
+    app.layer(middleware::from_fn(tag_raw))
+        .layer(middleware::from_fn(response_modifications_layer))
+        .oneshot(req)
+        .await
+        .into_response()
+}
+
+async fn tag_raw(req: Request, next: Next) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let (mut parts, body) = next.run(req).await.into_parts();
+    if parts.status.as_u16() == 200 {
+        parts.extensions.insert(MetaData::ServedRaw);
+    }
+    Ok(Response::from_parts(parts, body))
+}
+
+#[allow(dead_code)]
+async fn print_request_response(
+    req: Request,
+    next: Next,
+) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let res = next.run(req).await;
+
+    let (parts, body) = res.into_parts();
+    let bytes = buffer_and_print("response", body).await?;
+    let lines = bytes.chunks(150).map(|c| c.to_owned()).collect::<Vec<_>>();
+
+    let stream = tokio_stream::iter(lines)
+        .throttle(Duration::from_millis(500))
+        .map(Ok::<_, Infallible>);
+
+    let res = Response::from_parts(parts, Body::from_stream(stream));
+
+    Ok(res)
+}
+
+async fn buffer_and_print<B>(direction: &str, body: B) -> Result<Bytes, (StatusCode, String)>
+where
+    B: axum::body::HttpBody<Data = Bytes>,
+    B::Error: std::fmt::Display,
+{
+    let bytes = match body.collect().await {
+        Ok(collected) => collected.to_bytes(),
+        Err(err) => {
+            return Err((
+                StatusCode::BAD_REQUEST,
+                format!("failed to read {direction} body: {err}"),
+            ));
+        }
+    };
+
+    if let Ok(body) = std::str::from_utf8(&bytes) {
+        tracing::debug!("▶️ {direction} body = {body:?}");
+    }
+
+    Ok(bytes)
+}
+
+pub fn text_asset_response(path: &str, css: &str) -> Response {
+    let mime = mime_guess::from_path(path);
+    let aas_str = mime.first_or_text_plain();
+    let cloned = css.to_owned();
+    ([(CONTENT_TYPE, aas_str.to_string())], cloned).into_response()
+}

package/crates/bsnext_core/src/server/actor.rs

@@ -0,0 +1,92 @@
+use crate::dto::ClientEvent;
+use crate::server::handler_stop::Stop;
+use crate::server::signals::ServerSignals;
+use crate::server::state::ServerState;
+use actix::{ActorContext, AsyncContext, Running};
+use axum_server::Handle;
+use bsnext_input::route_manifest::RoutesManifest;
+use bsnext_input::server_config::ServerConfig;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::sync::oneshot::Sender;
+use tokio::sync::{broadcast, oneshot};
+use tracing::{span, Level};
+
+pub struct ServerActor {
+    pub config: ServerConfig,
+    pub routes_manifest: RoutesManifest,
+    pub signals: Option<ServerSignals>,
+    pub app_state: Option<Arc<ServerState>>,
+    pub addr: Option<SocketAddr>,
+}
+
+impl ServerActor {
+    pub fn new_from_config(config: ServerConfig) -> Self {
+        let routes_manifest = RoutesManifest::new(&config.routes);
+        Self {
+            config,
+            signals: None,
+            app_state: None,
+            addr: None,
+            routes_manifest,
+        }
+    }
+    pub fn install_signals(&mut self) -> (Sender<()>, Handle, broadcast::Sender<ClientEvent>) {
+        // todo: make this an enum for more messages
+        let (client_sender, client_receiver) = broadcast::channel::<ClientEvent>(5);
+        let (shutdown_complete, shutdown_complete_receiver) = oneshot::channel();
+        let axum_server_handle = Handle::new();
+        let axum_server_handle_clone = axum_server_handle.clone();
+
+        self.signals = Some(ServerSignals {
+            complete_mdg_receiver: Some(shutdown_complete_receiver),
+            axum_server_handle: Some(axum_server_handle),
+            client_sender: Some(client_sender.clone()),
+            client_receiver: Some(client_receiver),
+        });
+
+        (shutdown_complete, axum_server_handle_clone, client_sender)
+    }
+}
+
+impl actix::Actor for ServerActor {
+    type Context = actix::Context<Self>;
+
+    fn started(&mut self, _ctx: &mut Self::Context) {
+        tracing::trace!(actor.name = "ServerActor", actor.lifecyle = "started");
+    }
+
+    fn stopping(&mut self, ctx: &mut Self::Context) -> Running {
+        let span = span!(
+            Level::TRACE,
+            "stopping",
+            actor.name = "ServerActor",
+            actor.lifecyle = "stopping",
+            identity = ?self.config.identity
+        );
+        let _guard = span.enter();
+        let addr = ctx.address();
+        let s = ctx.state();
+
+        // this handles crashes. If the server actor crashes we want to ensure we're
+        // cleaning up any server we've started. So in a crash we return 'Running::Continue'
+        // and send ourselves the `Stop2` message (which will cleanly close the server)
+        // `Stop2` will then eventually also try to close this actor, at which point we'll allow it
+        if s.alive() {
+            tracing::trace!("actor was ❤️, sending `Stop2` to SELF",);
+            addr.do_send(Stop);
+            Running::Continue
+        } else {
+            tracing::trace!("Server actor was already 💀");
+            Running::Stop
+        }
+    }
+
+    fn stopped(&mut self, _ctx: &mut Self::Context) {
+        tracing::trace!(
+            actor.name = "ServerActor",
+            actor.lifecyle = "stopped",
+            identity = ?self.config.identity
+        );
+    }
+}

package/crates/bsnext_core/src/server/error.rs

@@ -0,0 +1,41 @@
+use std::net::SocketAddr;
+use thiserror::Error;
+
+// We derive `thiserror::Error`
+#[derive(serde::Serialize, serde::Deserialize, Debug, Error)]
+pub enum ServerError {
+    // The `#[from]` attribute generates `From<JsonRejection> for ApiError`
+    // implementation. See `thiserror` docs for more information
+    #[error("address in use {socket_addr}")]
+    AddrInUse { socket_addr: SocketAddr },
+    #[error("invalid bind address: {addr_parse_error}")]
+    InvalidAddress { addr_parse_error: String },
+    #[error("could not determine the reason")]
+    Unknown,
+    #[error("server was closed")]
+    Closed,
+}
+
+#[test]
+fn test_api_error() {
+    #[derive(serde::Serialize, serde::Deserialize, Debug)]
+    struct Output {
+        error: ServerError,
+    }
+
+    let e = ServerError::AddrInUse {
+        socket_addr: "127.0.0.1:3000".parse().unwrap(),
+    };
+
+    let output = Output { error: e };
+    let _as_yaml = serde_yaml::to_string(&output).unwrap();
+    let _as_json = serde_json::to_string_pretty(&output).unwrap();
+    // println!("{}", as_yaml);
+    // println!("{}", as_json);
+
+    let input = r#"
+error: !AddrInUse
+  socket_addr: 127.0.0.1:3000
+    "#;
+    let _input: Output = serde_yaml::from_str(&input).unwrap();
+}

package/crates/bsnext_core/src/server/handler_change.rs

@@ -0,0 +1,85 @@
+use crate::dto::ClientEvent;
+use crate::server::actor::ServerActor;
+
+use std::path::{Path, PathBuf};
+
+#[derive(actix::Message, Clone, Debug)]
+#[rtype(result = "()")]
+pub enum Change {
+    Fs {
+        path: PathBuf,
+        change_kind: ChangeKind,
+    },
+    FsMany(Vec<Change>),
+}
+
+#[typeshare::typeshare]
+#[derive(Clone, Debug, serde::Serialize)]
+pub enum ChangeKind {
+    Changed,
+    Added,
+    Removed,
+}
+
+impl Change {
+    pub fn fs<A: AsRef<Path>>(a: A) -> Self {
+        Self::Fs {
+            path: a.as_ref().to_path_buf(),
+            change_kind: ChangeKind::Changed,
+        }
+    }
+    pub fn fs_many<A: AsRef<Path>>(a: &[A]) -> Self {
+        Self::FsMany(
+            a.iter()
+                .map(|p| p.as_ref().to_owned())
+                .map(|p| Self::Fs {
+                    path: p,
+                    change_kind: ChangeKind::Changed,
+                })
+                .collect(),
+        )
+    }
+    pub fn fs_added<A: AsRef<Path>>(a: A) -> Self {
+        Self::Fs {
+            path: a.as_ref().to_path_buf(),
+            change_kind: ChangeKind::Added,
+        }
+    }
+    pub fn fs_removed<A: AsRef<Path>>(a: A) -> Self {
+        Self::Fs {
+            path: a.as_ref().to_path_buf(),
+            change_kind: ChangeKind::Removed,
+        }
+    }
+}
+
+impl actix::Handler<Change> for ServerActor {
+    type Result = ();
+
+    fn handle(&mut self, msg: Change, _ctx: &mut Self::Context) -> Self::Result {
+        if let Some(sender) = self.signals.as_ref().and_then(|s| s.client_sender.as_ref()) {
+            // todo: what messages are the clients expecting?
+            tracing::info!("forwarding `Change` event to connected web socket clients");
+            match sender.send(ClientEvent::Change((&msg).into())) {
+                Ok(_) => {
+                    tracing::trace!("change event sent to clients");
+                }
+                Err(_) => tracing::error!("not sent to client_sender"),
+            };
+        } else {
+            tracing::debug!("signals not ready, should they be?");
+        }
+    }
+}
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::dto::ChangeDTO;
+    #[test]
+    fn test_serialize() -> anyhow::Result<()> {
+        let fs: ChangeDTO = (&Change::fs("./a.js")).into();
+        let json = serde_json::to_string(&fs).unwrap();
+        print!("{json}");
+        Ok(())
+    }
+}

package/crates/bsnext_core/src/server/handler_listen.rs

@@ -0,0 +1,163 @@
+use crate::server::actor::ServerActor;
+use crate::server::error::ServerError;
+use crate::server::router::make_router;
+use crate::server::state::ServerState;
+use crate::servers_supervisor::actor::ServersSupervisor;
+use actix::{Addr, AsyncContext};
+use actix_rt::Arbiter;
+use bsnext_input::server_config::Identity;
+use std::future::Future;
+use std::io::ErrorKind;
+use std::net::{SocketAddr, TcpListener};
+use std::pin::Pin;
+use std::sync::Arc;
+use tokio::sync::{oneshot, RwLock};
+
+#[derive(actix::Message)]
+#[rtype(result = "Result<(SocketAddr, actix::Addr<ServerActor>), ServerError>")]
+pub struct Listen {
+    pub(crate) parent: Addr<ServersSupervisor>,
+}
+
+impl actix::Handler<Listen> for ServerActor {
+    type Result =
+        Pin<Box<dyn Future<Output = Result<(SocketAddr, actix::Addr<ServerActor>), ServerError>>>>;
+
+    fn handle(&mut self, msg: Listen, ctx: &mut Self::Context) -> Self::Result {
+        let identity = self.config.identity.clone();
+        tracing::trace!("actor started for {:?}", identity);
+        let (send_complete, handle, client_sender) = self.install_signals();
+        let (oneshot_send, oneshot_rec) = oneshot::channel();
+        let h1 = handle.clone();
+        let h2 = handle.clone();
+
+        let app_state = Arc::new(ServerState {
+            // parent: ,
+            routes: Arc::new(RwLock::new(self.config.routes.clone())),
+            id: self.config.identity.as_id(),
+            parent: Some(msg.parent.clone()),
+            client_sender: Arc::new(client_sender),
+        });
+
+        self.app_state = Some(app_state.clone());
+        let self_addr = ctx.address();
+
+        let server = async move {
+            let router = make_router(&app_state);
+
+            let maybe_socket_addr: Result<SocketAddr, _> = match identity {
+                Identity::Both {
+                    ref bind_address, ..
+                } => bind_address.parse(),
+                Identity::Address { ref bind_address } => bind_address.parse(),
+                Identity::Named { .. } => {
+                    format!("127.0.0.1:{}", get_available_port().expect("port?")).parse()
+                }
+            };
+
+            let Ok(socket_addr) = maybe_socket_addr else {
+                tracing::error!(
+                    "{:?} [❌ NOT started] could not parse bind_address",
+                    identity
+                );
+
+                match oneshot_send.send(Err(ServerError::InvalidAddress {
+                    addr_parse_error: maybe_socket_addr.unwrap_err().to_string(),
+                })) {
+                    Ok(_) => {}
+                    Err(_) => tracing::error!("oneshot send failed"),
+                }
+                return;
+            };
+
+            tracing::trace!("trying to listen on {:?}", socket_addr);
+
+            let server = axum_server::bind(socket_addr)
+                .handle(h1)
+                .serve(router.into_make_service_with_connect_info::<SocketAddr>());
+
+            let result: Result<_, ServerError> = match server.await {
+                Ok(_) => {
+                    tracing::debug!("{:?} [started] Server all done", identity);
+                    if send_complete.send(()).is_err() {
+                        tracing::error!("{:?} [started] could not send complete message", identity);
+                    }
+                    Ok(())
+                }
+                Err(e) => match e.kind() {
+                    ErrorKind::AddrInUse => {
+                        tracing::error!("{:?} [not-started] [AddrInUse] {}", identity, e);
+                        Err(ServerError::AddrInUse { socket_addr })
+                    }
+                    _ => {
+                        tracing::error!("{:?} [not-started] UNKNOWN {}", identity, e);
+                        Err(ServerError::Unknown)
+                    }
+                },
+            };
+            if !oneshot_send.is_closed() {
+                let _r = oneshot_send.send(result);
+            }
+        };
+
+        Arbiter::current().spawn(server);
+
+        let self_addr = self_addr.clone();
+
+        Box::pin(async move {
+            tokio::select! {
+                listening = h2.listening() => {
+                    match listening {
+                        Some(socket_addr) => {
+                            tracing::debug!("{} listening...", socket_addr);
+                            Ok((socket_addr, self_addr.clone()))
+                        }
+                        None => {
+                            Err(ServerError::Unknown)
+                        }
+                    }
+                }
+                msg = oneshot_rec => {
+                    match msg {
+                        Ok(v) => {
+                            match v {
+                                Ok(_) => {
+                                    tracing::info!("All good from one_shot?");
+                                    Err(ServerError::Closed)
+                                }
+                                Err(e) => {
+                                    Err(e)
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            tracing::error!("-->{e}");
+                            Err(ServerError::Unknown)
+                        }
+                    }
+                }
+            }
+        })
+    }
+}
+
+pub fn get_available_port() -> Option<u16> {
+    TcpListener::bind("127.0.0.1:0")
+        .and_then(|listener| listener.local_addr())
+        .map(|socket_addr| socket_addr.port())
+        .ok()
+}
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct Listening {
+    addr: SocketAddr,
+}
+
+impl actix::Handler<Listening> for ServerActor {
+    type Result = ();
+
+    fn handle(&mut self, msg: Listening, _ctx: &mut Self::Context) -> Self::Result {
+        self.addr = Some(msg.addr);
+    }
+}

package/crates/bsnext_core/src/server/handler_patch.rs

@@ -0,0 +1,42 @@
+use crate::server::actor::ServerActor;
+use crate::server::handler_routes_updated::RoutesUpdated;
+use actix::AsyncContext;
+use actix_rt::Arbiter;
+use anyhow::anyhow;
+use bsnext_input::route_manifest::RoutesManifest;
+use bsnext_input::server_config::ServerConfig;
+
+#[derive(actix::Message, Clone)]
+#[rtype(result = "anyhow::Result<()>")]
+pub struct Patch {
+    pub server_config: ServerConfig,
+}
+
+impl actix::Handler<Patch> for ServerActor {
+    type Result = anyhow::Result<()>;
+
+    fn handle(&mut self, msg: Patch, ctx: &mut Self::Context) -> Self::Result {
+        let addr = ctx.address();
+        tracing::trace!("Handler<PatchOne> for ServerActor");
+        let app_state = self
+            .app_state
+            .as_ref()
+            .ok_or(anyhow!("could not access state"))?;
+        let app_state_clone = app_state.clone();
+        let routes = msg.server_config.routes.clone();
+        let next_manifest = RoutesManifest::new(&routes);
+        let changeset = self.routes_manifest.changeset_for(&next_manifest);
+        self.routes_manifest = RoutesManifest::new(&routes);
+
+        let update_dn = async move {
+            let mut mut_routes = app_state_clone.routes.write().await;
+            *mut_routes = routes;
+            addr.do_send(RoutesUpdated {
+                change_set: changeset,
+            })
+        };
+
+        Arbiter::current().spawn(update_dn);
+        Ok(())
+    }
+}