server name on DeploymentStateChange

bin/core/src/helpers/alert.rs

@@ -192,7 +192,7 @@ async fn send_slack_alert(url: &str, alert: &Alert) -> anyhow::Result<()> {
         }
         AlertData::ContainerStateChange {
             name,
-            server,
+            server_name,
             from,
             to,
             ..
@@ -201,7 +201,7 @@ async fn send_slack_alert(url: &str, alert: &Alert) -> anyhow::Result<()> {
             let text = format!("📦 container *{name}* is now {to}");
             let blocks = vec![
                 Block::header(format!("📦 container *{name}* is now {to}")),
-                Block::section(format!("server: {server}\nprevious: {from}")),
+                Block::section(format!("server: {server_name}\nprevious: {from}")),
             ];
             (text, blocks.into())
         }

bin/core/src/monitor/alert/deployment.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use monitor_types::entities::{
     alert::{Alert, AlertData, AlertDataVariant},
     deployment::Deployment,
@@ -8,7 +10,7 @@ use monitor_types::entities::{
 use crate::{helpers::resource::StateResource, state::State};
 
 impl State {
-    pub async fn alert_deployments(&self, ts: i64) {
+    pub async fn alert_deployments(&self, ts: i64, server_names: HashMap<String, String>) {
         let mut alerts = Vec::<Alert>::new();
         for v in self.deployment_status_cache.get_list().await {
             if v.prev.is_none() {
@@ -27,7 +29,11 @@ impl State {
                 let data = AlertData::ContainerStateChange {
                     id: v.curr.id.clone(),
                     name: d.name,
-                    server: d.config.server_id,
+                    server_name: server_names
+                        .get(&d.config.server_id)
+                        .cloned()
+                        .unwrap_or(String::from("unknown")),
+                    server_id: d.config.server_id,
                     from: prev,
                     to: v.curr.state,
                 };

bin/core/src/monitor/alert/mod.rs

@@ -1,11 +1,56 @@
 mod deployment;
 mod server;
 
-use crate::state::State;
+use std::collections::HashMap;
+
+use anyhow::Context;
+use monitor_types::entities::server::{Server, ServerListItem};
+
+use crate::{auth::InnerRequestUser, helpers::resource::StateResource, state::State};
 
 impl State {
     // called after cache update
     pub async fn check_alerts(&self, ts: i64) {
-        tokio::join!(self.alert_servers(ts), self.alert_deployments(ts));
+        let servers = self.get_all_servers_map().await;
+
+        if let Err(e) = servers {
+            error!("{e:#?}");
+            return;
+        }
+
+        let (servers, server_names) = servers.unwrap();
+
+        tokio::join!(
+            self.alert_servers(ts, servers),
+            self.alert_deployments(ts, server_names)
+        );
+    }
+
+    async fn get_all_servers_map(
+        &self,
+    ) -> anyhow::Result<(HashMap<String, ServerListItem>, HashMap<String, String>)> {
+        let servers = <State as StateResource<Server>>::list_resources_for_user(
+            self,
+            None,
+            &InnerRequestUser {
+                is_admin: true,
+                ..Default::default()
+            }
+            .into(),
+        )
+        .await
+        .context("failed to get servers from db (in alert_servers)")?;
+
+        let servers = servers
+            .into_iter()
+            .map(|server| (server.id.clone(), server))
+            .collect::<HashMap<_, _>>();
+
+        let server_names = servers
+            .iter()
+            .map(|(id, server)| (id.clone(), server.name.clone()))
+            .collect::<HashMap<_, _>>();
+
+        Ok((servers, server_names))
     }
 }

bin/core/src/monitor/alert/server.rs

@@ -4,7 +4,7 @@ use anyhow::Context;
 use monitor_types::{
     entities::{
         alert::{Alert, AlertData, AlertDataVariant},
-        server::{stats::SeverityLevel, Server, ServerListItem, ServerStatus},
+        server::{stats::SeverityLevel, ServerStatus, ServerListItem},
         update::ResourceTarget,
     },
     monitor_timestamp, optional_string,
@@ -14,23 +14,15 @@ use mungos::{
     BulkUpdate,
 };
 
-use crate::{auth::InnerRequestUser, helpers::resource::StateResource, state::State};
+use crate::state::State;
 
 type OpenAlertMap<T = AlertDataVariant> = HashMap<ResourceTarget, HashMap<T, Alert>>;
 type OpenDiskAlertMap = OpenAlertMap<PathBuf>;
 type OpenTempAlertMap = OpenAlertMap<String>;
 
 impl State {
-    pub async fn alert_servers(&self, ts: i64) {
+    pub async fn alert_servers(&self, ts: i64, mut servers: HashMap<String, ServerListItem>) {
         let server_statuses = self.server_status_cache.get_list().await;
-        let servers = self.get_all_servers_map().await;
-
-        if let Err(e) = servers {
-            error!("{e:#?}");
-            return;
-        }
-
-        let mut servers = servers.unwrap();
 
         let alerts = self.get_open_alerts().await;
 
@@ -511,25 +503,4 @@ impl State {
 
         Ok((map, disk_map, temp_map))
     }
-
-    async fn get_all_servers_map(&self) -> anyhow::Result<HashMap<String, ServerListItem>> {
-        let servers = <State as StateResource<Server>>::list_resources_for_user(
-            self,
-            None,
-            &InnerRequestUser {
-                is_admin: true,
-                ..Default::default()
-            }
-            .into(),
-        )
-        .await
-        .context("failed to get servers from db (in alert_servers)")?;
-
-        let servers = servers
-            .into_iter()
-            .map(|server| (server.id.clone(), server))
-            .collect::<HashMap<_, _>>();
-
-        Ok(servers)
-    }
 }

lib/types/src/entities/alert.rs

@@ -99,7 +99,8 @@ pub enum AlertData {
     ContainerStateChange {
         id: String,
         name: String,
-        server: String, // server name
+        server_id: String,
+        server_name: String,
         from: DockerContainerState,
         to: DockerContainerState,
     },