@browsersync/bslive 0.0.14 → 0.0.15

package/crates/bsnext_core/src/dir_loader.rs

@@ -1,230 +0,0 @@
-#![allow(clippy::redundant_pattern_matching)]
-#![allow(clippy::single_match)]
-use crate::handlers::proxy::ProxyConfig;
-use crate::meta::MetaData;
-use axum::body::Body;
-use axum::extract::{Request, State};
-
-use axum::middleware::Next;
-use axum::response::{IntoResponse, Response};
-use axum::{middleware, Extension, Router};
-use bytes::Bytes;
-use futures::channel::mpsc::unbounded;
-use futures::SinkExt;
-
-use crate::common_layers::add_route_layers;
-use crate::handlers::proxy;
-use crate::server::state::ServerState;
-use axum::routing::any;
-use bsnext_input::route::{DirRoute, ProxyRoute, Route, RouteKind};
-use bsnext_resp::{response_modifications_layer, RespMod};
-use http::{HeaderValue, StatusCode};
-use http_body_util::BodyExt;
-use std::collections::HashMap;
-use std::convert::Infallible;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::fs::File;
-use tokio::io::{AsyncWriteExt, BufWriter};
-use tokio_stream::StreamExt;
-use tower::{ServiceBuilder, ServiceExt};
-use tower_http::decompression::DecompressionLayer;
-use tower_http::services::ServeDir;
-use tracing::{span, Instrument, Level};
-
-pub async fn serve_dir_loader(
-    State(state): State<Arc<ServerState>>,
-    req: Request,
-    _next: Next,
-) -> Response {
-    let _path = req.uri().path().to_owned();
-    let span = span!(parent: None, Level::INFO, "serve_dir_loader", path = req.uri().path());
-    let _guard = span.enter();
-
-    let accepts_html = RespMod::accepts_html(&req);
-    let routes = state.routes.read().instrument(span.clone()).await;
-    let mut app = Router::new();
-    let route_map = routes
-        .iter()
-        .filter(|r| matches!(&r.kind, RouteKind::Proxy(_) | RouteKind::Dir(_)))
-        .fold(HashMap::<&str, Vec<&Route>>::new(), |mut acc, route| {
-            acc.entry(route.path.as_str())
-                .and_modify(|acc| acc.push(route))
-                .or_insert(vec![route]);
-            acc
-        });
-
-    for (_, routes) in route_map.iter() {
-        if routes.len() > 1 {
-            tracing::error!(
-                "cannot register duplicate dir or proxy routes, only the first will take effect"
-            );
-        }
-
-        let route = routes.first().expect("guarded");
-        let mut router = match &route.kind {
-            RouteKind::Proxy(ProxyRoute { proxy }) => {
-                let response_handling = if accepts_html {
-                    ResponseHandling::Modify
-                } else {
-                    ResponseHandling::None
-                };
-                service_for_proxy(response_handling, route).layer(Extension(ProxyConfig {
-                    target: proxy.to_owned(),
-                    path: route.path.clone(),
-                }))
-            }
-            RouteKind::Dir(DirRoute { dir }) => service_for_dir(route, dir),
-            _ => unreachable!("{:?}", route.kind),
-        };
-        router = add_route_layers(router, route);
-        app = app.merge(router);
-    }
-
-    drop(routes);
-
-    let r = app.oneshot(req).await;
-
-    r.into_response()
-}
-
-fn service_for_dir(route: &Route, dir: &str) -> Router {
-    Router::new()
-        .nest_service(route.path.as_str(), ServeDir::new(dir))
-        .layer(middleware::from_fn(tag_file))
-        .layer(middleware::from_fn(response_modifications_layer))
-}
-
-async fn tag_file(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::ServedFile);
-    }
-    Ok(Response::from_parts(parts, body))
-}
-
-enum ResponseHandling {
-    Modify,
-    None,
-}
-
-fn service_for_proxy(handling: ResponseHandling, route: &Route) -> Router {
-    match handling {
-        ResponseHandling::Modify => Router::new()
-            .nest_service(route.path.as_str(), any(proxy::proxy_handler))
-            .layer(
-                ServiceBuilder::new()
-                    .layer(middleware::from_fn(response_modifications_layer))
-                    .layer(DecompressionLayer::new()),
-            ),
-        ResponseHandling::None => Router::new()
-            .nest_service(route.path.as_str(), any(proxy::proxy_handler))
-            .layer(middleware::from_fn(response_modifications_layer)),
-    }
-}
-
-#[allow(dead_code)]
-async fn print_request_response(
-    req: Request,
-    next: Next,
-) -> Result<impl IntoResponse, (StatusCode, String)> {
-    let (parts, body) = req.into_parts();
-    let bytes = buffer_and_print("request", body).await?;
-    let req = Request::from_parts(parts, Body::from(bytes));
-
-    let res = next.run(req).await;
-    let (parts, body) = res.into_parts();
-
-    let (mut sender, rec) = unbounded::<Bytes>();
-    let is_event_stream = parts.headers.get("content-type")
-        == Some(&HeaderValue::from_str("text/event-stream").unwrap());
-
-    tokio::spawn(async move {
-        let mut stream = body.into_data_stream();
-        let mut chunks: Vec<Bytes> = vec![];
-        while let Some(b) = stream.next().await {
-            tracing::info!("CHUNK");
-            match b {
-                Ok(bytes) => {
-                    if is_event_stream {
-                        // let _written = file.write(&bytes).await;
-                        chunks.push(bytes.to_owned());
-                        match sender.send(bytes.to_owned()).await {
-                            Ok(_) => tracing::trace!("stripped chunk sent"),
-                            Err(_) => tracing::error!("stripped chunk not sent"),
-                        };
-                    } else {
-                        match sender.send(bytes.to_owned()).await {
-                            Ok(_) => tracing::trace!("chunk sent"),
-                            Err(_) => tracing::error!("not sent"),
-                        };
-                    }
-                }
-                Err(e) => {
-                    tracing::error!(?e, "error")
-                }
-            }
-        }
-        if is_event_stream {
-            let path = std::path::Path::new("record").join("out4.yml");
-            let mut file = BufWriter::new(File::create(path).await.expect("file"));
-            let to_str = chunks
-                .into_iter()
-                .map(|x| std::str::from_utf8(&x).expect("bytes").to_owned())
-                .collect::<Vec<_>>();
-            let yml = serde_yaml::to_string(&to_str).expect("to yaml");
-            println!("yml={}", yml);
-            let _r = file.write(yml.as_bytes());
-
-            match file.flush().await {
-                Ok(_) => {}
-                Err(_) => {}
-            }
-        }
-    });
-
-    // let res = Response::from_parts(parts, body);
-    // while let Some(b) = res.body().next().await {
-    //     dbg!(b);
-    // }
-
-    // let (parts, body) = res.into_parts();
-    // let bytes = buffer_and_print("response", body).await?;
-    // let l = lines
-    //     .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<_>>();
-
-    let stream = rec
-        .throttle(Duration::from_millis(500))
-        .map(Ok::<_, Infallible>);
-
-    let res = Response::from_parts(parts, Body::from_stream(stream));
-
-    Ok(res)
-}
-
-#[allow(dead_code)]
-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)
-}

package/crates/bsnext_core/src/dto.rs

@@ -1,341 +0,0 @@
-use actix::MessageResponse;
-use bsnext_input::server_config::Identity;
-use bsnext_input::InputError;
-use std::fmt::{Display, Formatter};
-use std::path::Path;
-
-use crate::server::handler_change::{Change, ChangeKind};
-use bsnext_fs::Debounce;
-use bsnext_input::route::{DirRoute, ProxyRoute, Route, RouteKind};
-use typeshare::typeshare;
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct ServerDesc {
-    pub routes: Vec<RouteDTO>,
-    pub id: String,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct RouteDTO {
-    pub path: String,
-    pub kind: RouteKindDTO,
-}
-
-impl From<Route> for RouteDTO {
-    fn from(value: Route) -> Self {
-        Self {
-            path: value.path.to_owned(),
-            kind: RouteKindDTO::from(value.kind),
-        }
-    }
-}
-impl From<&Route> for RouteDTO {
-    fn from(value: &Route) -> Self {
-        Self {
-            path: value.path.to_owned(),
-            kind: RouteKindDTO::from(value.kind.clone()),
-        }
-    }
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-#[serde(tag = "kind", content = "payload")]
-pub enum RouteKindDTO {
-    Html { html: String },
-    Json { json_str: String },
-    Raw { raw: String },
-    Sse { sse: String },
-    Proxy { proxy: String },
-    Dir { dir: String },
-}
-
-impl From<RouteKind> for RouteKindDTO {
-    fn from(value: RouteKind) -> Self {
-        match value {
-            RouteKind::Html { html } => RouteKindDTO::Html { html },
-            RouteKind::Json { json } => RouteKindDTO::Json {
-                json_str: serde_json::to_string(&json).expect("unreachable"),
-            },
-            RouteKind::Raw { raw } => RouteKindDTO::Raw { raw },
-            RouteKind::Sse { sse } => RouteKindDTO::Sse { sse },
-            RouteKind::Proxy(ProxyRoute { proxy }) => RouteKindDTO::Proxy { proxy },
-            RouteKind::Dir(DirRoute { dir }) => RouteKindDTO::Dir { dir },
-        }
-    }
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct ServersStarted {
-    pub servers_resp: GetServersMessageResponse,
-    pub changeset: ServerChangeSet,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub enum EventLevel {
-    #[serde(rename = "BSLIVE_EXTERNAL")]
-    External,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct ExternalEvent {
-    pub level: EventLevel,
-    pub fields: ExternalEvents,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-#[serde(tag = "kind", content = "payload")]
-pub enum ExternalEvents {
-    ServersStarted(ServersStarted),
-    Watching(Watching),
-    WatchingStopped(StoppedWatching),
-    FileChanged(FileChanged),
-    FilesChanged(FilesChangedDTO),
-    InputFileChanged(FileChanged),
-    InputAccepted(InputAccepted),
-    StartupFailed(InputErrorDTO),
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct InputAccepted {
-    pub path: String,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct FileChanged {
-    pub path: String,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct FilesChangedDTO {
-    pub paths: Vec<String>,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct Watching {
-    pub paths: Vec<String>,
-    pub debounce: DebounceDTO,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct StoppedWatching {
-    pub paths: Vec<String>,
-}
-
-impl StoppedWatching {
-    pub fn from_path_buf(p: &Path) -> Self {
-        Self {
-            paths: vec![p.to_string_lossy().to_string()],
-        }
-    }
-}
-
-impl Display for Watching {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "yo")
-    }
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct DebounceDTO {
-    kind: String,
-    ms: String,
-}
-
-impl Display for DebounceDTO {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}:{}ms", self.kind, self.ms)
-    }
-}
-
-impl From<Debounce> for DebounceDTO {
-    fn from(value: Debounce) -> Self {
-        match value {
-            Debounce::Trailing { duration } => Self {
-                kind: "trailing".to_string(),
-                ms: duration.as_millis().to_string(),
-            },
-            Debounce::Buffered { duration } => Self {
-                kind: "buffered".to_string(),
-                ms: duration.as_millis().to_string(),
-            },
-        }
-    }
-}
-
-impl FileChanged {
-    pub fn from_path_buf(p: &Path) -> Self {
-        Self {
-            path: p.to_string_lossy().to_string(),
-        }
-    }
-}
-
-impl Watching {
-    pub fn from_path_buf(p: &Path, debounce: Debounce) -> Self {
-        Self {
-            paths: vec![p.to_string_lossy().to_string()],
-            debounce: debounce.into(),
-        }
-    }
-}
-
-#[typeshare]
-#[derive(Debug, Clone, serde::Serialize)]
-#[serde(tag = "kind", content = "payload")]
-pub enum ServerChange {
-    Stopped { bind_address: String },
-    Started,
-    Patched,
-}
-
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct ServerChangeSetItem {
-    pub identity: IdentityDTO,
-    pub change: ServerChange,
-}
-#[typeshare]
-#[derive(Debug, serde::Serialize)]
-pub struct ServerChangeSet {
-    pub items: Vec<ServerChangeSetItem>,
-}
-
-#[typeshare::typeshare]
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, MessageResponse)]
-pub struct GetServersMessageResponse {
-    pub servers: Vec<ServerDTO>,
-}
-
-#[typeshare::typeshare]
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct ServerDTO {
-    pub id: String,
-    pub identity: IdentityDTO,
-    pub socket_addr: String,
-}
-
-#[typeshare::typeshare]
-#[derive(Debug, PartialEq, Hash, Eq, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(tag = "kind", content = "payload")]
-pub enum IdentityDTO {
-    Both { name: String, bind_address: String },
-    Address { bind_address: String },
-    Named { name: String },
-}
-
-impl From<&Identity> for IdentityDTO {
-    fn from(value: &Identity) -> Self {
-        match value {
-            Identity::Both { name, bind_address } => IdentityDTO::Both {
-                name: name.to_owned(),
-                bind_address: bind_address.to_owned(),
-            },
-            Identity::Address { bind_address } => IdentityDTO::Address {
-                bind_address: bind_address.to_owned(),
-            },
-            Identity::Named { name } => IdentityDTO::Named {
-                name: name.to_owned(),
-            },
-        }
-    }
-}
-
-#[typeshare::typeshare]
-#[derive(Debug, PartialEq, Hash, Eq, Clone, serde::Deserialize, serde::Serialize)]
-#[serde(tag = "kind", content = "payload")]
-pub enum InputErrorDTO {
-    MissingInputs(String),
-    InvalidInput(String),
-    NotFound(String),
-    InputWriteError(String),
-    PathError(String),
-    PortError(String),
-    DirError(String),
-}
-
-impl From<&InputError> for InputErrorDTO {
-    fn from(value: &InputError) -> Self {
-        match value {
-            e @ InputError::MissingInputs => InputErrorDTO::MissingInputs(e.to_string()),
-            e @ InputError::InvalidInput(_) => InputErrorDTO::InvalidInput(e.to_string()),
-            e @ InputError::NotFound(_) => InputErrorDTO::NotFound(e.to_string()),
-            e @ InputError::InputWriteError(_) => InputErrorDTO::InputWriteError(e.to_string()),
-            e @ InputError::PathError(_) => InputErrorDTO::PathError(e.to_string()),
-            e @ InputError::PortError(_) => InputErrorDTO::PortError(e.to_string()),
-            e @ InputError::DirError(_) => InputErrorDTO::DirError(e.to_string()),
-        }
-    }
-}
-
-#[typeshare::typeshare]
-#[derive(Debug, Clone, serde::Serialize)]
-#[serde(tag = "kind", content = "payload")]
-pub enum ClientEvent {
-    Change(ChangeDTO),
-}
-
-#[typeshare::typeshare]
-#[derive(Debug, Clone, serde::Serialize)]
-#[serde(tag = "kind", content = "payload")]
-pub enum ChangeDTO {
-    Fs {
-        path: String,
-        change_kind: ChangeKind,
-    },
-    FsMany(Vec<ChangeDTO>),
-}
-
-impl From<&Change> for ChangeDTO {
-    fn from(value: &Change) -> Self {
-        match value {
-            Change::Fs { path, change_kind } => Self::Fs {
-                path: path.to_string_lossy().to_string(),
-                change_kind: change_kind.clone(),
-            },
-            Change::FsMany(changes) => Self::FsMany(
-                changes
-                    .iter()
-                    .map(|change| match change {
-                        Change::Fs { path, change_kind } => Self::Fs {
-                            path: path.to_string_lossy().to_string(),
-                            change_kind: change_kind.clone(),
-                        },
-                        Change::FsMany(_) => unreachable!("recursive not supported"),
-                    })
-                    .collect(),
-            ),
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    #[test]
-    fn test_serialize() -> anyhow::Result<()> {
-        let fs = Change::fs("./a.js");
-        let evt = ClientEvent::Change((&fs).into());
-        let _json = serde_json::to_string(&evt).unwrap();
-        Ok(())
-    }
-    #[test]
-    fn test_serialize_server_start() -> anyhow::Result<()> {
-        let fs = Change::fs("./a.js");
-        let evt = ClientEvent::Change((&fs).into());
-        let _json = serde_json::to_string(&evt).unwrap();
-        Ok(())
-    }
-}

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

@@ -1 +0,0 @@
-pub mod proxy;

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

@@ -1,95 +0,0 @@
-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

@@ -1,12 +0,0 @@
-pub mod server;
-pub mod servers_supervisor;
-
-pub mod common_layers;
-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

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

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

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