ComputerSurge/komodo
3
0
Fork 0
forked from github-starred/komodo
Code Pull Requests Packages Releases Activity

rename server

Browse Source
This commit is contained in:
mbecker20
2023-06-19 08:03:58 +00:00
parent 6320d6fbeb
commit 86379d1c79
8 changed files with 234 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
core/src/helpers.rs
View File

@@ -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)]

4
core/src/monitoring.rs
View File

@@ -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;

13
core/src/requests/api/mod.rs
View File

@@ -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 ====
//
}

269
core/src/requests/api/server.rs
View File

@@ -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<CreateServer, RequestUser> for State {
#[async_trait]
impl Resolve<DeleteServer, RequestUser> for State {
async fn resolve(&self, req: DeleteServer, user: RequestUser) -> anyhow::Result<()> {
todo!()
async fn resolve(&self, req: DeleteServer, user: RequestUser) -> anyhow::Result<Server> {
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<UpdateServer, RequestUser> for State {
#[async_trait]
impl Resolve<RenameServer, RequestUser> for State {
async fn resolve(&self, req: RenameServer, args: RequestUser) -> anyhow::Result<Server> {
async fn resolve(
&self,
RenameServer { id, name }: RenameServer,
user: RequestUser,
) -> anyhow::Result<Server> {
self.get_server_check_permissions(&id, &user, PermissionLevel::Update)
.await?;
self.db
.updates
.update_one(
&id,
mungos::Update::<Server>::Set(
doc! { "name": name, "updated_at": unix_timestamp_ms() as i64 },
),
)
.await?;
todo!()
}
}
@@ -144,78 +198,175 @@ impl Resolve<RenameServer, RequestUser> for State {
impl Resolve<GetSystemInformation, RequestUser> for State {
async fn resolve(
&self,
req: GetSystemInformation,
args: RequestUser,
GetSystemInformation { server_id }: GetSystemInformation,
user: RequestUser,
) -> anyhow::Result<SystemInformation> {
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<GetAllSystemStats, RequestUser> for State {
async fn resolve(
impl ResolveToString<GetAllSystemStats, RequestUser> for State {
async fn resolve_to_string(
&self,
req: GetAllSystemStats,
args: RequestUser,
) -> anyhow::Result<AllSystemStats> {
todo!()
GetAllSystemStats { server_id }: GetAllSystemStats,
user: RequestUser,
) -> anyhow::Result<String> {
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<GetBasicSystemStats, RequestUser> for State {
async fn resolve(
impl ResolveToString<GetBasicSystemStats, RequestUser> for State {
async fn resolve_to_string(
&self,
req: GetBasicSystemStats,
args: RequestUser,
) -> anyhow::Result<BasicSystemStats> {
todo!()
GetBasicSystemStats { server_id }: GetBasicSystemStats,
user: RequestUser,
) -> anyhow::Result<String> {
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<GetCpuUsage, RequestUser> for State {
async fn resolve(&self, req: GetCpuUsage, args: RequestUser) -> anyhow::Result<CpuUsage> {
todo!()
}
}
#[async_trait]
impl Resolve<GetDiskUsage, RequestUser> for State {
async fn resolve(&self, req: GetDiskUsage, args: RequestUser) -> anyhow::Result<DiskUsage> {
todo!()
}
}
#[async_trait]
impl Resolve<GetNetworkUsage, RequestUser> for State {
async fn resolve(
impl ResolveToString<GetCpuUsage, RequestUser> for State {
async fn resolve_to_string(
&self,
req: GetNetworkUsage,
args: RequestUser,
) -> anyhow::Result<NetworkUsage> {
todo!()
GetCpuUsage { server_id }: GetCpuUsage,
user: RequestUser,
) -> anyhow::Result<String> {
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<GetSystemProcesses, RequestUser> for State {
async fn resolve(
impl ResolveToString<GetDiskUsage, RequestUser> for State {
async fn resolve_to_string(
&self,
req: GetSystemProcesses,
args: RequestUser,
) -> anyhow::Result<Vec<SystemProcess>> {
todo!()
GetDiskUsage { server_id }: GetDiskUsage,
user: RequestUser,
) -> anyhow::Result<String> {
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<GetSystemComponents, RequestUser> for State {
async fn resolve(
impl ResolveToString<GetNetworkUsage, RequestUser> for State {
async fn resolve_to_string(
&self,
req: GetSystemComponents,
args: RequestUser,
) -> anyhow::Result<Vec<SystemComponent>> {
todo!()
GetNetworkUsage { server_id }: GetNetworkUsage,
user: RequestUser,
) -> anyhow::Result<String> {
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<GetSystemProcesses, RequestUser> for State {
async fn resolve_to_string(
&self,
GetSystemProcesses { server_id }: GetSystemProcesses,
user: RequestUser,
) -> anyhow::Result<String> {
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<GetSystemComponents, RequestUser> for State {
async fn resolve_to_string(
&self,
GetSystemComponents { server_id }: GetSystemComponents,
user: RequestUser,
) -> anyhow::Result<String> {
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)
}
}

2
lib/types/src/entities/server/stats.rs
View File

@@ -26,7 +26,7 @@ pub struct AllSystemStats {
#[serde(default)]
pub processes: Vec<SystemProcess>,
#[serde(default)]
pub componenets: Vec<SystemComponent>,
pub components: Vec<SystemComponent>,
pub polling_rate: Timelength,
pub refresh_ts: I64,
pub refresh_list_ts: I64,

2
lib/types/src/requests/api/server.rs
View File

@@ -36,7 +36,7 @@ pub struct CreateServer {
#[typeshare]
#[derive(Serialize, Deserialize, Debug, Clone, Request)]
#[response(())]
#[response(Server)]
pub struct DeleteServer {
pub id: String,
}

2
periphery/src/helpers/stats.rs
View File

@@ -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,

2
periphery/src/requests/stats.rs
View File

@@ -113,7 +113,7 @@ pub struct GetSystemComponents {}
#[async_trait::async_trait]
impl ResolveToString<GetSystemComponents> for State {
async fn resolve_to_string(&self, _: GetSystemComponents, _: ()) -> anyhow::Result<String> {
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")
}
}