@browsersync/bslive 0.0.5 → 0.0.9

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

@@ -0,0 +1,19 @@
+use crate::dto::ClientEvent;
+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 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()
+    }
+}

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

@@ -0,0 +1,199 @@
+use crate::dto::{ServerChange, ServerChangeSet, ServerChangeSetItem};
+
+use crate::server::handler_stop::Stop;
+use actix::{Actor, Addr, Running};
+
+use crate::server::actor::ServerActor;
+use crate::servers_supervisor::start_handler::StartMessage;
+
+use crate::server::handler_patch::Patch;
+use bsnext_input::server_config::Identity;
+use bsnext_input::Input;
+use std::collections::HashSet;
+use std::future::Future;
+use std::net::SocketAddr;
+
+use std::pin::Pin;
+use tokio::sync::oneshot::Sender;
+use tracing::{span, Level};
+
+#[derive(Debug)]
+pub struct ServersSupervisor {
+    pub(crate) handlers: std::collections::HashMap<Identity, ChildHandler>,
+    tx: Option<Sender<()>>,
+}
+
+impl ServersSupervisor {
+    pub fn new(tx: Sender<()>) -> Self {
+        Self {
+            handlers: std::default::Default::default(),
+            tx: Some(tx),
+        }
+    }
+
+    pub(crate) fn input_changed(
+        &mut self,
+        self_addr: Addr<ServersSupervisor>,
+        input: Input,
+    ) -> Pin<Box<impl Future<Output = ServerChangeSet> + Sized>> {
+        let span = span!(Level::TRACE, "input_changed");
+        let _guard = span.enter();
+
+        let existing: HashSet<_> = self.handlers.values().map(|v| v.identity.clone()).collect();
+        let incoming: HashSet<_> = input.servers.iter().map(|s| s.identity.clone()).collect();
+
+        let startup = incoming.difference(&existing).collect::<HashSet<_>>();
+        let shutdown = existing.difference(&incoming).collect::<HashSet<_>>();
+        let patch = existing.intersection(&incoming).collect::<HashSet<_>>();
+
+        let shutdown_jobs = shutdown
+            .into_iter()
+            .filter_map(|identity| self.handlers.get(identity).map(ToOwned::to_owned))
+            .collect::<Vec<_>>();
+
+        let start_jobs = startup
+            .iter()
+            .filter_map(|s| {
+                input
+                    .servers
+                    .iter()
+                    .find(|x| x.identity == **s)
+                    .map(ToOwned::to_owned)
+            })
+            .collect::<Vec<_>>();
+
+        let patch_jobs = patch
+            .iter()
+            .filter_map(|s| {
+                let child = self.handlers.get(s).map(ToOwned::to_owned);
+                let input = input
+                    .servers
+                    .iter()
+                    .find(|x| x.identity == **s)
+                    .map(ToOwned::to_owned);
+                match (child, input) {
+                    (Some(child), Some(config)) => Some((child, config)),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        Box::pin(async move {
+            let mut changeset = ServerChangeSet { items: vec![] };
+            for x in shutdown_jobs {
+                tracing::debug!("stopping {:?}", x.identity);
+                changeset.items.push(ServerChangeSetItem {
+                    identity: (&x.identity).into(),
+                    change: ServerChange::Stopped {
+                        bind_address: x.socket_addr.to_string(),
+                    },
+                });
+                match x.actor_address.send(Stop).await {
+                    Ok(_) => {
+                        self_addr.do_send(ChildStopped {
+                            identity: x.identity.clone(),
+                        });
+                    }
+                    Err(_) => {
+                        tracing::error!("couldn't send Stop2 {:?}", x.identity);
+                    }
+                }
+            }
+
+            if !start_jobs.is_empty() {
+                tracing::debug!("starting {:?} servers", start_jobs.len());
+                let idens = start_jobs
+                    .iter()
+                    .map(|x| &x.identity)
+                    .map(|x| x.to_owned())
+                    .collect::<Vec<_>>();
+                match self_addr
+                    .send(StartMessage {
+                        server_configs: start_jobs,
+                    })
+                    .await
+                {
+                    Ok(_) => {
+                        for x in idens {
+                            changeset.items.push(ServerChangeSetItem {
+                                identity: (&x).into(),
+                                change: ServerChange::Started,
+                            })
+                        }
+                    }
+                    Err(_) => tracing::error!("could not send StartMessage to self"),
+                };
+            }
+
+            for (child, config) in patch_jobs {
+                tracing::debug!("patching {:?}", child.identity);
+                child.actor_address.do_send(Patch {
+                    server_config: config,
+                });
+                changeset.items.push(ServerChangeSetItem {
+                    identity: (&child.identity).into(),
+                    change: ServerChange::Patched,
+                })
+            }
+
+            changeset
+        })
+    }
+}
+
+impl Actor for ServersSupervisor {
+    type Context = actix::Context<Self>;
+    fn started(&mut self, _ctx: &mut Self::Context) {
+        tracing::trace!(actor.name = "Servers", actor.lifecyle = "started")
+    }
+
+    fn stopping(&mut self, _ctx: &mut Self::Context) -> Running {
+        tracing::trace!(actor.name = "Servers", actor.lifecyle = "stopping");
+        Running::Stop
+    }
+
+    fn stopped(&mut self, _ctx: &mut Self::Context) {
+        let span = span!(parent: None, Level::TRACE, "stopped", actor.name = "Servers");
+        tracing::trace!(actor.lifecyle = "stopping");
+        let _guard = span.enter();
+        if let Some(tx) = self.tx.take() {
+            tracing::trace!("sending final completion");
+            match tx.send(()) {
+                Ok(_) => {
+                    tracing::trace!("✅ sent final completion message");
+                }
+                Err(_) => {
+                    tracing::trace!("❌ could not send final completion message. This usually means the actor went away (eg: a crash) before we could send this.");
+                }
+            }
+        } else {
+            tracing::error!("could not access oneshot sender for completion message")
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ChildHandler {
+    pub actor_address: Addr<ServerActor>,
+    pub identity: Identity,
+    pub socket_addr: SocketAddr,
+}
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct ChildStopped {
+    pub identity: Identity,
+}
+
+impl actix::Handler<ChildStopped> for ServersSupervisor {
+    type Result = ();
+
+    fn handle(&mut self, msg: ChildStopped, _ctx: &mut Self::Context) -> Self::Result {
+        tracing::trace!("Handler<Stopped> for Servers {:?}", msg.identity);
+        self.handlers.remove(&msg.identity);
+        tracing::trace!(
+            "Handler<Stopped> remaining handlers: {}",
+            self.handlers.len()
+        )
+    }
+}

package/crates/bsnext_core/src/servers_supervisor/file_changed_handler.rs

@@ -0,0 +1,41 @@
+use crate::server::handler_change::Change;
+use crate::servers_supervisor::actor::ServersSupervisor;
+use std::path::PathBuf;
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct FileChanged {
+    pub path: PathBuf,
+    pub id: u64,
+}
+
+impl actix::Handler<FileChanged> for ServersSupervisor {
+    type Result = ();
+
+    fn handle(&mut self, msg: FileChanged, _ctx: &mut Self::Context) -> Self::Result {
+        for child in self.handlers.values() {
+            if child.identity.as_id() == msg.id {
+                child.actor_address.do_send(Change::fs(&msg.path))
+            }
+        }
+    }
+}
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct FilesChanged {
+    pub paths: Vec<PathBuf>,
+    pub id: u64,
+}
+
+impl actix::Handler<FilesChanged> for ServersSupervisor {
+    type Result = ();
+
+    fn handle(&mut self, msg: FilesChanged, _ctx: &mut Self::Context) -> Self::Result {
+        for child in self.handlers.values() {
+            if child.identity.as_id() == msg.id {
+                child.actor_address.do_send(Change::fs_many(&msg.paths))
+            }
+        }
+    }
+}

package/crates/bsnext_core/src/servers_supervisor/get_servers_handler.rs

@@ -0,0 +1,23 @@
+use crate::dto::{GetServersMessageResponse, ServersDTO};
+use crate::servers_supervisor::actor::ServersSupervisor;
+
+#[derive(actix::Message)]
+#[rtype(result = "GetServersMessageResponse")]
+pub struct GetServersMessage;
+
+impl actix::Handler<GetServersMessage> for ServersSupervisor {
+    type Result = GetServersMessageResponse;
+
+    fn handle(&mut self, _msg: GetServersMessage, _ctx: &mut Self::Context) -> Self::Result {
+        GetServersMessageResponse {
+            servers: self
+                .handlers
+                .iter()
+                .map(|(identity, child_handler)| ServersDTO {
+                    identity: identity.into(),
+                    socket_addr: child_handler.socket_addr.to_string(),
+                })
+                .collect(),
+        }
+    }
+}

package/crates/bsnext_core/src/servers_supervisor/input_changed_handler.rs

@@ -0,0 +1,21 @@
+use crate::dto::ServerChangeSet;
+use crate::servers_supervisor::actor::ServersSupervisor;
+use actix::AsyncContext;
+use bsnext_input::Input;
+use std::future::Future;
+
+use std::pin::Pin;
+
+#[derive(actix::Message)]
+#[rtype(result = "ServerChangeSet")]
+pub struct InputChanged {
+    pub input: Input,
+}
+
+impl actix::Handler<InputChanged> for ServersSupervisor {
+    type Result = Pin<Box<dyn Future<Output = ServerChangeSet>>>;
+
+    fn handle(&mut self, msg: InputChanged, ctx: &mut Self::Context) -> Self::Result {
+        self.input_changed(ctx.address(), msg.input)
+    }
+}

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

@@ -0,0 +1,6 @@
+pub mod actor;
+pub mod file_changed_handler;
+pub mod get_servers_handler;
+pub mod input_changed_handler;
+pub mod start_handler;
+pub mod stop_handler;

package/crates/bsnext_core/src/servers_supervisor/start_handler.rs

@@ -0,0 +1,82 @@
+use crate::server::actor::ServerActor;
+use crate::server::handler_listen::Listen;
+use crate::servers_supervisor::actor::{ChildHandler, ServersSupervisor};
+use actix::{Actor, AsyncContext};
+use bsnext_input::server_config::ServerConfig;
+use futures_util::future::join_all;
+use futures_util::FutureExt;
+use std::future::Future;
+use std::pin::Pin;
+use tracing::{span, Instrument, Level};
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub(crate) struct StartMessage {
+    pub server_configs: Vec<ServerConfig>,
+}
+
+impl actix::Handler<StartMessage> for ServersSupervisor {
+    type Result = Pin<Box<dyn Future<Output = ()>>>;
+
+    fn handle(&mut self, msg: StartMessage, ctx: &mut Self::Context) -> Self::Result {
+        let span = span!(Level::TRACE, "actix::Handler<StartMessage> for Servers");
+        let self_addr = ctx.address();
+
+        let workload = async move {
+            tracing::debug!("creating {} actor(s)", msg.server_configs.len());
+            let fts = msg
+                .server_configs
+                .into_iter()
+                .map(|server_config| {
+                    let server = ServerActor::new_from_config(server_config.clone());
+                    let actor_addr = server.start();
+                    let c = server_config.clone();
+                    actor_addr.send(Listen).map(|r| (r, c))
+                })
+                .collect::<Vec<_>>();
+
+            let results = join_all(fts).await;
+            for (fut_result, server_config) in results {
+                match fut_result {
+                    Ok(msg_response) => match msg_response {
+                        Ok((addr, actor_addr)) => {
+                            tracing::debug!("✚ got listening child: {}", addr.to_string());
+                            self_addr.do_send(ChildCreated {
+                                server_handler: ChildHandler {
+                                    actor_address: actor_addr,
+                                    identity: server_config.identity,
+                                    socket_addr: addr,
+                                },
+                            });
+                        }
+                        Err(e) => {
+                            tracing::error!("{:?}  <- {}", server_config.identity, e)
+                        }
+                    },
+                    Err(e) => tracing::error!("  <- [m] {}", e),
+                }
+            }
+        }
+        .instrument(span);
+
+        Box::pin(workload)
+    }
+}
+
+#[derive(Debug, actix::Message)]
+#[rtype(result = "()")]
+pub struct ChildCreated {
+    server_handler: ChildHandler,
+}
+
+impl actix::Handler<ChildCreated> for ServersSupervisor {
+    type Result = ();
+
+    fn handle(&mut self, msg: ChildCreated, _ctx: &mut Self::Context) -> Self::Result {
+        self.handlers.insert(
+            msg.server_handler.identity.clone(),
+            msg.server_handler.clone(),
+        );
+        tracing::trace!("ChildCreated child count: {}", self.handlers.len());
+    }
+}

package/crates/bsnext_core/src/servers_supervisor/stop_handler.rs

@@ -0,0 +1,26 @@
+use crate::server::handler_stop::Stop;
+use crate::servers_supervisor::actor::ServersSupervisor;
+use futures_util::future::join_all;
+use std::future::Future;
+use std::pin::Pin;
+
+#[derive(actix::Message)]
+#[rtype(result = "()")]
+pub struct StopServers;
+
+impl actix::Handler<StopServers> for ServersSupervisor {
+    type Result = Pin<Box<dyn Future<Output = ()>>>;
+
+    fn handle(&mut self, _msg: StopServers, _ctx: &mut Self::Context) -> Self::Result {
+        let aaddresses = self.handlers.clone();
+
+        Box::pin(async move {
+            tracing::debug!("stopping {} servers", aaddresses.len());
+            let fts = aaddresses
+                .values()
+                .map(|handler| handler.actor_address.send(Stop))
+                .collect::<Vec<_>>();
+            join_all(fts).await;
+        })
+    }
+}

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

@@ -0,0 +1,164 @@
+use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade};
+use axum::extract::{ConnectInfo, State};
+use axum::response::IntoResponse;
+
+use futures_util::{SinkExt, StreamExt};
+
+use crate::dto::ClientEvent;
+use crate::server::state::ServerState;
+use std::net::SocketAddr;
+use std::ops::ControlFlow;
+use std::sync::Arc;
+use tokio::sync::broadcast::error::RecvError;
+use tokio::sync::broadcast::Sender;
+
+/// The handler for the HTTP request (this gets called when the HTTP GET lands at the start
+/// of websocket negotiation). After this completes, the actual switching from HTTP to
+/// websocket protocol will occur.
+/// This is the last point where we can extract TCP/IP metadata such as IP address of the client
+/// as well as things from HTTP headers such as user-agent of the browser etc.
+pub async fn ws_handler(
+    State(state): State<Arc<ServerState>>,
+    ws: WebSocketUpgrade,
+    ConnectInfo(addr): ConnectInfo<SocketAddr>,
+) -> impl IntoResponse {
+    // finalize the upgrade process by returning upgrade callback.
+    // we can customize the callback by sending additional info such as address.
+    ws.on_upgrade(move |socket| handle_socket(socket, addr, state.client_sender.clone()))
+}
+
+/// Actual websocket statemachine (one will be spawned per connection)
+async fn handle_socket(
+    mut socket: WebSocket,
+    who: SocketAddr,
+    client_sender: Arc<Sender<ClientEvent>>,
+) {
+    //send a ping (unsupported by some browsers) just to kick things off and get a response
+    if socket.send(Message::Ping(vec![1, 2, 3])).await.is_ok() {
+        tracing::trace!("Pinged {who}...");
+    } else {
+        tracing::trace!("Could not send ping {who}!");
+        // no Error here since the only thing we can do is to close the connection.
+        // If we can not send messages, there is no way to salvage the statemachine anyway.
+        return;
+    }
+
+    // receive single message from a client (we can either receive or send with socket).
+    // this will likely be the Pong for our Ping or a hello message from client.
+    // waiting for message from a client will block this task, but will not block other client's
+    // connections.
+    if let Some(msg) = socket.recv().await {
+        if let Ok(msg) = msg {
+            if process_message(msg, who).is_break() {
+                return;
+            }
+        } else {
+            tracing::debug!("client {who} abruptly disconnected");
+            return;
+        }
+    }
+
+    // By splitting socket we can send and receive at the same time. In this example we will send
+    // unsolicited messages to client based on some sort of server's internal event (i.e .timer).
+    let (mut sender, mut receiver) = socket.split();
+
+    // Spawn a task that will push several messages to the client (does not matter what client does)
+    let mut send_task = tokio::spawn(async move {
+        let mut count = 0;
+        let mut client_receiver = client_sender.subscribe();
+        loop {
+            match client_receiver.recv().await {
+                Ok(incoming) => {
+                    tracing::trace!(?incoming, "ws incoming!");
+                    let output = serde_json::to_string(&incoming);
+                    let Ok(as_str) = output else {
+                        tracing::error!("could not serialize incoming client message");
+                        break;
+                    };
+                    if sender.send(Message::Text(as_str)).await.is_err() {
+                        return count;
+                    } else {
+                        count += 1;
+                    }
+                }
+                Err(RecvError::Closed) => {
+                    tracing::debug!("closed!");
+                }
+                Err(RecvError::Lagged(num)) => {
+                    tracing::error!(?num, "loagged!");
+                }
+            }
+        }
+        count
+    });
+
+    // This second task will receive messages from client and print them on server console
+    let mut recv_task = tokio::spawn(async move {
+        let mut cnt = 0;
+        while let Some(Ok(msg)) = receiver.next().await {
+            cnt += 1;
+            // print message and break if instructed to do so
+            if process_message(msg, who).is_break() {
+                break;
+            }
+        }
+        cnt
+    });
+
+    // If any one of the tasks exit, abort the other.
+    tokio::select! {
+        rv_a = (&mut send_task) => {
+            match rv_a {
+                Ok(a) => tracing::trace!("{a} messages sent to {who}"),
+                Err(a) => tracing::trace!("Error sending messages {a:?}")
+            }
+            recv_task.abort();
+        },
+        rv_b = (&mut recv_task) => {
+            match rv_b {
+                Ok(b) => tracing::trace!("Received {b} messages"),
+                Err(b) => tracing::trace!("Error receiving messages {b:?}")
+            }
+            send_task.abort();
+        }
+    }
+
+    // returning from the handler closes the websocket connection
+    tracing::trace!("Websocket context {who} destroyed");
+}
+
+/// helper to print contents of messages to stdout. Has special treatment for Close.
+fn process_message(msg: Message, who: SocketAddr) -> ControlFlow<(), ()> {
+    match msg {
+        Message::Text(t) => {
+            tracing::trace!(">>> {who} sent str: {t:?}");
+        }
+        Message::Binary(d) => {
+            tracing::trace!(">>> {} sent {} bytes: {:?}", who, d.len(), d);
+        }
+        Message::Close(c) => {
+            if let Some(cf) = c {
+                tracing::trace!(
+                    ">>> {} sent close with code {} and reason `{}`",
+                    who,
+                    cf.code,
+                    cf.reason
+                );
+            } else {
+                tracing::trace!(">>> {who} somehow sent close message without CloseFrame");
+            }
+            return ControlFlow::Break(());
+        }
+
+        Message::Pong(v) => {
+            tracing::trace!(">>> {who} sent pong with {v:?}");
+        }
+        // You should never need to manually handle Message::Ping, as axum's websocket library
+        // will do so for you automagically by replying with Pong and copying the v according to
+        // spec. But if you need the contents of the pings you can see them here.
+        Message::Ping(v) => {
+            tracing::trace!(">>> {who} sent ping with {v:?}");
+        }
+    }
+    ControlFlow::Continue(())
+}

package/crates/bsnext_example/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "bsnext_example"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bsnext_input = { path = "../bsnext_input" }
+clap = { workspace = true }

package/crates/bsnext_example/src/basic.rs

@@ -0,0 +1,51 @@
+use bsnext_input::route::{Route, RouteKind};
+use bsnext_input::server_config::Identity;
+use bsnext_input::{
+    server_config::{self},
+    Input,
+};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct BasicExample;
+
+impl BasicExample {
+    pub fn into_input(self, identity: Option<Identity>) -> Input {
+        let server = server_config::ServerConfig {
+            identity: identity.unwrap_or_else(Identity::named),
+            routes: vec![
+                Route {
+                    path: "/".to_string(),
+                    kind: RouteKind::Html {
+                        html: include_str!("../../../examples/basic/public/index.html").to_owned(),
+                    },
+                    ..Default::default()
+                },
+                Route {
+                    path: "/styles.css".to_string(),
+                    kind: RouteKind::Raw {
+                        raw: include_str!("../../../examples/basic/public/styles.css").to_owned(),
+                    },
+                    ..Default::default()
+                },
+                Route {
+                    path: "/script.js".to_string(),
+                    kind: RouteKind::Raw {
+                        raw: include_str!("../../../examples/basic/public/script.js").to_owned(),
+                    },
+                    ..Default::default()
+                },
+                Route {
+                    path: "/reset.css".to_string(),
+                    kind: RouteKind::Raw {
+                        raw: include_str!("../../../examples/basic/public/reset.css").to_owned(),
+                    },
+                    ..Default::default()
+                },
+            ],
+            ..Default::default()
+        };
+        Input {
+            servers: vec![server],
+        }
+    }
+}

package/crates/bsnext_example/src/lib.rs

@@ -0,0 +1,26 @@
+use crate::basic::BasicExample;
+use crate::lit::LitExample;
+use crate::md::MdExample;
+use bsnext_input::server_config::Identity;
+use bsnext_input::Input;
+
+pub mod basic;
+pub mod lit;
+pub mod md;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
+pub enum Example {
+    Basic,
+    Lit,
+    Md,
+}
+
+impl Example {
+    pub fn into_input(self, identity: Identity) -> Input {
+        match self {
+            Example::Basic => BasicExample.into_input(Some(identity)),
+            Example::Lit => LitExample.into_input(Some(identity)),
+            Example::Md => MdExample.into_input(Some(identity)),
+        }
+    }
+}