Merge pull request #71 from BrowserSync/overlay

overlay

Author: shakyShane

.prettierignore

@@ -1,4 +1,6 @@
 ui/dist
 inject/dist
 inject/vendor
-generated/
+generated/
+package-lock.json
+package.json

crates/bsnext_core/src/server/actor.rs

@@ -46,6 +46,9 @@ impl ServerActor {
 
         (shutdown_complete, axum_server_handle_clone, client_sender)
     }
+    pub fn client_sender(&self) -> Option<&tokio::sync::broadcast::Sender<ClientEvent>> {
+        self.signals.as_ref().and_then(|s| s.client_sender.as_ref())
+    }
 }
 
 impl actix::Actor for ServerActor {

crates/bsnext_core/src/server/handler_notification.rs

@@ -0,0 +1,35 @@
+use crate::server::actor::ServerActor;
+use bsnext_dto::{ClientEvent, DisplayMessageDTO};
+use bsnext_input::bs_live_built_in_task::ClientNotification;
+
+#[derive(actix::Message, Debug)]
+#[rtype(result = "()")]
+pub enum Notification {
+    Any(ClientNotification),
+}
+
+impl actix::Handler<Notification> for ServerActor {
+    type Result = ();
+
+    fn handle(&mut self, msg: Notification, _ctx: &mut Self::Context) -> Self::Result {
+        let Some(client_sender) = self.client_sender() else {
+            return tracing::error!("signals not ready, should they be?");
+        };
+
+        match msg {
+            Notification::Any(ClientNotification::DisplayMessage(dm)) => {
+                let msg = DisplayMessageDTO {
+                    message: dm.message,
+                    reason: dm.reason,
+                };
+                match client_sender.send(ClientEvent::DisplayMessage(msg)) {
+                    Ok(_) => tracing::debug!("send ClientEvent::DisplayMessage to clients"),
+                    Err(e) => {
+                        tracing::error!("did not send ClientEvent::DisplayMessage to clients");
+                        tracing::error!(?e)
+                    }
+                }
+            }
+        }
+    }
+}

crates/bsnext_core/src/server/mod.rs

@@ -3,6 +3,7 @@ pub mod error;
 pub mod handler_change;
 pub mod handler_client_config;
 pub mod handler_listen;
+pub mod handler_notification;
 pub mod handler_patch;
 pub mod handler_routes_updated;
 pub mod handler_stop;

crates/bsnext_core/src/server/router/pub_api.rs

@@ -71,6 +71,9 @@ async fn post_events(
                 ClientEvent::WsConnection(_) => {
                     todo!("handle ClientEvent::WsConnection  in incoming event handler?")
                 }
+                ClientEvent::DisplayMessage(_) => {
+                    todo!("handle ClientEvent::DisplayMessage  in incoming event handler...")
+                }
             };
             match recv
                 .send(IncomingEvents::FilesChanged(FilesChanged {

crates/bsnext_core/src/servers_supervisor/file_changed_handler.rs

@@ -1,6 +1,9 @@
 use crate::server::handler_change::{Change, ChangeWithSpan};
+use crate::server::handler_notification::Notification;
 use crate::servers_supervisor::actor::ServersSupervisor;
+use actix::AsyncContext;
 use bsnext_fs::FsEventContext;
+use bsnext_input::bs_live_built_in_task::ClientNotification;
 use std::path::PathBuf;
 
 #[derive(actix::Message)]
@@ -59,3 +62,27 @@ impl actix::Handler<FilesChanged> for ServersSupervisor {
         }
     }
 }
+
+#[derive(Debug, Clone, actix::Message)]
+#[rtype(result = "()")]
+pub enum ServersNotification {
+    FilesChanged(FilesChanged),
+    ClientNotification(ClientNotification),
+}
+
+impl actix::Handler<ServersNotification> for ServersSupervisor {
+    type Result = ();
+
+    fn handle(&mut self, msg: ServersNotification, ctx: &mut Self::Context) -> Self::Result {
+        tracing::debug!("looking at {} handlers", self.handlers.len());
+        match msg {
+            ServersNotification::FilesChanged(fc) => ctx.notify(fc),
+            ServersNotification::ClientNotification(notification) => {
+                for child in self.handlers.values() {
+                    let server_msg = Notification::Any(notification.to_owned());
+                    child.actor_address.do_send(server_msg);
+                }
+            }
+        }
+    }
+}

crates/bsnext_dto/src/lib.rs

@@ -461,6 +461,14 @@ pub enum ClientEvent {
     Change(ChangeDTO),
     WsConnection(ClientConfigDTO),
     Config(ClientConfigDTO),
+    DisplayMessage(DisplayMessageDTO),
+}
+
+#[typeshare::typeshare]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct DisplayMessageDTO {
+    pub message: String,
+    pub reason: Option<String>,
 }
 
 #[typeshare::typeshare]

crates/bsnext_input/src/bs_live_built_in_task.rs

@@ -5,6 +5,8 @@ use std::str::FromStr;
     Debug, PartialEq, PartialOrd, Ord, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
 )]
 pub enum BsLiveBuiltInTask {
+    #[serde(rename = "notify-clients")]
+    NotifyClients(ClientNotification),
     #[serde(rename = "notify-server")]
     NotifyServer,
     #[serde(rename = "ext-event")]
@@ -14,10 +16,18 @@ pub enum BsLiveBuiltInTask {
 impl FromStr for BsLiveBuiltInTask {
     type Err = anyhow::Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "notify-server" => Ok(Self::NotifyServer),
-            "ext-event" => Ok(Self::PublishExternalEvent),
-            _ => Err(anyhow::anyhow!("not a valid bslive builtin task")),
+        match s.split_once(":") {
+            Some(("notify-clients", message)) => Ok(Self::NotifyClients(
+                ClientNotification::DisplayMessage(DisplayMessage {
+                    message: message.to_owned(),
+                    reason: None,
+                }),
+            )),
+            _ => match s {
+                "notify-server" => Ok(Self::NotifyServer),
+                "ext-event" => Ok(Self::PublishExternalEvent),
+                _ => Err(anyhow::anyhow!("not a valid bslive builtin task")),
+            },
         }
     }
 }
@@ -26,9 +36,25 @@ impl Display for BsLiveBuiltInTask {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             BsLiveBuiltInTask::NotifyServer => write!(f, "BsLiveTask::NotifyServer"),
+            BsLiveBuiltInTask::NotifyClients(..) => write!(f, "BsLiveTask::NotifyClients"),
             BsLiveBuiltInTask::PublishExternalEvent => {
                 write!(f, "BsLiveTask::PublishExternalEvent")
             }
         }
     }
 }
+
+#[derive(
+    Debug, PartialEq, PartialOrd, Ord, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+pub enum ClientNotification {
+    DisplayMessage(DisplayMessage),
+}
+
+#[derive(
+    Debug, PartialEq, PartialOrd, Ord, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+pub struct DisplayMessage {
+    pub message: String,
+    pub reason: Option<String>,
+}

crates/bsnext_system/src/capabilities/servers_addr.rs

@@ -1,17 +1,17 @@
 use crate::capabilities::Capabilities;
 use actix::{Handler, Recipient, ResponseFuture};
-use bsnext_core::servers_supervisor::file_changed_handler::FilesChanged;
+use bsnext_core::servers_supervisor::file_changed_handler::ServersNotification;
 
 #[derive(actix::Message)]
-#[rtype(result = "Result<Recipient<FilesChanged>, anyhow::Error>")]
+#[rtype(result = "Result<Recipient<ServersNotification>, anyhow::Error>")]
 pub struct RequestServersAddr;
 
 impl Handler<RequestServersAddr> for Capabilities {
-    type Result = ResponseFuture<Result<Recipient<FilesChanged>, anyhow::Error>>;
+    type Result = ResponseFuture<Result<Recipient<ServersNotification>, anyhow::Error>>;
 
     #[tracing::instrument(skip_all, name = "RequestServersAddr")]
     fn handle(&mut self, _msg: RequestServersAddr, _ctx: &mut Self::Context) -> Self::Result {
-        let addr: Recipient<FilesChanged> = self.servers_addr.clone().recipient();
+        let addr: Recipient<ServersNotification> = self.servers_addr.clone().recipient();
         Box::pin(async move { Ok(addr) })
     }
 }

crates/bsnext_system/src/tasks/mod.rs

@@ -1,4 +1,5 @@
 use crate::external_event_sender::ExternalEventSenderWithLogging;
+use crate::tasks::notify_clients::NotifyClientsReady;
 use crate::tasks::notify_servers::NotifyServersReady;
 use crate::tasks::sh_cmd::ShCmd;
 use crate::tasks::task_spec::{TaskSpec, TreeDisplay};
@@ -15,6 +16,7 @@ use std::hash::{DefaultHasher, Hash, Hasher};
 
 pub mod comms;
 mod into_recipient;
+pub mod notify_clients;
 pub mod notify_servers;
 pub mod resolve;
 pub mod sh_cmd;
@@ -88,6 +90,11 @@ impl AsActor for RunnableWithComms {
                 let actor = a.start();
                 actor.recipient()
             }
+            Runnable::BsLiveTask(BsLiveBuiltInTask::NotifyClients(client)) => {
+                let a = NotifyClientsReady::new(self.ctx.capabilities.recipient(), client);
+                let actor = a.start();
+                actor.recipient()
+            }
             Runnable::BsLiveTask(BsLiveBuiltInTask::PublishExternalEvent) => {
                 let actor = ExternalEventSenderWithLogging::new(self.ctx.capabilities.recipient());
                 let addr = actor.start();
@@ -124,6 +131,9 @@ impl From<&RunOptItem> for Runnable {
                 BsLiveBuiltInTask::PublishExternalEvent => {
                     Self::BsLiveTask(BsLiveBuiltInTask::PublishExternalEvent)
                 }
+                BsLiveBuiltInTask::NotifyClients(notify_clients) => {
+                    Self::BsLiveTask(BsLiveBuiltInTask::NotifyClients(notify_clients.to_owned()))
+                }
             },
             RunOptItem::Sh(sh) => Self::Sh(ShCmd::from(sh)),
             RunOptItem::ShImplicit(sh) => Self::Sh(ShCmd::new(sh.into())),