diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index d042e3a4ab59041abc5a1353ee4d43c44543c4a2..b30e8fad62ab1daec2a65942f5e008d397370fa4 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,5 +1,5 @@ stages: [build, release] -image: 'themackabu/rust:zigbuild-1.77.0' +image: 'themackabu/rust:zigbuild-1.79.0' before_script: - mkdir binary diff --git a/.harness-ci.yml b/.harness-ci.yml index d0f68200ae0128411a65db78aa5e04a9c41b7fa9..ce1d857ba99ec68a634e32b47614d7552a32a1ba 100644 --- a/.harness-ci.yml +++ b/.harness-ci.yml @@ -9,7 +9,7 @@ spec: - name: build type: run spec: - container: themackabu/rust:zigbuild-1.77.0 + container: themackabu/rust:zigbuild-1.79.0 script: |- apt-get update -yqq apt-get install -yqq zip clang llvm diff --git a/build.rs b/build.rs index 6c6ad36d162cce01379268874c7302ffcfb1cbb1..cbe98d7d3489b25460ed0d15004ae0ed3ee0207c 100644 --- a/build.rs +++ b/build.rs @@ -132,27 +132,26 @@ fn main() { /* profile matching */ match profile.as_str() { "debug" => println!("cargo:rustc-env=PROFILE=debug"), - "release" => { - /* cleanup */ - fs::remove_dir_all(format!("src/webui/dist")).ok(); - println!("cargo:rustc-env=PROFILE=release"); - - /* pre-build */ - let path = download_node(); - download_then_build(path); - - /* cc linking */ - cxx_build::bridge("src/lib.rs") - .file("lib/bridge.cc") - .file("lib/process.cc") - .file("lib/fork.cc") - .include("lib/include") - .flag_if_supported("-std=c++17") - .compile("bridge"); - } + "release" => println!("cargo:rustc-env=PROFILE=release"), _ => println!("cargo:rustc-env=PROFILE=none"), } + /* cleanup */ + fs::remove_dir_all(format!("src/webui/dist")).ok(); + + /* pre-build */ + let path = download_node(); + download_then_build(path); + + /* cc linking */ + cxx_build::bridge("src/lib.rs") + .file("lib/bridge.cc") + .file("lib/process.cc") + .file("lib/fork.cc") + .include("lib/include") + .flag_if_supported("-std=c++17") + .compile("bridge"); + let watched = vec![ "lib", "src/lib.rs", diff --git a/src/cli/args.rs b/src/cli/args.rs new file mode 100644 index 0000000000000000000000000000000000000000..a5a04fa11ab73ab52203c5de23d5c4a1c5ce77e8 --- /dev/null +++ b/src/cli/args.rs @@ -0,0 +1,34 @@ +pub trait Validatable { + fn from_id(id: usize) -> Self; + fn from_string(s: String) -> Self; +} + +#[derive(Clone)] +pub enum Args { + Id(usize), + Script(String), +} + +#[derive(Clone)] +pub enum Item { + Id(usize), + Name(String), +} + +impl Validatable for Args { + fn from_id(id: usize) -> Self { Args::Id(id) } + fn from_string(s: String) -> Self { Args::Script(s) } +} + +impl Validatable for Item { + fn from_id(id: usize) -> Self { Item::Id(id) } + fn from_string(s: String) -> Self { Item::Name(s) } +} + +pub fn validate(s: &str) -> Result { + if let Ok(id) = s.parse::() { + Ok(T::from_id(id)) + } else { + Ok(T::from_string(s.to_owned())) + } +} diff --git a/src/cli/internal.rs b/src/cli/internal.rs index 1fc9b741cd127fe5c2a92d4f524922a06e0506bf..681dc93fee3e4a9d359614d18c52c17c819e3eb4 100644 --- a/src/cli/internal.rs +++ b/src/cli/internal.rs @@ -1,12 +1,32 @@ -use macros_rs::{crashln, string}; -use pmc::{config, file, helpers, log, process::Runner}; +use colored::Colorize; +use macros_rs::{crashln, string, ternary}; +use psutil::process::{MemoryInfo, Process}; use regex::Regex; +use serde::Serialize; +use serde_json::json; + +use pmc::{ + config, file, + helpers::{self, ColoredString}, + log, + process::{http, ItemSingle, Runner}, +}; + +use tabled::{ + settings::{ + object::{Columns, Rows}, + style::{BorderColor, Style}, + themes::Colorization, + Color, Modify, Rotate, Width, + }, + Table, Tabled, +}; pub struct Internal<'i> { pub id: usize, pub runner: Runner, pub kind: String, - pub server_name: &'i String, + pub server_name: &'i str, } impl<'i> Internal<'i> { @@ -17,7 +37,7 @@ impl<'i> Internal<'i> { None => string!(script.split_whitespace().next().unwrap_or_default()), }; - if matches!(&**self.server_name, "internal" | "local") { + if matches!(self.server_name, "internal" | "local") { let pattern = Regex::new(r"(?m)^[a-zA-Z0-9]+(/[a-zA-Z0-9]+)*(\.js|\.ts)?$").unwrap(); if pattern.is_match(script) { @@ -32,7 +52,7 @@ impl<'i> Internal<'i> { }; if let Some(server) = servers.get(self.server_name) { - match Runner::connect(self.server_name.clone(), server.get(), false) { + match Runner::connect(self.server_name.into(), server.get(), false) { Some(mut remote) => remote.start(&name, script, file::cwd(), watch), None => crashln!("{} Failed to connect (name={}, address={})", *helpers::FAIL, self.server_name, server.address), }; @@ -48,7 +68,7 @@ impl<'i> Internal<'i> { pub fn restart(self, name: &Option, watch: &Option) { println!("{} Applying {}action restartProcess on ({})", *helpers::SUCCESS, self.kind, self.id); - if matches!(&**self.server_name, "internal" | "local") { + if matches!(self.server_name, "internal" | "local") { let mut item = self.runner.get(self.id); match watch { @@ -66,7 +86,7 @@ impl<'i> Internal<'i> { }; if let Some(server) = servers.get(self.server_name) { - match Runner::connect(self.server_name.clone(), server.get(), false) { + match Runner::connect(self.server_name.into(), server.get(), false) { Some(remote) => { let mut item = remote.get(self.id); @@ -86,13 +106,13 @@ impl<'i> Internal<'i> { pub fn stop(mut self) { println!("{} Applying {}action stopProcess on ({})", *helpers::SUCCESS, self.kind, self.id); - if !matches!(&**self.server_name, "internal" | "local") { + if !matches!(self.server_name, "internal" | "local") { let Some(servers) = config::servers().servers else { crashln!("{} Failed to read servers", *helpers::FAIL) }; if let Some(server) = servers.get(self.server_name) { - self.runner = match Runner::connect(self.server_name.clone(), server.get(), false) { + self.runner = match Runner::connect(self.server_name.into(), server.get(), false) { Some(remote) => remote, None => crashln!("{} Failed to connect (name={}, address={})", *helpers::FAIL, self.server_name, server.address), }; @@ -109,13 +129,13 @@ impl<'i> Internal<'i> { pub fn remove(mut self) { println!("{} Applying {}action removeProcess on ({})", *helpers::SUCCESS, self.kind, self.id); - if !matches!(&**self.server_name, "internal" | "local") { + if !matches!(self.server_name, "internal" | "local") { let Some(servers) = config::servers().servers else { crashln!("{} Failed to read servers", *helpers::FAIL) }; if let Some(server) = servers.get(self.server_name) { - self.runner = match Runner::connect(self.server_name.clone(), server.get(), false) { + self.runner = match Runner::connect(self.server_name.into(), server.get(), false) { Some(remote) => remote, None => crashln!("{} Failed to remove (name={}, address={})", *helpers::FAIL, self.server_name, server.address), }; @@ -128,4 +148,431 @@ impl<'i> Internal<'i> { println!("{} removed {}({}) ✓", *helpers::SUCCESS, self.kind, self.id); log!("process removed (id={})", self.id); } + + pub fn info(&self, format: &String) { + #[derive(Clone, Debug, Tabled)] + struct Info { + #[tabled(rename = "error log path ")] + log_error: String, + #[tabled(rename = "out log path")] + log_out: String, + #[tabled(rename = "cpu percent")] + cpu_percent: String, + #[tabled(rename = "memory usage")] + memory_usage: String, + #[tabled(rename = "path hash")] + hash: String, + #[tabled(rename = "watching")] + watch: String, + children: String, + #[tabled(rename = "exec cwd")] + path: String, + #[tabled(rename = "script command ")] + command: String, + #[tabled(rename = "script id")] + id: String, + restarts: u64, + uptime: String, + pid: String, + name: String, + status: ColoredString, + } + + impl Serialize for Info { + fn serialize(&self, serializer: S) -> Result { + let trimmed_json = json!({ + "id": &self.id.trim(), + "pid": &self.pid.trim(), + "name": &self.name.trim(), + "path": &self.path.trim(), + "restarts": &self.restarts, + "hash": &self.hash.trim(), + "watch": &self.watch.trim(), + "children": &self.children, + "uptime": &self.uptime.trim(), + "status": &self.status.0.trim(), + "log_out": &self.log_out.trim(), + "cpu": &self.cpu_percent.trim(), + "command": &self.command.trim(), + "mem": &self.memory_usage.trim(), + "log_error": &self.log_error.trim(), + }); + + trimmed_json.serialize(serializer) + } + } + + let render_info = |data: Vec| { + let table = Table::new(data.clone()) + .with(Rotate::Left) + .with(Style::rounded().remove_horizontals()) + .with(Colorization::exact([Color::FG_CYAN], Columns::first())) + .with(BorderColor::filled(Color::FG_BRIGHT_BLACK)) + .to_string(); + + if let Ok(json) = serde_json::to_string(&data[0]) { + match format.as_str() { + "raw" => println!("{:?}", data[0]), + "json" => println!("{json}"), + _ => { + println!("{}\n{table}\n", format!("Describing {}process with id ({})", self.kind, self.id).on_bright_white().black()); + println!(" {}", format!("Use `pmc logs {} [--lines ]` to display logs", self.id).white()); + println!(" {}", format!("Use `pmc env {}` to display environment variables", self.id).white()); + } + }; + }; + }; + + if matches!(self.server_name, "internal" | "local") { + if let Some(home) = home::home_dir() { + let config = config::read().runner; + let mut runner = Runner::new(); + let item = runner.process(self.id); + + let mut memory_usage: Option = None; + let mut cpu_percent: Option = None; + + let path = file::make_relative(&item.path, &home).to_string_lossy().into_owned(); + let children = if item.children.is_empty() { "none".to_string() } else { format!("{:?}", item.children) }; + + if let Ok(mut process) = Process::new(item.pid as u32) { + memory_usage = process.memory_info().ok(); + cpu_percent = process.cpu_percent().ok(); + } + + let cpu_percent = match cpu_percent { + Some(percent) => format!("{:.2}%", percent), + None => string!("0%"), + }; + + let memory_usage = match memory_usage { + Some(usage) => helpers::format_memory(usage.rss()), + None => string!("0b"), + }; + + let status = if item.running { + "online ".green().bold() + } else { + match item.crash.crashed { + true => "crashed ", + false => "stopped ", + } + .red() + .bold() + }; + + let data = vec![Info { + children, + cpu_percent, + memory_usage, + id: string!(self.id), + restarts: item.restarts, + name: item.name.clone(), + log_out: item.logs().out, + path: format!("{} ", path), + log_error: item.logs().error, + status: ColoredString(status), + pid: ternary!(item.running, format!("{}", item.pid), string!("n/a")), + command: format!("{} {} '{}'", config.shell, config.args.join(" "), item.script), + hash: ternary!(item.watch.enabled, format!("{} ", item.watch.hash), string!("none ")), + watch: ternary!(item.watch.enabled, format!("{path}/{} ", item.watch.path), string!("disabled ")), + uptime: ternary!(item.running, format!("{}", helpers::format_duration(item.started)), string!("none")), + }]; + + render_info(data) + } else { + crashln!("{} Impossible to get your home directory", *helpers::FAIL); + } + } else { + let data: (pmc::process::Process, Runner); + let Some(servers) = config::servers().servers else { + crashln!("{} Failed to read servers", *helpers::FAIL) + }; + + if let Some(server) = servers.get(self.server_name) { + data = match Runner::connect(self.server_name.into(), server.get(), false) { + Some(mut remote) => (remote.process(self.id).clone(), remote), + None => crashln!("{} Failed to connect (name={}, address={})", *helpers::FAIL, self.server_name, server.address), + }; + } else { + crashln!("{} Server '{}' does not exist", *helpers::FAIL, self.server_name) + }; + + let (item, remote) = data; + let remote = remote.remote.unwrap(); + let info = http::info(&remote, self.id); + let path = item.path.to_string_lossy().into_owned(); + + let status = if item.running { + "online ".green().bold() + } else { + match item.crash.crashed { + true => "crashed ", + false => "stopped ", + } + .red() + .bold() + }; + + if let Ok(info) = info { + let stats = info.json::().unwrap().stats; + let children = if item.children.is_empty() { "none".to_string() } else { format!("{:?}", item.children) }; + + let cpu_percent = match stats.cpu_percent { + Some(percent) => format!("{percent:.2}%"), + None => string!("0%"), + }; + + let memory_usage = match stats.memory_usage { + Some(usage) => helpers::format_memory(usage.rss), + None => string!("0b"), + }; + + let data = vec![Info { + children, + cpu_percent, + memory_usage, + id: string!(self.id), + path: path.clone(), + status: status.into(), + restarts: item.restarts, + name: item.name.clone(), + pid: ternary!(item.running, format!("{pid}", pid = item.pid), string!("n/a")), + log_out: format!("{}/{}-out.log", remote.config.log_path, item.name), + log_error: format!("{}/{}-error.log", remote.config.log_path, item.name), + hash: ternary!(item.watch.enabled, format!("{} ", item.watch.hash), string!("none ")), + command: format!("{} {} '{}'", remote.config.shell, remote.config.args.join(" "), item.script), + watch: ternary!(item.watch.enabled, format!("{path}/{} ", item.watch.path), string!("disabled ")), + uptime: ternary!(item.running, format!("{}", helpers::format_duration(item.started)), string!("none")), + }]; + + render_info(data) + } + } + } + + pub fn logs(mut self, lines: &usize) { + if !matches!(self.server_name, "internal" | "local") { + let Some(servers) = config::servers().servers else { + crashln!("{} Failed to read servers", *helpers::FAIL) + }; + + if let Some(server) = servers.get(self.server_name) { + self.runner = match Runner::connect(self.server_name.into(), server.get(), false) { + Some(remote) => remote, + None => crashln!("{} Failed to connect (name={}, address={})", *helpers::FAIL, self.server_name, server.address), + }; + } else { + crashln!("{} Server '{}' does not exist", *helpers::FAIL, self.server_name) + }; + + let item = self.runner.info(self.id).unwrap_or_else(|| crashln!("{} Process ({}) not found", *helpers::FAIL, self.id)); + println!( + "{}", + format!("Showing last {lines} lines for {}process [{}] (change the value with --lines option)", self.kind, self.id).yellow() + ); + + for kind in vec!["error", "out"] { + let logs = http::logs(&self.runner.remote.as_ref().unwrap(), self.id, kind); + + if let Ok(log) = logs { + if log.lines.is_empty() { + println!("{} No logs found for {}/{kind}", *helpers::FAIL, item.name); + continue; + } + + file::logs_internal(log.lines, *lines, log.path, self.id, kind, &item.name) + } + } + } else { + let item = self.runner.info(self.id).unwrap_or_else(|| crashln!("{} Process ({}) not found", *helpers::FAIL, self.id)); + println!( + "{}", + format!("Showing last {lines} lines for {}process [{}] (change the value with --lines option)", self.kind, self.id).yellow() + ); + + file::logs(item, *lines, "error"); + file::logs(item, *lines, "out"); + } + } + + pub fn env(mut self) { + println!("{}", format!("Showing env for {}process {}:\n", self.kind, self.id).bright_yellow()); + + if !matches!(self.server_name, "internal" | "local") { + let Some(servers) = config::servers().servers else { + crashln!("{} Failed to read servers", *helpers::FAIL) + }; + + if let Some(server) = servers.get(self.server_name) { + self.runner = match Runner::connect(self.server_name.into(), server.get(), false) { + Some(remote) => remote, + None => crashln!("{} Failed to connect (name={}, address={})", *helpers::FAIL, self.server_name, server.address), + }; + } else { + crashln!("{} Server '{}' does not exist", *helpers::FAIL, self.server_name) + }; + } + + let item = self.runner.process(self.id); + item.env.iter().for_each(|(key, value)| println!("{}: {}", key, value.green())); + } + + pub fn list(format: &String, server_name: &String) { + let render_list = |runner: &mut Runner, internal: bool| { + let mut processes: Vec = Vec::new(); + + #[derive(Tabled, Debug)] + struct ProcessItem { + id: ColoredString, + name: String, + pid: String, + uptime: String, + #[tabled(rename = "↺")] + restarts: String, + status: ColoredString, + cpu: String, + mem: String, + #[tabled(rename = "watching")] + watch: String, + } + + impl serde::Serialize for ProcessItem { + fn serialize(&self, serializer: S) -> Result { + let trimmed_json = json!({ + "cpu": &self.cpu.trim(), + "mem": &self.mem.trim(), + "id": &self.id.0.trim(), + "pid": &self.pid.trim(), + "name": &self.name.trim(), + "watch": &self.watch.trim(), + "uptime": &self.uptime.trim(), + "status": &self.status.0.trim(), + "restarts": &self.restarts.trim(), + }); + trimmed_json.serialize(serializer) + } + } + + if runner.is_empty() { + println!("{} Process table empty", *helpers::SUCCESS); + } else { + for (id, item) in runner.items() { + let mut cpu_percent: String = string!("0%"); + let mut memory_usage: String = string!("0b"); + + if internal { + let mut usage_internals: (Option, Option) = (None, None); + + if let Ok(mut process) = Process::new(item.pid as u32) { + usage_internals = (process.cpu_percent().ok(), process.memory_info().ok()); + } + + cpu_percent = match usage_internals.0 { + Some(percent) => format!("{:.0}%", percent), + None => string!("0%"), + }; + + memory_usage = match usage_internals.1 { + Some(usage) => helpers::format_memory(usage.rss()), + None => string!("0b"), + }; + } else { + let info = http::info(&runner.remote.as_ref().unwrap(), id); + + if let Ok(info) = info { + let stats = info.json::().unwrap().stats; + + cpu_percent = match stats.cpu_percent { + Some(percent) => format!("{:.2}%", percent), + None => string!("0%"), + }; + + memory_usage = match stats.memory_usage { + Some(usage) => helpers::format_memory(usage.rss), + None => string!("0b"), + }; + } + } + + let status = if item.running { + "online ".green().bold() + } else { + match item.crash.crashed { + true => "crashed ", + false => "stopped ", + } + .red() + .bold() + }; + + processes.push(ProcessItem { + status: status.into(), + cpu: format!("{cpu_percent} "), + mem: format!("{memory_usage} "), + id: id.to_string().cyan().bold().into(), + restarts: format!("{} ", item.restarts), + name: format!("{} ", item.name.clone()), + pid: ternary!(item.running, format!("{} ", item.pid), string!("n/a ")), + watch: ternary!(item.watch.enabled, format!("{} ", item.watch.path), string!("disabled ")), + uptime: ternary!(item.running, format!("{} ", helpers::format_duration(item.started)), string!("none ")), + }); + } + + let table = Table::new(&processes) + .with(Style::rounded().remove_verticals()) + .with(BorderColor::filled(Color::FG_BRIGHT_BLACK)) + .with(Colorization::exact([Color::FG_BRIGHT_CYAN], Rows::first())) + .with(Modify::new(Columns::single(1)).with(Width::truncate(35).suffix("... "))) + .to_string(); + + if let Ok(json) = serde_json::to_string(&processes) { + match format.as_str() { + "raw" => println!("{:?}", processes), + "json" => println!("{json}"), + "default" => println!("{table}"), + _ => {} + }; + }; + } + }; + + if let Some(servers) = config::servers().servers { + let mut failed: Vec<(String, String)> = vec![]; + + if let Some(server) = servers.get(server_name) { + match Runner::connect(server_name.clone(), server.get(), true) { + Some(mut remote) => render_list(&mut remote, false), + None => println!("{} Failed to fetch (name={server_name}, address={})", *helpers::FAIL, server.address), + } + } else { + if matches!(&**server_name, "internal" | "all" | "global" | "local") { + if *server_name == "all" || *server_name == "global" { + println!("{} Internal daemon", *helpers::SUCCESS); + } + render_list(&mut Runner::new(), true); + } else { + crashln!("{} Server '{server_name}' does not exist", *helpers::FAIL); + } + } + + if *server_name == "all" || *server_name == "global" { + for (name, server) in servers { + match Runner::connect(name.clone(), server.get(), true) { + Some(mut remote) => render_list(&mut remote, false), + None => failed.push((name, server.address)), + } + } + } + + if !failed.is_empty() { + println!("{} Failed servers:", *helpers::FAIL); + failed + .iter() + .for_each(|server| println!(" {} {} {}", "-".yellow(), format!("{}", server.0), format!("[{}]", server.1).white())); + } + } else { + render_list(&mut Runner::new(), true); + } + } } diff --git a/src/cli/mod.rs b/src/cli/mod.rs index fa6b59e03e0dfa99cc602b7cc35bc186eb745998..ca89bdbd34d51f55e2fd6b25e8d0ed6e3e1a8890 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -1,43 +1,14 @@ +mod args; +pub use args::*; + pub(crate) mod internal; pub(crate) mod server; -use colored::Colorize; use internal::Internal; use macros_rs::{crashln, string, ternary}; -use psutil::process::{MemoryInfo, Process}; -use serde::Serialize; -use serde_json::json; +use pmc::{helpers, process::Runner}; use std::env; -use pmc::{ - config, file, - helpers::{self, ColoredString}, - log, - process::{http, ItemSingle, Runner}, -}; - -use tabled::{ - settings::{ - object::{Columns, Rows}, - style::{BorderColor, Style}, - themes::Colorization, - Color, Modify, Rotate, Width, - }, - Table, Tabled, -}; - -#[derive(Clone, Debug)] -pub enum Args { - Id(usize), - Script(String), -} - -#[derive(Clone, Debug)] -pub enum Item { - Id(usize), - Name(String), -} - fn format(server_name: &String) -> (String, String) { let kind = ternary!(matches!(&**server_name, "internal" | "local"), "", "remote ").to_string(); return (kind, server_name.to_string()); @@ -59,13 +30,13 @@ pub fn start(name: &Option, args: &Args, watch: &Option, server_ match args { Args::Id(id) => Internal { id: *id, runner, server_name, kind }.restart(name, watch), - Args::Script(script) => match runner.find(&script) { + Args::Script(script) => match runner.find(&script, server_name) { Some(id) => Internal { id, runner, server_name, kind }.restart(name, watch), None => Internal { id: 0, runner, server_name, kind }.create(script, name, watch), }, } - list(&string!("default"), &list_name); + Internal::list(&string!("default"), &list_name); } pub fn stop(item: &Item, server_name: &String) { @@ -74,13 +45,13 @@ pub fn stop(item: &Item, server_name: &String) { match item { Item::Id(id) => Internal { id: *id, runner, server_name, kind }.stop(), - Item::Name(name) => match runner.find(&name) { + Item::Name(name) => match runner.find(&name, server_name) { Some(id) => Internal { id, runner, server_name, kind }.stop(), None => crashln!("{} Process ({name}) not found", *helpers::FAIL), }, } - list(&string!("default"), &list_name); + Internal::list(&string!("default"), &list_name); } pub fn remove(item: &Item, server_name: &String) { @@ -89,432 +60,48 @@ pub fn remove(item: &Item, server_name: &String) { match item { Item::Id(id) => Internal { id: *id, runner, server_name, kind }.remove(), - Item::Name(name) => match runner.find(&name) { + Item::Name(name) => match runner.find(&name, server_name) { Some(id) => Internal { id, runner, server_name, kind }.remove(), None => crashln!("{} Process ({name}) not found", *helpers::FAIL), }, } } -pub fn info(id: &usize, format: &String, server_name: &String) { - #[derive(Clone, Debug, Tabled)] - struct Info { - #[tabled(rename = "error log path ")] - log_error: String, - #[tabled(rename = "out log path")] - log_out: String, - #[tabled(rename = "cpu percent")] - cpu_percent: String, - #[tabled(rename = "memory usage")] - memory_usage: String, - #[tabled(rename = "path hash")] - hash: String, - #[tabled(rename = "watching")] - watch: String, - children: String, - #[tabled(rename = "exec cwd")] - path: String, - #[tabled(rename = "script command ")] - command: String, - #[tabled(rename = "script id")] - id: String, - restarts: u64, - uptime: String, - pid: String, - name: String, - status: ColoredString, - } - - impl Serialize for Info { - fn serialize(&self, serializer: S) -> Result { - let trimmed_json = json!({ - "id": &self.id.trim(), - "pid": &self.pid.trim(), - "name": &self.name.trim(), - "path": &self.path.trim(), - "restarts": &self.restarts, - "hash": &self.hash.trim(), - "watch": &self.watch.trim(), - "children": &self.children, - "uptime": &self.uptime.trim(), - "status": &self.status.0.trim(), - "log_out": &self.log_out.trim(), - "cpu": &self.cpu_percent.trim(), - "command": &self.command.trim(), - "mem": &self.memory_usage.trim(), - "log_error": &self.log_error.trim(), - }); - - trimmed_json.serialize(serializer) - } - } - - let render_info = |data: Vec| { - let table = Table::new(data.clone()) - .with(Rotate::Left) - .with(Style::rounded().remove_horizontals()) - .with(Colorization::exact([Color::FG_CYAN], Columns::first())) - .with(BorderColor::filled(Color::FG_BRIGHT_BLACK)) - .to_string(); - - if let Ok(json) = serde_json::to_string(&data[0]) { - match format.as_str() { - "raw" => println!("{:?}", data[0]), - "json" => println!("{json}"), - _ => { - println!("{}\n{table}\n", format!("Describing process with id ({id})").on_bright_white().black()); - println!(" {}", format!("Use `pmc logs {id} [--lines ]` to display logs").white()); - println!(" {}", format!("Use `pmc env {id}` to display environment variables").white()); - } - }; - }; - }; - - if matches!(&**server_name, "internal" | "local") { - if let Some(home) = home::home_dir() { - let config = config::read().runner; - let mut runner = Runner::new(); - let item = runner.process(*id); - - let mut memory_usage: Option = None; - let mut cpu_percent: Option = None; - - let path = file::make_relative(&item.path, &home).to_string_lossy().into_owned(); - let children = if item.children.is_empty() { "none".to_string() } else { format!("{:?}", item.children) }; - - if let Ok(mut process) = Process::new(item.pid as u32) { - memory_usage = process.memory_info().ok(); - cpu_percent = process.cpu_percent().ok(); - } - - let cpu_percent = match cpu_percent { - Some(percent) => format!("{:.2}%", percent), - None => string!("0%"), - }; - - let memory_usage = match memory_usage { - Some(usage) => helpers::format_memory(usage.rss()), - None => string!("0b"), - }; - - let status = if item.running { - "online ".green().bold() - } else { - match item.crash.crashed { - true => "crashed ", - false => "stopped ", - } - .red() - .bold() - }; - - let data = vec![Info { - children, - cpu_percent, - memory_usage, - id: string!(id), - restarts: item.restarts, - name: item.name.clone(), - log_out: item.logs().out, - path: format!("{} ", path), - log_error: item.logs().error, - status: ColoredString(status), - pid: ternary!(item.running, format!("{}", item.pid), string!("n/a")), - command: format!("{} {} '{}'", config.shell, config.args.join(" "), item.script), - hash: ternary!(item.watch.enabled, format!("{} ", item.watch.hash), string!("none ")), - watch: ternary!(item.watch.enabled, format!("{path}/{} ", item.watch.path), string!("disabled ")), - uptime: ternary!(item.running, format!("{}", helpers::format_duration(item.started)), string!("none")), - }]; - - render_info(data) - } else { - crashln!("{} Impossible to get your home directory", *helpers::FAIL); - } - } else { - let data: (pmc::process::Process, Runner); - let Some(servers) = config::servers().servers else { - crashln!("{} Failed to read servers", *helpers::FAIL) - }; - - if let Some(server) = servers.get(server_name) { - data = match Runner::connect(server_name.clone(), server.get(), false) { - Some(mut remote) => (remote.process(*id).clone(), remote), - None => crashln!("{} Failed to connect (name={server_name}, address={})", *helpers::FAIL, server.address), - }; - } else { - crashln!("{} Server '{server_name}' does not exist", *helpers::FAIL) - }; - - let (item, remote) = data; - let remote = remote.remote.unwrap(); - let info = http::info(&remote, *id); - let path = item.path.to_string_lossy().into_owned(); - - let status = if item.running { - "online ".green().bold() - } else { - match item.crash.crashed { - true => "crashed ", - false => "stopped ", - } - .red() - .bold() - }; - - if let Ok(info) = info { - let stats = info.json::().unwrap().stats; - let children = if item.children.is_empty() { "none".to_string() } else { format!("{:?}", item.children) }; - - let cpu_percent = match stats.cpu_percent { - Some(percent) => format!("{percent:.2}%"), - None => string!("0%"), - }; - - let memory_usage = match stats.memory_usage { - Some(usage) => helpers::format_memory(usage.rss), - None => string!("0b"), - }; - - let data = vec![Info { - children, - cpu_percent, - memory_usage, - id: string!(id), - path: path.clone(), - status: status.into(), - restarts: item.restarts, - name: item.name.clone(), - pid: ternary!(item.running, format!("{pid}", pid = item.pid), string!("n/a")), - log_out: format!("{}/{}-out.log", remote.config.log_path, item.name), - log_error: format!("{}/{}-error.log", remote.config.log_path, item.name), - hash: ternary!(item.watch.enabled, format!("{} ", item.watch.hash), string!("none ")), - command: format!("{} {} '{}'", remote.config.shell, remote.config.args.join(" "), item.script), - watch: ternary!(item.watch.enabled, format!("{path}/{} ", item.watch.path), string!("disabled ")), - uptime: ternary!(item.running, format!("{}", helpers::format_duration(item.started)), string!("none")), - }]; - - render_info(data) - } - } -} - -pub fn logs(id: &usize, lines: &usize, server_name: &String) { - let mut runner: Runner = Runner::new(); - - if !matches!(&**server_name, "internal" | "local") { - let Some(servers) = config::servers().servers else { - crashln!("{} Failed to read servers", *helpers::FAIL) - }; - - if let Some(server) = servers.get(server_name) { - runner = match Runner::connect(server_name.clone(), server.get(), false) { - Some(remote) => remote, - None => crashln!("{} Failed to connect (name={server_name}, address={})", *helpers::FAIL, server.address), - }; - } else { - crashln!("{} Server '{server_name}' does not exist", *helpers::FAIL) - }; - - let item = runner.info(*id).unwrap_or_else(|| crashln!("{} Process ({id}) not found", *helpers::FAIL)); - println!("{}", format!("Showing last {lines} lines for process [{id}] (change the value with --lines option)").yellow()); - - for kind in vec!["error", "out"] { - let logs = http::logs(&runner.remote.as_ref().unwrap(), *id, kind); - - if let Ok(log) = logs { - if log.lines.is_empty() { - println!("{} No logs found for {}/{kind}", *helpers::FAIL, item.name); - continue; - } - - file::logs_internal(log.lines, *lines, log.path, *id, kind, &item.name) - } - } - } else { - let item = runner.info(*id).unwrap_or_else(|| crashln!("{} Process ({id}) not found", *helpers::FAIL)); - println!("{}", format!("Showing last {lines} lines for process [{id}] (change the value with --lines option)").yellow()); +pub fn info(item: &Item, format: &String, server_name: &String) { + let runner: Runner = Runner::new(); + let (kind, _) = self::format(server_name); - file::logs(item, *lines, "error"); - file::logs(item, *lines, "out"); + match item { + Item::Id(id) => Internal { id: *id, runner, server_name, kind }.info(format), + Item::Name(name) => match runner.find(&name, server_name) { + Some(id) => Internal { id, runner, server_name, kind }.info(format), + None => crashln!("{} Process ({name}) not found", *helpers::FAIL), + }, } } -pub fn env(id: &usize, server_name: &String) { - let mut runner: Runner = Runner::new(); - - if !matches!(&**server_name, "internal" | "local") { - let Some(servers) = config::servers().servers else { - crashln!("{} Failed to read servers", *helpers::FAIL) - }; +pub fn logs(item: &Item, lines: &usize, server_name: &String) { + let runner: Runner = Runner::new(); + let (kind, _) = format(server_name); - if let Some(server) = servers.get(server_name) { - runner = match Runner::connect(server_name.clone(), server.get(), false) { - Some(remote) => remote, - None => crashln!("{} Failed to connect (name={server_name}, address={})", *helpers::FAIL, server.address), - }; - } else { - crashln!("{} Server '{server_name}' does not exist", *helpers::FAIL) - }; + match item { + Item::Id(id) => Internal { id: *id, runner, server_name, kind }.logs(lines), + Item::Name(name) => match runner.find(&name, server_name) { + Some(id) => Internal { id, runner, server_name, kind }.logs(lines), + None => crashln!("{} Process ({name}) not found", *helpers::FAIL), + }, } - - let item = runner.process(*id); - item.env.iter().for_each(|(key, value)| println!("{}: {}", key, value.green())); } -pub fn list(format: &String, server_name: &String) { - let render_list = |runner: &mut Runner, internal: bool| { - let mut processes: Vec = Vec::new(); - - #[derive(Tabled, Debug)] - struct ProcessItem { - id: ColoredString, - name: String, - pid: String, - uptime: String, - #[tabled(rename = "↺")] - restarts: String, - status: ColoredString, - cpu: String, - mem: String, - #[tabled(rename = "watching")] - watch: String, - } - - impl serde::Serialize for ProcessItem { - fn serialize(&self, serializer: S) -> Result { - let trimmed_json = json!({ - "cpu": &self.cpu.trim(), - "mem": &self.mem.trim(), - "id": &self.id.0.trim(), - "pid": &self.pid.trim(), - "name": &self.name.trim(), - "watch": &self.watch.trim(), - "uptime": &self.uptime.trim(), - "status": &self.status.0.trim(), - "restarts": &self.restarts.trim(), - }); - trimmed_json.serialize(serializer) - } - } - - if runner.is_empty() { - println!("{} Process table empty", *helpers::SUCCESS); - } else { - for (id, item) in runner.items() { - let mut cpu_percent: String = string!("0%"); - let mut memory_usage: String = string!("0b"); - - if internal { - let mut usage_internals: (Option, Option) = (None, None); - - if let Ok(mut process) = Process::new(item.pid as u32) { - usage_internals = (process.cpu_percent().ok(), process.memory_info().ok()); - } - - cpu_percent = match usage_internals.0 { - Some(percent) => format!("{:.0}%", percent), - None => string!("0%"), - }; - - memory_usage = match usage_internals.1 { - Some(usage) => helpers::format_memory(usage.rss()), - None => string!("0b"), - }; - } else { - let info = http::info(&runner.remote.as_ref().unwrap(), id); - - if let Ok(info) = info { - let stats = info.json::().unwrap().stats; - - cpu_percent = match stats.cpu_percent { - Some(percent) => format!("{:.2}%", percent), - None => string!("0%"), - }; - - memory_usage = match stats.memory_usage { - Some(usage) => helpers::format_memory(usage.rss), - None => string!("0b"), - }; - } - } - - let status = if item.running { - "online ".green().bold() - } else { - match item.crash.crashed { - true => "crashed ", - false => "stopped ", - } - .red() - .bold() - }; - - processes.push(ProcessItem { - status: status.into(), - cpu: format!("{cpu_percent} "), - mem: format!("{memory_usage} "), - id: id.to_string().cyan().bold().into(), - restarts: format!("{} ", item.restarts), - name: format!("{} ", item.name.clone()), - pid: ternary!(item.running, format!("{} ", item.pid), string!("n/a ")), - watch: ternary!(item.watch.enabled, format!("{} ", item.watch.path), string!("disabled ")), - uptime: ternary!(item.running, format!("{} ", helpers::format_duration(item.started)), string!("none ")), - }); - } - - let table = Table::new(&processes) - .with(Style::rounded().remove_verticals()) - .with(BorderColor::filled(Color::FG_BRIGHT_BLACK)) - .with(Colorization::exact([Color::FG_BRIGHT_CYAN], Rows::first())) - .with(Modify::new(Columns::single(1)).with(Width::truncate(35).suffix("... "))) - .to_string(); - - if let Ok(json) = serde_json::to_string(&processes) { - match format.as_str() { - "raw" => println!("{:?}", processes), - "json" => println!("{json}"), - "default" => println!("{table}"), - _ => {} - }; - }; - } - }; - - if let Some(servers) = config::servers().servers { - let mut failed: Vec<(String, String)> = vec![]; - - if let Some(server) = servers.get(server_name) { - match Runner::connect(server_name.clone(), server.get(), true) { - Some(mut remote) => render_list(&mut remote, false), - None => println!("{} Failed to fetch (name={server_name}, address={})", *helpers::FAIL, server.address), - } - } else { - if matches!(&**server_name, "internal" | "all" | "global" | "local") { - if *server_name == "all" || *server_name == "global" { - println!("{} Internal daemon", *helpers::SUCCESS); - } - render_list(&mut Runner::new(), true); - } else { - crashln!("{} Server '{server_name}' does not exist", *helpers::FAIL); - } - } - - if *server_name == "all" || *server_name == "global" { - for (name, server) in servers { - match Runner::connect(name.clone(), server.get(), true) { - Some(mut remote) => render_list(&mut remote, false), - None => failed.push((name, server.address)), - } - } - } +pub fn env(item: &Item, server_name: &String) { + let runner: Runner = Runner::new(); + let (kind, _) = format(server_name); - if !failed.is_empty() { - println!("{} Failed servers:", *helpers::FAIL); - failed - .iter() - .for_each(|server| println!(" {} {} {}", "-".yellow(), format!("{}", server.0), format!("[{}]", server.1).white())); - } - } else { - render_list(&mut Runner::new(), true); + match item { + Item::Id(id) => Internal { id: *id, runner, server_name, kind }.env(), + Item::Name(name) => match runner.find(&name, server_name) { + Some(id) => Internal { id, runner, server_name, kind }.env(), + None => crashln!("{} Process ({name}) not found", *helpers::FAIL), + }, } } diff --git a/src/cli/server.rs b/src/cli/server.rs index 53403da7355e514a3b660aabce459f1c5ce792f7..5d4ea587df639b3c3961b2fee59c3018a433f0a6 100644 --- a/src/cli/server.rs +++ b/src/cli/server.rs @@ -60,7 +60,7 @@ pub fn list(format: &String, log_level: Option) { .collect(); match Select::new("Select a server:", options).prompt() { - Ok(server) => super::list(format, &server.name), + Ok(server) => super::internal::Internal::list(format, &server.name), Err(_) => crashln!("{}", "Canceled...".white()), } } diff --git a/src/daemon/fork.rs b/src/daemon/fork.rs index 6f8941b3e662822d956da90778a94d20950256ce..b7589c9eb3192f662c7193ba13d569dace6365c2 100644 --- a/src/daemon/fork.rs +++ b/src/daemon/fork.rs @@ -1,6 +1,7 @@ use global_placeholders::global; use std::{ffi::CString, process::exit}; +#[allow(dead_code)] pub enum Fork { Parent(libc::pid_t), Child, diff --git a/src/main.rs b/src/main.rs index b48f573b1275ffd7b84b4379ed2bb0d5540ceb2d..c9a5f9bbfd9ba9c75e1cab04c8a60b707cbb86b8 100644 --- a/src/main.rs +++ b/src/main.rs @@ -9,28 +9,10 @@ use macros_rs::{str, string, then}; use update_informer::{registry, Check}; use crate::{ - cli::{Args, Item}, + cli::{internal::Internal, Args, Item}, globals::defaults, }; -// migrate to helpers -fn validate_id_script(s: &str) -> Result { - if let Ok(id) = s.parse::() { - Ok(Args::Id(id)) - } else { - Ok(Args::Script(s.to_owned())) - } -} - -// migrate to helpers -fn validate_item(s: &str) -> Result { - if let Ok(id) = s.parse::() { - Ok(Item::Id(id)) - } else { - Ok(Item::Name(s.to_owned())) - } -} - #[derive(Copy, Clone, Debug, Default)] struct NoneLevel; impl LogLevel for NoneLevel { @@ -108,7 +90,7 @@ enum Commands { /// Process name #[arg(long)] name: Option, - #[clap(value_parser = validate_id_script)] + #[clap(value_parser = cli::validate::)] args: Args, /// Watch to reload path #[arg(long)] @@ -121,7 +103,7 @@ enum Commands { /// Stop/Kill a process #[command(visible_alias = "kill")] Stop { - #[clap(value_parser = validate_item)] + #[clap(value_parser = cli::validate::)] item: Item, /// Server #[arg(short, long)] @@ -131,7 +113,7 @@ enum Commands { /// Stop then remove a process #[command(visible_alias = "rm")] Remove { - #[clap(value_parser = validate_item)] + #[clap(value_parser = cli::validate::)] item: Item, /// Server #[arg(short, long)] @@ -141,7 +123,8 @@ enum Commands { /// Get env of a process #[command(visible_alias = "cmdline")] Env { - id: usize, + #[clap(value_parser = cli::validate::)] + item: Item, /// Server #[arg(short, long)] server: Option, @@ -150,7 +133,8 @@ enum Commands { /// Get information of a process #[command(visible_alias = "info")] Details { - id: usize, + #[clap(value_parser = cli::validate::)] + item: Item, /// Format output #[arg(long, default_value_t = string!("default"))] format: String, @@ -172,7 +156,8 @@ enum Commands { /// Get logs from a process Logs { - id: usize, + #[clap(value_parser = cli::validate::)] + item: Item, #[arg(long, default_value_t = 15, help = "")] lines: usize, /// Server @@ -212,10 +197,10 @@ fn main() { Commands::Start { name, args, watch, server } => cli::start(name, args, watch, &defaults(server)), Commands::Stop { item, server } => cli::stop(item, &defaults(server)), Commands::Remove { item, server } => cli::remove(item, &defaults(server)), - Commands::Env { id, server } => cli::env(id, &defaults(server)), - Commands::Details { id, format, server } => cli::info(id, format, &defaults(server)), - Commands::List { format, server } => cli::list(format, &defaults(server)), - Commands::Logs { id, lines, server } => cli::logs(id, lines, &defaults(server)), + Commands::Env { item, server } => cli::env(item, &defaults(server)), + Commands::Details { item, format, server } => cli::info(item, format, &defaults(server)), + Commands::List { format, server } => Internal::list(format, &defaults(server)), + Commands::Logs { item, lines, server } => cli::logs(item, lines, &defaults(server)), Commands::Daemon { command } => match command { Daemon::Stop => daemon::stop(), diff --git a/src/process/mod.rs b/src/process/mod.rs index 7743222aa5bf1c1b59d85e2d6795abfffe8c4d3b..6ea086ab309218d4c10241f0f2155243aa01c85b 100644 --- a/src/process/mod.rs +++ b/src/process/mod.rs @@ -354,8 +354,6 @@ impl Runner { pub fn pid(&self, id: usize) -> i64 { self.list.get(&id).unwrap_or_else(|| crashln!("{} Process ({id}) not found", *helpers::FAIL)).pid } - pub fn find(&self, name: &str) -> Option { self.list.iter().find(|(_, p)| p.name == name).map(|(id, _)| *id) } - pub fn get(self, id: usize) -> ProcessWrapper { ProcessWrapper { id, @@ -421,6 +419,27 @@ impl Runner { return self; } + pub fn find(&self, name: &str, server_name: &String) -> Option { + let mut runner = self.clone(); + + if !matches!(&**server_name, "internal" | "local") { + let Some(servers) = config::servers().servers else { + crashln!("{} Failed to read servers", *helpers::FAIL) + }; + + if let Some(server) = servers.get(server_name) { + runner = match Runner::connect(server_name.clone(), server.get(), false) { + Some(remote) => remote, + None => crashln!("{} Failed to connect (name={server_name}, address={})", *helpers::FAIL, server.address), + }; + } else { + crashln!("{} Server '{server_name}' does not exist", *helpers::FAIL) + }; + } + + runner.list.iter().find(|(_, p)| p.name == name).map(|(id, _)| *id) + } + pub fn fetch(&self) -> Vec { let mut processes: Vec = Vec::new();