From 86379d1c79b2fc74670af16f041a44a3cfa6e90f Mon Sep 17 00:00:00 2001 From: mbecker20 Date: Mon, 19 Jun 2023 08:03:58 +0000 Subject: [PATCH] rename server --- core/src/helpers.rs | 11 +- core/src/monitoring.rs | 4 +- core/src/requests/api/mod.rs | 13 +- core/src/requests/api/server.rs | 269 +++++++++++++++++++------ lib/types/src/entities/server/stats.rs | 2 +- lib/types/src/requests/api/server.rs | 2 +- periphery/src/helpers/stats.rs | 2 +- periphery/src/requests/stats.rs | 2 +- 8 files changed, 234 insertions(+), 71 deletions(-) diff --git a/core/src/helpers.rs b/core/src/helpers.rs index 2d2d21b44..61309525d 100644 --- a/core/src/helpers.rs +++ b/core/src/helpers.rs @@ -4,15 +4,12 @@ use anyhow::{anyhow, Context}; use monitor_types::{ busy::Busy, entities::{ - build::Build, - deployment::Deployment, - server::{self, Server}, - update::Update, - user::User, + build::Build, deployment::Deployment, server::Server, update::Update, user::User, PermissionLevel, }, permissioned::Permissioned, }; +use periphery_client::PeripheryClient; use tokio::sync::RwLock; use crate::{auth::RequestUser, state::State}; @@ -176,6 +173,10 @@ impl State { let _ = self.send_update(update).await; Ok(()) } + + pub fn periphery_client(&self, server: &Server) -> PeripheryClient { + PeripheryClient::new(&server.config.address, &self.config.passkey) + } } #[derive(Default)] diff --git a/core/src/monitoring.rs b/core/src/monitoring.rs index a3c77cf11..b75e5bb86 100644 --- a/core/src/monitoring.rs +++ b/core/src/monitoring.rs @@ -5,7 +5,7 @@ use monitor_types::entities::{ server::{stats::AllSystemStats, Server, ServerStatus}, }; use mungos::mongodb::bson::doc; -use periphery_client::{requests, PeripheryClient}; +use periphery_client::requests; use crate::state::State; @@ -62,7 +62,7 @@ impl State { .await; return; } - let periphery = PeripheryClient::new(&server.config.address, &self.config.passkey); + let periphery = self.periphery_client(server); let version = periphery.request(requests::GetVersion {}).await; if version.is_err() { self.insert_deployments_status_unknown(deployments).await; diff --git a/core/src/requests/api/mod.rs b/core/src/requests/api/mod.rs index 982a03c8c..abd5d243b 100644 --- a/core/src/requests/api/mod.rs +++ b/core/src/requests/api/mod.rs @@ -4,7 +4,7 @@ use monitor_types::requests::api::{ GetServer, GetSystemComponents, GetSystemInformation, GetSystemProcesses, ListServers, RenameServer, UpdateServer, }; -use resolver_api::{derive::Resolver, Resolve}; +use resolver_api::{derive::Resolver, Resolve, ResolveToString}; use serde::{Deserialize, Serialize}; use crate::{auth::RequestUser, state::State}; @@ -35,11 +35,22 @@ pub enum ApiRequest { UpdateServer(UpdateServer), RenameServer(RenameServer), // Stats + #[to_string_resolver] GetAllSystemStats(GetAllSystemStats), + #[to_string_resolver] GetBasicSystemStats(GetBasicSystemStats), + #[to_string_resolver] GetCpuUsage(GetCpuUsage), + #[to_string_resolver] GetDiskUsage(GetDiskUsage), + #[to_string_resolver] GetNetworkUsage(GetNetworkUsage), + #[to_string_resolver] GetSystemProcesses(GetSystemProcesses), + #[to_string_resolver] GetSystemComponents(GetSystemComponents), + + // + // ==== DEPLOYMENT ==== + // } diff --git a/core/src/requests/api/server.rs b/core/src/requests/api/server.rs index c15a27184..b5d8dc7e9 100644 --- a/core/src/requests/api/server.rs +++ b/core/src/requests/api/server.rs @@ -3,14 +3,8 @@ use async_timing_util::unix_timestamp_ms; use async_trait::async_trait; use monitor_types::{ entities::{ - server::{ - stats::{ - AllSystemStats, BasicSystemStats, CpuUsage, DiskUsage, NetworkUsage, - SystemComponent, SystemInformation, SystemProcess, - }, - Server, ServerBuilder, - }, - update::{Update, UpdateTarget}, + server::{stats::SystemInformation, Server}, + update::{Log, Update, UpdateStatus, UpdateTarget}, Operation, PermissionLevel, }, permissioned::Permissioned, @@ -21,7 +15,9 @@ use monitor_types::{ UpdateServer, }, }; -use resolver_api::Resolve; +use mungos::mongodb::bson::doc; +use periphery_client::requests; +use resolver_api::{Resolve, ResolveToString}; use crate::{auth::RequestUser, state::State}; @@ -121,8 +117,51 @@ impl Resolve for State { #[async_trait] impl Resolve for State { - async fn resolve(&self, req: DeleteServer, user: RequestUser) -> anyhow::Result<()> { - todo!() + async fn resolve(&self, req: DeleteServer, user: RequestUser) -> anyhow::Result { + if self.action_states.server.busy(&req.id).await { + return Err(anyhow!("server busy")); + } + + let server = self + .get_server_check_permissions(&req.id, &user, PermissionLevel::Update) + .await?; + + let start_ts = unix_timestamp_ms() as i64; + + let mut update = Update { + target: UpdateTarget::Server(req.id.clone()), + operation: Operation::DeleteServer, + start_ts, + operator: user.id.clone(), + success: true, + status: UpdateStatus::InProgress, + ..Default::default() + }; + + update.id = self.add_update(update.clone()).await?; + + let res = self + .db + .servers + .delete_one(&req.id) + .await + .context("failed to delete server from mongo"); + + let log = match res { + Ok(_) => Log::simple("delete server", format!("deleted server {}", server.name)), + Err(e) => Log::error("delete server", format!("failed to delete server\n{e:#?}")), + }; + + update.end_ts = Some(unix_timestamp_ms() as i64); + update.status = UpdateStatus::Complete; + update.success = log.success; + update.logs.push(log); + + self.update_update(update).await?; + + self.server_status_cache.remove(&req.id).await; + + Ok(server) } } @@ -135,7 +174,22 @@ impl Resolve for State { #[async_trait] impl Resolve for State { - async fn resolve(&self, req: RenameServer, args: RequestUser) -> anyhow::Result { + async fn resolve( + &self, + RenameServer { id, name }: RenameServer, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&id, &user, PermissionLevel::Update) + .await?; + self.db + .updates + .update_one( + &id, + mungos::Update::::Set( + doc! { "name": name, "updated_at": unix_timestamp_ms() as i64 }, + ), + ) + .await?; todo!() } } @@ -144,78 +198,175 @@ impl Resolve for State { impl Resolve for State { async fn resolve( &self, - req: GetSystemInformation, - args: RequestUser, + GetSystemInformation { server_id }: GetSystemInformation, + user: RequestUser, ) -> anyhow::Result { - todo!() + let server = self + .get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + self.periphery_client(&server) + .request(requests::GetSystemInformation {}) + .await } } #[async_trait] -impl Resolve for State { - async fn resolve( +impl ResolveToString for State { + async fn resolve_to_string( &self, - req: GetAllSystemStats, - args: RequestUser, - ) -> anyhow::Result { - todo!() + GetAllSystemStats { server_id }: GetAllSystemStats, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + let status = self + .server_status_cache + .get(&server_id) + .await + .ok_or(anyhow!("did not find status for server at {server_id}"))?; + let stats = status + .stats + .as_ref() + .ok_or(anyhow!("server not reachable"))?; + let stats = serde_json::to_string(&stats)?; + Ok(stats) } } #[async_trait] -impl Resolve for State { - async fn resolve( +impl ResolveToString for State { + async fn resolve_to_string( &self, - req: GetBasicSystemStats, - args: RequestUser, - ) -> anyhow::Result { - todo!() + GetBasicSystemStats { server_id }: GetBasicSystemStats, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + let status = self + .server_status_cache + .get(&server_id) + .await + .ok_or(anyhow!("did not find status for server at {server_id}"))?; + let stats = status + .stats + .as_ref() + .ok_or(anyhow!("server not reachable"))?; + let stats = serde_json::to_string(&stats.basic)?; + Ok(stats) } } #[async_trait] -impl Resolve for State { - async fn resolve(&self, req: GetCpuUsage, args: RequestUser) -> anyhow::Result { - todo!() - } -} - -#[async_trait] -impl Resolve for State { - async fn resolve(&self, req: GetDiskUsage, args: RequestUser) -> anyhow::Result { - todo!() - } -} - -#[async_trait] -impl Resolve for State { - async fn resolve( +impl ResolveToString for State { + async fn resolve_to_string( &self, - req: GetNetworkUsage, - args: RequestUser, - ) -> anyhow::Result { - todo!() + GetCpuUsage { server_id }: GetCpuUsage, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + let status = self + .server_status_cache + .get(&server_id) + .await + .ok_or(anyhow!("did not find status for server at {server_id}"))?; + let stats = status + .stats + .as_ref() + .ok_or(anyhow!("server not reachable"))?; + let stats = serde_json::to_string(&stats.cpu)?; + Ok(stats) } } #[async_trait] -impl Resolve for State { - async fn resolve( +impl ResolveToString for State { + async fn resolve_to_string( &self, - req: GetSystemProcesses, - args: RequestUser, - ) -> anyhow::Result> { - todo!() + GetDiskUsage { server_id }: GetDiskUsage, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + let status = self + .server_status_cache + .get(&server_id) + .await + .ok_or(anyhow!("did not find status for server at {server_id}"))?; + let stats = status + .stats + .as_ref() + .ok_or(anyhow!("server not reachable"))?; + let stats = serde_json::to_string(&stats.disk)?; + Ok(stats) } } #[async_trait] -impl Resolve for State { - async fn resolve( +impl ResolveToString for State { + async fn resolve_to_string( &self, - req: GetSystemComponents, - args: RequestUser, - ) -> anyhow::Result> { - todo!() + GetNetworkUsage { server_id }: GetNetworkUsage, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + let status = self + .server_status_cache + .get(&server_id) + .await + .ok_or(anyhow!("did not find status for server at {server_id}"))?; + let stats = status + .stats + .as_ref() + .ok_or(anyhow!("server not reachable"))?; + let stats = serde_json::to_string(&stats.network)?; + Ok(stats) + } +} + +#[async_trait] +impl ResolveToString for State { + async fn resolve_to_string( + &self, + GetSystemProcesses { server_id }: GetSystemProcesses, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + let status = self + .server_status_cache + .get(&server_id) + .await + .ok_or(anyhow!("did not find status for server at {server_id}"))?; + let stats = status + .stats + .as_ref() + .ok_or(anyhow!("server not reachable"))?; + let stats = serde_json::to_string(&stats.processes)?; + Ok(stats) + } +} + +#[async_trait] +impl ResolveToString for State { + async fn resolve_to_string( + &self, + GetSystemComponents { server_id }: GetSystemComponents, + user: RequestUser, + ) -> anyhow::Result { + self.get_server_check_permissions(&server_id, &user, PermissionLevel::Read) + .await?; + let status = self + .server_status_cache + .get(&server_id) + .await + .ok_or(anyhow!("did not find status for server at {server_id}"))?; + let stats = status + .stats + .as_ref() + .ok_or(anyhow!("server not reachable"))?; + let stats = serde_json::to_string(&stats.components)?; + Ok(stats) } } diff --git a/lib/types/src/entities/server/stats.rs b/lib/types/src/entities/server/stats.rs index f2c3dc062..0681d401e 100644 --- a/lib/types/src/entities/server/stats.rs +++ b/lib/types/src/entities/server/stats.rs @@ -26,7 +26,7 @@ pub struct AllSystemStats { #[serde(default)] pub processes: Vec, #[serde(default)] - pub componenets: Vec, + pub components: Vec, pub polling_rate: Timelength, pub refresh_ts: I64, pub refresh_list_ts: I64, diff --git a/lib/types/src/requests/api/server.rs b/lib/types/src/requests/api/server.rs index d90a96319..460aacecd 100644 --- a/lib/types/src/requests/api/server.rs +++ b/lib/types/src/requests/api/server.rs @@ -36,7 +36,7 @@ pub struct CreateServer { #[typeshare] #[derive(Serialize, Deserialize, Debug, Clone, Request)] -#[response(())] +#[response(Server)] pub struct DeleteServer { pub id: String, } diff --git a/periphery/src/helpers/stats.rs b/periphery/src/helpers/stats.rs index 7c80c0595..05417db88 100644 --- a/periphery/src/helpers/stats.rs +++ b/periphery/src/helpers/stats.rs @@ -81,7 +81,7 @@ impl InnerStatsClient { disk: self.get_disk_usage(), network: self.get_network_usage(), processes: self.get_processes(), - componenets: self.get_components(), + components: self.get_components(), polling_rate: self.stats.polling_rate, refresh_ts: self.stats.refresh_ts, refresh_list_ts: self.stats.refresh_list_ts, diff --git a/periphery/src/requests/stats.rs b/periphery/src/requests/stats.rs index 88fbd5974..cf204ab0e 100644 --- a/periphery/src/requests/stats.rs +++ b/periphery/src/requests/stats.rs @@ -113,7 +113,7 @@ pub struct GetSystemComponents {} #[async_trait::async_trait] impl ResolveToString for State { async fn resolve_to_string(&self, _: GetSystemComponents, _: ()) -> anyhow::Result { - let stats = &self.stats.read().await.stats.componenets; + let stats = &self.stats.read().await.stats.components; serde_json::to_string(&stats).context("failed to serialize response to string") } }