@browsersync/bslive 0.0.5 → 0.0.9

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,157 @@
+use crate::server::actor::ServerActor;
+use crate::server::error::ServerError;
+use crate::server::router::make_router;
+use crate::server::state::ServerState;
+use actix::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;
+
+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 {
+            routes: Arc::new(RwLock::new(self.config.routes.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!("box::pin was listening...");
+                            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(())
+    }
+}

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

@@ -0,0 +1,27 @@
+use crate::server::actor::ServerActor;
+use crate::server::handler_change::Change;
+use actix::AsyncContext;
+use bsnext_input::route_manifest::RouteChangeSet;
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct RoutesUpdated {
+    pub change_set: RouteChangeSet,
+}
+
+impl actix::Handler<RoutesUpdated> for ServerActor {
+    type Result = ();
+
+    fn handle(&mut self, msg: RoutesUpdated, ctx: &mut Self::Context) -> Self::Result {
+        tracing::trace!(changeset=?msg.change_set, id = ?self.config.identity);
+        for id in &msg.change_set.changed {
+            ctx.address().do_send(Change::fs(&id.path))
+        }
+        for id in &msg.change_set.removed {
+            ctx.address().do_send(Change::fs_removed(&id.path))
+        }
+        for id in &msg.change_set.added {
+            ctx.address().do_send(Change::fs_added(&id.path))
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+use crate::server::actor::ServerActor;
+use actix::ActorContext;
+use std::future::Future;
+use std::pin::Pin;
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct Stop;
+
+impl actix::Handler<Stop> for ServerActor {
+    type Result = Pin<Box<dyn Future<Output = ()>>>;
+
+    fn handle(&mut self, _msg: Stop, ctx: &mut Self::Context) -> Self::Result {
+        tracing::trace!("{:?} [ServerActor::Stop2]", self.addr);
+
+        // don't accept any more messages
+        let Some(signals) = self.signals.take() else {
+            todo!("should be unreachable. close signal can only be sent once")
+        };
+        let Some(handle) = signals.axum_server_handle else {
+            todo!("cannot get here handle cannnot be absent can it??")
+        };
+        tracing::trace!("{:?} using handle to shutdown", self.config.identity);
+        handle.shutdown();
+        ctx.stop();
+        if let Some(complete_msg_receiver) = signals.complete_mdg_receiver {
+            tracing::debug!("{:?} confirmed closed via signal", self.addr);
+            Box::pin(async move {
+                match complete_msg_receiver.await {
+                    Ok(_) => {}
+                    Err(e) => tracing::error!("failed to get complete message {e}"),
+                }
+            })
+        } else {
+            todo!("cannot get here?")
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+pub mod actor;
+pub mod error;
+pub mod handler_change;
+pub mod handler_listen;
+pub mod handler_patch;
+pub mod handler_routes_updated;
+pub mod handler_stop;
+pub mod router;
+pub mod signals;
+pub mod state;

package/crates/bsnext_core/src/server/router/mod.rs

@@ -0,0 +1,112 @@
+use crate::panic_handler::handle_panic;
+
+use axum::extract::{Request, State};
+use axum::http::Uri;
+use axum::middleware::{from_fn_with_state, Next};
+use axum::response::IntoResponse;
+use axum::routing::{get, MethodRouter};
+use axum::{http, Extension, Router};
+
+use axum::body::Body;
+use http::header::CONTENT_TYPE;
+use http::{HeaderValue, StatusCode};
+use hyper_tls::HttpsConnector;
+use hyper_util::client::legacy::connect::HttpConnector;
+use hyper_util::client::legacy::Client;
+use hyper_util::rt::TokioExecutor;
+use mime_guess::mime;
+use std::sync::Arc;
+use std::time::Duration;
+use tower::ServiceBuilder;
+use tower_http::catch_panic::CatchPanicLayer;
+
+use crate::dir_loader::serve_dir_loader;
+use crate::meta::MetaData;
+use crate::not_found::not_found_service::not_found_loader;
+use crate::not_found::route_list::create_route_list_html;
+use crate::raw_loader::raw_loader;
+use crate::server::state::ServerState;
+use crate::ws::ws_handler;
+use tower_http::timeout::TimeoutLayer;
+use tower_http::trace::TraceLayer;
+
+mod tests;
+
+pub fn make_router(state: &Arc<ServerState>) -> Router {
+    let https = HttpsConnector::new();
+    let client: Client<HttpsConnector<HttpConnector>, Body> =
+        Client::builder(TokioExecutor::new()).build(https);
+    let router = Router::new()
+        .merge(built_ins(state.clone()))
+        .merge(dynamic_loaders(state.clone()));
+    router
+        .layer(TraceLayer::new_for_http())
+        .layer(TimeoutLayer::new(Duration::from_secs(10)))
+        .layer(Extension(client))
+}
+
+pub fn built_ins(state: Arc<ServerState>) -> Router {
+    async fn handler(State(app): State<Arc<ServerState>>, _uri: Uri) -> impl IntoResponse {
+        // let v = app.lock().await;
+        let routes = app.routes.read().await;
+        let markup = create_route_list_html(&routes);
+        (
+            [(
+                CONTENT_TYPE,
+                HeaderValue::from_static(mime::TEXT_HTML_UTF_8.as_ref()),
+            )],
+            markup,
+        )
+            .into_response()
+    }
+    async fn js_handler(_uri: Uri) -> impl IntoResponse {
+        let markup = include_str!("../../../../bsnext_client/dist/index.js");
+        (
+            [(
+                CONTENT_TYPE,
+                HeaderValue::from_static(mime::APPLICATION_JAVASCRIPT_UTF_8.as_ref()),
+            )],
+            markup,
+        )
+            .into_response()
+    }
+
+    route("/__bsnext", get(handler))
+        .route("/__bs_js", get(js_handler))
+        .route("/__bs_ws", get(ws_handler))
+        .with_state(state.clone())
+}
+
+fn route(path: &str, method_router: MethodRouter<Arc<ServerState>>) -> Router<Arc<ServerState>> {
+    Router::new().route(path, method_router)
+}
+
+pub fn dynamic_loaders(state: Arc<ServerState>) -> Router {
+    Router::new()
+        .layer(
+            ServiceBuilder::new()
+                .layer(from_fn_with_state(state.clone(), tagging_layer))
+                .layer(from_fn_with_state(state.clone(), not_found_loader))
+                .layer(from_fn_with_state(state.clone(), raw_loader))
+                .layer(from_fn_with_state(state.clone(), serve_dir_loader)),
+        )
+        .layer(CatchPanicLayer::custom(handle_panic))
+        .with_state(state.clone())
+}
+
+async fn tagging_layer(
+    req: Request,
+    next: Next,
+) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let r = next.run(req).await;
+    if let Some(_metadata) = r.extensions().get::<MetaData>() {
+        // todo:
+    }
+    Ok(r)
+}
+
+#[derive(serde::Deserialize, Debug)]
+pub enum Encoding {
+    Br,
+    Zip,
+}

package/crates/bsnext_core/src/server/router/tests.rs

@@ -0,0 +1,204 @@
+#[cfg(test)]
+mod test {
+
+    use crate::dto::ClientEvent;
+    use crate::server::router::make_router;
+    use crate::server::state::ServerState;
+    use axum::body::Body;
+    use axum::extract::Request;
+    use axum::response::Response;
+    use bsnext_input::route::{CorsOpts, Route, RouteKind};
+    use bsnext_input::server_config::{Identity, ServerConfig};
+    use http::HeaderValue;
+    use std::sync::Arc;
+    use tokio::sync::RwLock;
+    use tower::ServiceExt;
+
+    impl From<ServerConfig> for ServerState {
+        fn from(val: ServerConfig) -> ServerState {
+            let (sender, _) = tokio::sync::broadcast::channel::<ClientEvent>(10);
+            ServerState {
+                routes: Arc::new(RwLock::new(val.routes.clone())),
+                client_sender: Arc::new(sender),
+            }
+        }
+    }
+
+    async fn to_resp_body(res: Response) -> String {
+        use http_body_util::BodyExt;
+        let (_parts, body) = res.into_parts();
+        let b = body.collect().await.unwrap();
+        let b = b.to_bytes();
+        let as_str = std::str::from_utf8(&b).unwrap();
+        as_str.to_owned()
+    }
+
+    #[tokio::test]
+    async fn test_handlers() -> Result<(), anyhow::Error> {
+        let state: ServerState = ServerConfig {
+            identity: Identity::Address {
+                bind_address: "127.0.0.1:3000".to_string(),
+            },
+            routes: vec![Route {
+                path: "/hello".to_string(),
+                kind: RouteKind::html("🐥"),
+                ..Default::default()
+            }],
+            ..Default::default()
+        }
+        .into();
+
+        let app = make_router(&Arc::new(state));
+        let req = Request::get("/hello").body(Body::empty()).unwrap();
+        let res = app.oneshot(req).await.unwrap();
+
+        assert_eq!(res.headers().get("content-length").unwrap(), "4");
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/html; charset=utf-8"
+        );
+
+        let body = to_resp_body(res).await;
+        assert_eq!(body, "🐥");
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_handlers_raw() -> Result<(), anyhow::Error> {
+        let state: ServerState = ServerConfig {
+            identity: Identity::Address {
+                bind_address: "127.0.0.1".to_string(),
+            },
+            routes: vec![Route {
+                path: "/styles.css".to_string(),
+                kind: RouteKind::Raw {
+                    raw: "body{}".into(),
+                },
+                ..Default::default()
+            }],
+            ..Default::default()
+        }
+        .into();
+
+        let app = make_router(&Arc::new(state));
+        let req = Request::get("/styles.css").body(Body::empty()).unwrap();
+        let res = app.oneshot(req).await.unwrap();
+
+        assert_eq!(res.headers().get("content-length").unwrap(), "6");
+        assert_eq!(res.headers().get("content-type").unwrap(), "text/css");
+
+        let body = to_resp_body(res).await;
+        assert_eq!(body, "body{}");
+        Ok(())
+    }
+    #[tokio::test]
+    async fn test_cors_handlers() -> Result<(), anyhow::Error> {
+        let state: ServerState = ServerConfig {
+            identity: Identity::Address {
+                bind_address: "127.0.0.1:3000".to_string(),
+            },
+            routes: vec![
+                Route {
+                    path: "/".to_string(),
+                    cors_opts: Some(CorsOpts::Cors(true)),
+                    kind: RouteKind::html("home"),
+                    ..Default::default()
+                },
+                Route {
+                    path: "/hello".to_string(),
+                    kind: RouteKind::html("🐥"),
+                    ..Default::default()
+                },
+            ],
+            ..Default::default()
+        }
+        .into();
+
+        let app = make_router(&Arc::new(state));
+        let req = Request::get("/").body(Body::empty()).unwrap();
+        let res = app.oneshot(req).await.unwrap();
+        let h = res.headers().get("access-control-allow-origin");
+        let v = res.headers().get("vary");
+
+        assert_eq!(h, Some(HeaderValue::from_str("*").as_ref().unwrap()));
+        assert_eq!(
+            v,
+            Some(
+                HeaderValue::from_str(
+                    "origin, access-control-request-method, access-control-request-headers"
+                )
+                .as_ref()
+                .unwrap()
+            )
+        );
+
+        let body = to_resp_body(res).await;
+        assert_eq!(body, "home");
+        Ok(())
+    }
+    #[tokio::test]
+    async fn test_not_found_handler() -> Result<(), anyhow::Error> {
+        let state: ServerState = ServerConfig {
+            identity: Identity::Address {
+                bind_address: "127.0.0.1:3000".to_string(),
+            },
+            routes: vec![Route {
+                path: "/".to_string(),
+                cors_opts: Some(CorsOpts::Cors(true)),
+                kind: RouteKind::html("home"),
+                ..Default::default()
+            }],
+            ..Default::default()
+        }
+        .into();
+
+        let app = make_router(&Arc::new(state));
+        let req = Request::get("/abc").body(Body::empty()).unwrap();
+        let res = app.oneshot(req).await.unwrap();
+        let status = res.status().as_u16();
+
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/html; charset=utf-8"
+        );
+
+        let body = to_resp_body(res).await;
+
+        assert!(body.contains("<title>BSNEXT</title>"));
+        assert_eq!(status, 404);
+        Ok(())
+    }
+    #[tokio::test]
+    async fn test_route_list() -> Result<(), anyhow::Error> {
+        let state: ServerState = ServerConfig {
+            identity: Identity::Address {
+                bind_address: "127.0.0.1:3000".to_string(),
+            },
+            routes: vec![Route {
+                path: "/abc".to_string(),
+                cors_opts: Some(CorsOpts::Cors(true)),
+                kind: RouteKind::html("home"),
+                ..Default::default()
+            }],
+            watchers: vec![],
+        }
+        .into();
+
+        let app = make_router(&Arc::new(state));
+        let req = Request::get("/__bsnext").body(Body::empty()).unwrap();
+        let res = app.oneshot(req).await.unwrap();
+        let status = res.status().as_u16();
+
+        assert_eq!(
+            res.headers().get("content-type").unwrap(),
+            "text/html; charset=utf-8"
+        );
+
+        let body = to_resp_body(res).await;
+
+        assert!(body.contains("<title>BSNEXT</title>"));
+        assert!(body.contains("<code>/abc</code>"));
+        assert_eq!(status, 200);
+        Ok(())
+    }
+}

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

@@ -0,0 +1,11 @@
+use crate::dto::ClientEvent;
+use axum_server::Handle;
+use tokio::sync::broadcast;
+use tokio::sync::oneshot::Receiver;
+
+pub struct ServerSignals {
+    pub complete_mdg_receiver: Option<Receiver<()>>,
+    pub axum_server_handle: Option<Handle>,
+    pub client_sender: Option<broadcast::Sender<ClientEvent>>,
+    pub client_receiver: Option<broadcast::Receiver<ClientEvent>>,
+}