Feat/stats (#2761)

* Feat: Add the memory for the stats.

* Chore: Add %

core/startos/src/lxc/dev.rs

@@ -8,10 +8,13 @@ use rpc_toolkit::{
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 
-use crate::context::{CliContext, RpcContext};
 use crate::lxc::{ContainerId, LxcConfig};
 use crate::prelude::*;
 use crate::rpc_continuations::Guid;
+use crate::{
+    context::{CliContext, RpcContext},
+    service::ServiceStats,
+};
 
 pub fn lxc<C: Context>() -> ParentHandler<C> {
     ParentHandler::new()
@@ -36,6 +39,42 @@ pub fn lxc<C: Context>() -> ParentHandler<C> {
                 .with_about("List lxc containers")
                 .with_call_remote::<CliContext>(),
         )
+        .subcommand(
+            "stats",
+            from_fn_async(stats)
+                .with_custom_display_fn(|_, res| {
+                    use prettytable::*;
+                    let mut table = table!([
+                        "Container ID",
+                        "Name",
+                        "Memory Usage",
+                        "Memory Limit",
+                        "Memory %"
+                    ]);
+                    for ServiceStats {
+                        container_id,
+                        package_id,
+                        memory_usage,
+                        memory_limit,
+                    } in res
+                    {
+                        table.add_row(row![
+                            &*container_id,
+                            &*package_id,
+                            memory_usage,
+                            memory_limit,
+                            format!(
+                                "{:.2}",
+                                memory_usage.0 as f64 / memory_limit.0 as f64 * 100.0
+                            )
+                        ]);
+                    }
+                    table.printstd();
+                    Ok(())
+                })
+                .with_about("List information related to the lxc containers i.e. CPU, Memory, Disk")
+                .with_call_remote::<CliContext>(),
+        )
         .subcommand(
             "remove",
             from_fn_async(remove)
@@ -63,6 +102,22 @@ pub async fn list(ctx: RpcContext) -> Result<Vec<ContainerId>, Error> {
     Ok(ctx.dev.lxc.lock().await.keys().cloned().collect())
 }
 
+pub async fn stats(ctx: RpcContext) -> Result<Vec<ServiceStats>, Error> {
+    let ids = ctx.db.peek().await.as_public().as_package_data().keys()?;
+    let guids: Vec<_> = ctx.dev.lxc.lock().await.keys().cloned().collect();
+
+    let mut stats = Vec::with_capacity(guids.len());
+    for id in ids {
+        let service: tokio::sync::OwnedRwLockReadGuard<Option<crate::service::ServiceRef>> =
+            ctx.services.get(&id).await;
+
+        let service_ref = service.as_ref().or_not_found(&id)?;
+
+        stats.push(service_ref.stats().await?);
+    }
+    Ok(stats)
+}
+
 #[derive(Deserialize, Serialize, Parser, TS)]
 pub struct RemoveParams {
     #[ts(type = "string")]

core/startos/src/lxc/mod.rs

@@ -1,8 +1,8 @@
-use std::collections::BTreeSet;
 use std::net::Ipv4Addr;
 use std::path::Path;
 use std::sync::{Arc, Weak};
 use std::time::Duration;
+use std::{collections::BTreeSet, ffi::OsString};
 
 use clap::builder::ValueParserFactory;
 use futures::{AsyncWriteExt, StreamExt};
@@ -32,7 +32,7 @@ use crate::util::io::open_file;
 use crate::util::rpc_client::UnixRpcClient;
 use crate::util::{new_guid, Invoke};
 
-#[cfg(feature = "dev")]
+// #[cfg(feature = "dev")]
 pub mod dev;
 
 const LXC_CONTAINER_DIR: &str = "/var/lib/lxc";
@@ -287,6 +287,30 @@ impl LxcContainer {
         self.rpc_bind.path()
     }
 
+    pub async fn command(&self, commands: &[&str]) -> Result<String, Error> {
+        let mut cmd = Command::new("lxc-attach");
+        cmd.kill_on_drop(true);
+
+        let output = cmd
+            .arg(&**self.guid)
+            .arg("--")
+            .args(commands)
+            .output()
+            .await?;
+
+        if !output.status.success() {
+            return Err(Error::new(
+                eyre!(
+                    "Command failed with exit code: {:?} \n Message: {:?}",
+                    output.status.code(),
+                    String::from_utf8(output.stderr)
+                ),
+                ErrorKind::Docker,
+            ));
+        }
+        Ok(String::from_utf8(output.stdout)?)
+    }
+
     #[instrument(skip_all)]
     pub async fn exit(mut self) -> Result<(), Error> {
         Command::new("lxc-stop")