npm - @browsersync/bslive - Versions diffs - 0.0.5 → 0.0.9 - Mend

@browsersync/bslive 0.0.5 → 0.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (137) hide show

package/Cargo.toml +32 -18
package/bin.js +6 -0
package/bslive/Cargo.toml +35 -0
package/{build.rs → bslive/build.rs} +1 -1
package/bslive/src/lib.rs +130 -0
package/bsnext/Cargo.toml +21 -0
package/bsnext/src/main.rs +110 -0
package/crates/bsnext_client/Cargo.toml +8 -0
package/crates/bsnext_client/build.rs +53 -0
package/crates/bsnext_client/dist/index.js +6493 -0
package/crates/bsnext_client/generated/dto.ts +116 -0
package/crates/bsnext_client/generated/schema.ts +187 -0
package/crates/bsnext_client/index.html +14 -0
package/crates/bsnext_client/package-lock.json +2059 -0
package/crates/bsnext_client/package.json +25 -0
package/crates/bsnext_client/src/lib.rs +1 -0
package/crates/bsnext_client/style.css +3 -0
package/crates/bsnext_client/ts/console.ts +25 -0
package/crates/bsnext_client/ts/index.ts +73 -0
package/crates/bsnext_client/tsconfig.json +16 -0
package/crates/bsnext_core/Cargo.toml +43 -0
package/crates/bsnext_core/src/dir_loader.rs +230 -0
package/crates/bsnext_core/src/dto.rs +281 -0
package/crates/bsnext_core/src/handlers/mod.rs +1 -0
package/crates/bsnext_core/src/handlers/proxy.rs +95 -0
package/crates/bsnext_core/src/lib.rs +11 -0
package/crates/bsnext_core/src/meta/mod.rs +5 -0
package/crates/bsnext_core/src/not_found/mod.rs +2 -0
package/crates/bsnext_core/src/not_found/not_found.html +20 -0
package/crates/bsnext_core/src/not_found/not_found_service.rs +41 -0
package/crates/bsnext_core/src/not_found/route_list.rs +49 -0
package/crates/bsnext_core/src/panic_handler.rs +32 -0
package/crates/bsnext_core/src/raw_loader.rs +226 -0
package/crates/bsnext_core/src/server/actor.rs +92 -0
package/crates/bsnext_core/src/server/error.rs +41 -0
package/crates/bsnext_core/src/server/handler_change.rs +85 -0
package/crates/bsnext_core/src/server/handler_listen.rs +157 -0
package/crates/bsnext_core/src/server/handler_patch.rs +42 -0
package/crates/bsnext_core/src/server/handler_routes_updated.rs +27 -0
package/crates/bsnext_core/src/server/handler_stop.rs +38 -0
package/crates/bsnext_core/src/server/mod.rs +10 -0
package/crates/bsnext_core/src/server/router/mod.rs +112 -0
package/crates/bsnext_core/src/server/router/tests.rs +204 -0
package/crates/bsnext_core/src/server/signals.rs +11 -0
package/crates/bsnext_core/src/server/state.rs +19 -0
package/crates/bsnext_core/src/servers_supervisor/actor.rs +199 -0
package/crates/bsnext_core/src/servers_supervisor/file_changed_handler.rs +41 -0
package/crates/bsnext_core/src/servers_supervisor/get_servers_handler.rs +23 -0
package/crates/bsnext_core/src/servers_supervisor/input_changed_handler.rs +21 -0
package/crates/bsnext_core/src/servers_supervisor/mod.rs +6 -0
package/crates/bsnext_core/src/servers_supervisor/start_handler.rs +82 -0
package/crates/bsnext_core/src/servers_supervisor/stop_handler.rs +26 -0
package/crates/bsnext_core/src/ws/mod.rs +164 -0
package/crates/bsnext_example/Cargo.toml +10 -0
package/crates/bsnext_example/src/basic.rs +51 -0
package/crates/bsnext_example/src/lib.rs +26 -0
package/crates/bsnext_example/src/lit.rs +37 -0
package/crates/bsnext_example/src/md.rs +18 -0
package/crates/bsnext_fs/Cargo.toml +22 -0
package/crates/bsnext_fs/src/actor.rs +122 -0
package/crates/bsnext_fs/src/buffered_debounce.rs +166 -0
package/crates/bsnext_fs/src/filter.rs +30 -0
package/crates/bsnext_fs/src/inner_fs_event_handler.rs +94 -0
package/crates/bsnext_fs/src/lib.rs +141 -0
package/crates/bsnext_fs/src/remove_path_handler.rs +46 -0
package/crates/bsnext_fs/src/stop_handler.rs +15 -0
package/crates/bsnext_fs/src/stream.rs +167 -0
package/crates/bsnext_fs/src/test/mod.rs +213 -0
package/crates/bsnext_fs/src/watch_path_handler.rs +67 -0
package/crates/bsnext_fs/src/watcher.rs +348 -0
package/crates/bsnext_input/Cargo.toml +22 -0
package/crates/bsnext_input/src/input_test/mod.rs +151 -0
package/crates/bsnext_input/src/lib.rs +153 -0
package/crates/bsnext_input/src/md.rs +541 -0
package/crates/bsnext_input/src/paths.rs +64 -0
package/crates/bsnext_input/src/route.rs +185 -0
package/crates/bsnext_input/src/route_manifest.rs +186 -0
package/crates/bsnext_input/src/server_config.rs +88 -0
package/crates/bsnext_input/src/target.rs +7 -0
package/crates/bsnext_input/src/watch_opt_test/mod.rs +68 -0
package/crates/bsnext_input/src/yml.rs +1 -0
package/crates/bsnext_output/Cargo.toml +16 -0
package/crates/bsnext_output/src/json.rs +11 -0
package/crates/bsnext_output/src/lib.rs +25 -0
package/crates/bsnext_output/src/pretty.rs +147 -0
package/crates/bsnext_resp/Cargo.toml +13 -0
package/crates/bsnext_resp/src/js/snippet.html +1 -0
package/crates/bsnext_resp/src/js/ws.js +1 -0
package/crates/bsnext_resp/src/lib.rs +79 -0
package/crates/bsnext_system/Cargo.toml +29 -0
package/crates/bsnext_system/src/args.rs +43 -0
package/crates/bsnext_system/src/lib.rs +227 -0
package/crates/bsnext_system/src/monitor.rs +241 -0
package/crates/bsnext_system/src/monitor_any_watchables.rs +127 -0
package/crates/bsnext_system/src/start_kind/snapshots/bsnext_system__start_kind__start_from_paths__test__test-2.snap +11 -0
package/crates/bsnext_system/src/start_kind/snapshots/bsnext_system__start_kind__start_from_paths__test__test.snap +29 -0
package/crates/bsnext_system/src/start_kind/start_from_example.rs +49 -0
package/crates/bsnext_system/src/start_kind/start_from_inputs.rs +67 -0
package/crates/bsnext_system/src/start_kind/start_from_paths.rs +51 -0
package/crates/bsnext_system/src/start_kind.rs +56 -0
package/crates/bsnext_system/src/startup.rs +51 -0
package/crates/bsnext_tracing/Cargo.toml +10 -0
package/crates/bsnext_tracing/src/lib.rs +89 -0
package/examples/basic/input.yml +5 -0
package/examples/basic/public/index.html +15 -0
package/examples/basic/public/reset.css +52 -0
package/examples/basic/public/script.js +1 -0
package/examples/basic/public/styles.css +3 -0
package/examples/kitchen-sink/a-file.md +1 -0
package/examples/kitchen-sink/api/1.json +1 -0
package/examples/kitchen-sink/api/2.json +3 -0
package/examples/kitchen-sink/app.js +1 -0
package/examples/kitchen-sink/input.html +185 -0
package/examples/kitchen-sink/input.yml +133 -0
package/examples/kitchen-sink/styles-2.css +3 -0
package/examples/lit/index.html +21 -0
package/examples/lit/input.yml +5 -0
package/examples/lit/lit.js +82 -0
package/examples/lit/package-lock.json +62 -0
package/examples/lit/package.json +15 -0
package/examples/md-single/frontmatter.md +35 -0
package/examples/md-single/md-single.md +35 -0
package/examples/openai/.nvm +1 -0
package/examples/openai/build.mjs +21 -0
package/examples/openai/index.html +13 -0
package/examples/openai/input.yml +59 -0
package/examples/openai/package-lock.json +720 -0
package/examples/openai/package.json +21 -0
package/examples/openai/src/index.js +21 -0
package/examples/openai/sse/01.txt +8 -0
package/examples/proxy-simple/input.yml +9 -0
package/examples/single/input.yaml +26 -0
package/index.d.ts +3 -1
package/index.js +3 -2
package/package.json +22 -19
package/run.sh +6 -0
package/src/lib.rs +0 -9

package/crates/bsnext_core/src/handlers/proxy.rs ADDED Viewed

@@ -0,0 +1,95 @@
+use anyhow::Context;
+use axum::body::Body;
+use axum::extract::Request;
+use axum::Extension;
+use axum::response::{IntoResponse, Response};
+use http::{HeaderValue, StatusCode, Uri};
+use hyper_tls::HttpsConnector;
+use hyper_util::client::legacy::connect::HttpConnector;
+use hyper_util::client::legacy::Client;
+#[derive(Debug, Clone)]
+pub struct ProxyConfig {
+    pub target: String,
+    pub path: String,
+}
+// Make our own error that wraps `anyhow::Error`.
+pub struct AnyAppError(anyhow::Error);
+// Tell axum how to convert `AppError` into a response.
+impl IntoResponse for AnyAppError {
+    fn into_response(self) -> Response {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Something went wrong: {}", self.0),
+        )
+            .into_response()
+    }
+}
+impl<E> From<E> for AnyAppError
+where
+    E: Into<anyhow::Error>,
+{
+    fn from(err: E) -> Self {
+        Self(err.into())
+    }
+}
+pub async fn proxy_handler(
+    Extension(config): Extension<ProxyConfig>,
+    req: Request,
+) -> Result<Response, AnyAppError> {
+    let client = {
+        req.extensions()
+            .get::<Client<HttpsConnector<HttpConnector>, Body>>()
+            .expect("must have a client, move this to an extractor?")
+    };
+    let client_c = client.clone();
+    let target = config.target.clone();
+    tracing::trace!(?config);
+    let path = req.uri().path();
+    tracing::trace!(req.uri = %path, config.path = config.path);
+    // tracing::trace!(req.headers = ?req.headers());
+    let path_query = req
+        .uri()
+        .path_and_query()
+        .map(|v| v.as_str())
+        .unwrap_or(path);
+    let uri = format!("{}{}", target, path_query);
+    let parsed = Uri::try_from(uri).context("tried to parse")?;
+    let target = match (parsed.host(), parsed.port()) {
+        (Some(host), Some(port)) => format!("{host}:{port}"),
+        (Some(host), None) => host.to_owned(),
+        _ => unreachable!("could not extract `host` from url"),
+    };
+    tracing::trace!(outgoing.uri = %parsed);
+    let host_header_value = HeaderValue::from_str(&target).unwrap();
+    let (parts, body) = req.into_parts();
+    let mut req = Request::from_parts(parts, body);
+    *req.uri_mut() = parsed;
+    // todo: Which other headers to mod here?
+    req.headers_mut().insert("host", host_header_value);
+    let res = client_c
+        .request(req)
+        .await
+        .map_err(|_| StatusCode::BAD_REQUEST)
+        .into_response();
+    Ok(res)
+}

package/crates/bsnext_core/src/lib.rs ADDED Viewed

@@ -0,0 +1,11 @@
+pub mod server;
+pub mod servers_supervisor;
+pub mod dir_loader;
+pub mod dto;
+pub mod handlers;
+pub mod meta;
+pub mod not_found;
+pub mod panic_handler;
+pub mod raw_loader;
+pub mod ws;

package/crates/bsnext_core/src/meta/mod.rs ADDED Viewed

@@ -0,0 +1,5 @@
+#[derive(Debug, Clone)]
+pub enum MetaData {
+    ServedFile,
+    ServedRaw,
+}

package/crates/bsnext_core/src/not_found/mod.rs ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ pub mod not_found_service;
2	+ pub mod route_list;

package/crates/bsnext_core/src/not_found/not_found.html ADDED Viewed

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport"
+          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>BSNEXT</title>
+    <style>
+        pre {
+            width: 100%;
+            overflow-x: auto;
+        }
+    </style>
+</head>
+<body>
+<h2>No routes were matched - here's what's available on this address:</h2>
+{{route_list}}
+</body>
+</html>

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

@@ -0,0 +1,41 @@
+use axum::extract::{Request, State};
+use axum::middleware::Next;
+use std::sync::Arc;
+use axum::response::{IntoResponse, Response};
+use http::header::CONTENT_TYPE;
+use http::{HeaderValue, StatusCode};
+use mime_guess::mime;
+use crate::handlers::proxy::AnyAppError;
+use crate::not_found::route_list::create_route_list_html;
+use crate::server::state::ServerState;
+use tracing::{span, Level};
+pub async fn not_found_loader(
+    State(state): State<Arc<ServerState>>,
+    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 routes = state.routes.read().await;
+    let markup = create_route_list_html(&routes);
+    Ok((
+        StatusCode::NOT_FOUND,
+        [(
+            CONTENT_TYPE,
+            HeaderValue::from_static(mime::TEXT_HTML_UTF_8.as_ref()),
+        )],
+        markup,
+    )
+        .into_response())
+}

package/crates/bsnext_core/src/not_found/route_list.rs ADDED Viewed

@@ -0,0 +1,49 @@
+use bsnext_input::route::{DirRoute, ProxyRoute, Route, RouteKind};
+use htmlescape::encode_minimal;
+pub fn create_route_list_html(routes: &[Route]) -> String {
+    let wrapper = include_str!("not_found.html");
+    let mut markup = String::from("<table>");
+    markup.push_str(
+        r##"
+    <thead>
+        <tr>
+            <td>Path</td>
+            <td>Kind</td>
+        </tr>
+    </thead>
+    "##,
+    );
+    for x in routes.iter() {
+        let mut item = String::from("<tr>");
+        let kind = match &x.kind {
+            RouteKind::Html { .. } => String::from("RouteKind::Html"),
+            RouteKind::Json { .. } => String::from("RouteKind::Json"),
+            RouteKind::Raw { .. } => String::from("RouteKind::Raw"),
+            RouteKind::Sse { .. } => String::from("RouteKind::Sse"),
+            RouteKind::Proxy(ProxyRoute { proxy }) => {
+                format!("RouteKind::Proxy('{}')", proxy)
+            }
+            RouteKind::Dir(DirRoute { dir }) => {
+                format!("RouteKind::Dir('{}')", dir.clone())
+            }
+        };
+        item.push_str(
+            format!(
+                "<td><a href='{}'><code>{}</code></a></td>\
+                \
+                <td><small>{}</small></td>",
+                x.path, x.path, kind
+            )
+            .as_str(),
+        );
+        item.push_str("</tr>");
+        markup.push_str(item.as_str());
+    }
+    markup.push_str("</table>");
+    markup.push_str("<pre><code>");
+    let json = serde_json::to_string_pretty(routes).expect("serde");
+    markup.push_str(&encode_minimal(&json));
+    markup.push_str("</pre></code>");
+    wrapper.replace("{{route_list}}", markup.as_str())
+}

package/crates/bsnext_core/src/panic_handler.rs ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,226 @@
+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::{CorsOpts, DelayKind, DelayOpts, DirRoute, ProxyRoute, Route, 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::time::sleep;
+use tokio_stream::StreamExt;
+use tower::ServiceExt;
+use tower_http::cors::CorsLayer;
+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))
+}
+pub fn add_route_layers(app: Router, route: &Route) -> Router {
+    let mut app = app;
+    if route
+        .cors_opts
+        .as_ref()
+        .is_some_and(|v| *v == CorsOpts::Cors(true))
+    {
+        tracing::trace!(to = route.path, "adding permissive cors");
+        app = app.layer(CorsLayer::permissive());
+    }
+    if let Some(DelayOpts::Delay(DelayKind::Ms(ms))) = route.delay_opts.as_ref() {
+        tracing::trace!(to = route.path, ?ms, "adding delay");
+        let ms = *ms;
+        app = app.layer(middleware::from_fn(
+            move |req: Request, next: Next| async move {
+                let res = next.run(req).await;
+                sleep(Duration::from_millis(ms)).await;
+                Ok::<_, Infallible>(res)
+            },
+        ));
+    }
+    // if route.opts.as_ref().is_some_and(|v| v.buff) {
+    // app = app.layer(middleware::from_fn(print_request_response));
+    // }
+    app
+}
+#[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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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();
+}