@browsersync/bslive 0.0.7 → 0.0.13

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/assets.rs

@@ -0,0 +1,39 @@
+use crate::server::state::ServerState;
+use axum::response::IntoResponse;
+use axum::routing::get;
+use axum::Router;
+use bsnext_client::{UI_CSS, UI_JS};
+use http::header::CONTENT_TYPE;
+use http::HeaderValue;
+use mime_guess::mime;
+use std::sync::Arc;
+
+pub fn pub_ui_assets(_: Arc<ServerState>) -> Router<Arc<ServerState>> {
+    Router::new()
+        .route(
+            "/dist/index.js",
+            get(|| async {
+                (
+                    [(
+                        CONTENT_TYPE,
+                        HeaderValue::from_static(mime::APPLICATION_JAVASCRIPT.as_ref()),
+                    )],
+                    UI_JS,
+                )
+                    .into_response()
+            }),
+        )
+        .route(
+            "/dist/index.css",
+            get(|| async {
+                (
+                    [(
+                        CONTENT_TYPE,
+                        HeaderValue::from_static(mime::TEXT_CSS.as_ref()),
+                    )],
+                    UI_CSS,
+                )
+                    .into_response()
+            }),
+        )
+}

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

@@ -0,0 +1,123 @@
+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::dto::{RouteDTO, ServerDesc};
+use crate::meta::MetaData;
+use crate::not_found::not_found_service::not_found_loader;
+use crate::raw_loader::raw_loader;
+use crate::server::router::assets::pub_ui_assets;
+use crate::server::router::pub_api::pub_api;
+use crate::server::state::ServerState;
+use crate::ws::ws_handler;
+use bsnext_client::html_with_base;
+use tower_http::timeout::TimeoutLayer;
+use tower_http::trace::TraceLayer;
+
+mod assets;
+mod pub_api;
+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 _dto = ServerDesc {
+            routes: routes.iter().map(RouteDTO::from).collect(),
+            id: app.id.to_string(),
+        };
+        let markup = html_with_base("/__bs_assets/ui/");
+        (
+            [(
+                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/inject/dist/index.js");
+        (
+            [(
+                CONTENT_TYPE,
+                HeaderValue::from_static(mime::APPLICATION_JAVASCRIPT_UTF_8.as_ref()),
+            )],
+            markup,
+        )
+            .into_response()
+    }
+
+    route("/__bslive", get(handler))
+        .route("/__bs_js", get(js_handler))
+        .nest("/__bs_api", pub_api(state.clone()))
+        .nest("/__bs_assets/ui", pub_ui_assets(state.clone()))
+        .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/pub_api.rs

@@ -0,0 +1,39 @@
+use crate::dto::{RouteDTO, ServerDesc};
+use crate::server::state::ServerState;
+use crate::servers_supervisor::get_servers_handler::GetServersMessage;
+use axum::extract::State;
+use axum::response::IntoResponse;
+use axum::routing::get;
+use axum::{Json, Router};
+use http::{StatusCode, Uri};
+use std::sync::Arc;
+
+async fn all_servers_handler(State(app): State<Arc<ServerState>>, _uri: Uri) -> impl IntoResponse {
+    match &app.parent {
+        None => unreachable!("cannot get here"),
+        Some(parent) => match parent.send(GetServersMessage).await {
+            Ok(servers) => Json(servers).into_response(),
+            Err(err) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Could not fetch servers: {}", err),
+            )
+                .into_response(),
+        },
+    }
+}
+
+async fn get_current_server(State(app): State<Arc<ServerState>>, _uri: Uri) -> impl IntoResponse {
+    let routes = app.routes.read().await;
+    let dto = ServerDesc {
+        routes: routes.iter().map(RouteDTO::from).collect(),
+        id: app.id.to_string(),
+    };
+    Json(dto)
+}
+
+pub fn pub_api(state: Arc<ServerState>) -> Router<Arc<ServerState>> {
+    Router::new()
+        .route("/servers", get(all_servers_handler))
+        .route("/me", get(get_current_server))
+        .with_state(state.clone())
+}

package/crates/bsnext_core/src/server/router/snapshots/bsnext_core__server__router__tests__test__handlers.snap

@@ -0,0 +1,9 @@
+---
+source: crates/bsnext_core/src/server/router/tests.rs
+expression: res.headers()
+---
+{
+    "content-type": "text/html; charset=utf-8",
+    "content-length": "4",
+    "a": "b",
+}

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

@@ -0,0 +1,209 @@
+#[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::collections::BTreeMap;
+    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())),
+                id: val.identity.as_id(),
+                parent: None,
+                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 headers: BTreeMap<String, String> =
+            [("a".to_string(), "b".to_string())].into_iter().collect();
+        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("🐥"),
+                headers: Some(headers),
+                ..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();
+
+        insta::assert_debug_snapshot!(res.headers());
+        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>Browsersync LIVE</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("/__bslive").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>Browsersync LIVE</title>"));
+        assert!(body.contains("<base href=\"/__bs_assets/ui/\" />"));
+        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>>,
+}

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

@@ -0,0 +1,23 @@
+use crate::dto::ClientEvent;
+use crate::servers_supervisor::actor::ServersSupervisor;
+use actix::Addr;
+use bsnext_input::route::Route;
+use std::fmt::Formatter;
+use std::sync::Arc;
+use tokio::sync::{broadcast, RwLock};
+
+#[derive(Clone)]
+pub struct ServerState {
+    pub routes: Arc<RwLock<Vec<Route>>>,
+    pub id: u64,
+    pub parent: Option<Addr<ServersSupervisor>>,
+    pub client_sender: Arc<broadcast::Sender<ClientEvent>>,
+}
+
+impl std::fmt::Debug for ServerState {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AppState")
+            .field("routes", &"Arc<RwLock<Vec<Route>>>")
+            .finish()
+    }
+}