No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/daemon/api/routes.rs b/src/daemon/api/routes.rs
	index a0635c9..1fb6ffd 100644
	--- a/src/daemon/api/routes.rs
	+++ b/src/daemon/api/routes.rs
	@@ -1,381 +1,381 @@
	use chrono::{DateTime, Utc};
	use global_placeholders::global;
	use macros_rs::{string, ternary, then};
	use pmc::{file, helpers, process::Runner};
	use prometheus::{Encoder, TextEncoder};
	use psutil::process::{MemoryInfo, Process};
	use serde::{Deserialize, Serialize};
	use serde_json::json;
	use std::convert::Infallible;
	use utoipa::ToSchema;

	use crate::daemon::{
	api::{HTTP_COUNTER, HTTP_REQ_HISTOGRAM},
	pid,
	};

	use warp::{
	hyper::body::Body,
	reject,
	reply::{self, json, Response},
	Rejection, Reply,
	};

	use std::{
	env,
	fs::{self, File},
	io::{self, BufRead, BufReader},
	};

	#[allow(dead_code)]
	#[derive(ToSchema)]
	#[schema(as = MemoryInfo)]
	pub(crate) struct DocMemoryInfo {
	rss: u64,
	vms: u64,
	#[cfg(target_os = "linux")]
	shared: u64,
	#[cfg(target_os = "linux")]
	text: u64,
	#[cfg(target_os = "linux")]
	data: u64,
	#[cfg(target_os = "macos")]
	page_faults: u64,
	#[cfg(target_os = "macos")]
	pageins: u64,
	}

	#[derive(Deserialize, ToSchema)]
	pub(crate) struct ActionBody {
	#[schema(example = "restart")]
	method: String,
	}

	#[derive(Serialize, ToSchema)]
	pub(crate) struct ActionResponse<'a> {
	#[schema(example = true)]
	done: bool,
	#[schema(example = "name")]
	action: &'a str,
	}

	#[derive(Serialize, ToSchema)]
	pub(crate) struct LogResponse {
	logs: Vec<String>,
	}

	#[derive(Serialize, ToSchema)]
	pub struct MetricsRoot<'a> {
	pub version: Version<'a>,
	pub daemon: Daemon,
	}

	#[derive(Serialize, ToSchema)]
	pub struct Version<'a> {
	+ #[schema(example = "v1.0.0")]
	pub pkg: String,
	pub hash: &'a str,
	+ #[schema(example = "2000-01-01")]
	pub build_date: &'a str,
	+ #[schema(example = "release")]
	pub target: &'a str,
	}

	#[derive(Serialize, ToSchema)]
	pub struct Daemon {
	- pub pid: String,
	+ pub pid: Option<i32>,
	+ #[schema(example = true)]
	pub running: bool,
	pub uptime: String,
	pub process_count: usize,
	+ #[schema(example = "default")]
	pub daemon_type: String,
	pub stats: Stats,
	}

	#[derive(Serialize, ToSchema)]
	pub struct Stats {
	pub memory_usage: String,
	pub cpu_percent: String,
	}

	#[inline]
	fn attempt(done: bool, method: &str) -> reply::Json {
	let data = json!(ActionResponse {
	done,
	action: ternary!(done, method, "DOES_NOT_EXIST")
	});

	json(&data)
	}

	#[inline]
	#[utoipa::path(get, tag = "Daemon", path = "/prometheus", responses((status = 200, description = "Get prometheus metrics", body = String)))]
	pub async fn prometheus_handler() -> Result<impl Reply, Infallible> {
	let encoder = TextEncoder::new();
	let mut buffer = Vec::<u8>::new();
	let metric_families = prometheus::gather();

	encoder.encode(&metric_families, &mut buffer).unwrap();
	Ok(format!("{}", String::from_utf8(buffer.clone()).unwrap()))
	}

	#[inline]
	#[utoipa::path(get, path = "/list", tag = "Process", responses((status = 200, description = "List processes successfully", body = [ProcessItem])))]
	pub async fn list_handler() -> Result<impl Reply, Infallible> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["list"]).start_timer();
	let data = Runner::new().json();

	HTTP_COUNTER.inc();
	timer.observe_duration();

	Ok(json(&data))
	}

	#[inline]
	#[utoipa::path(get, tag = "Process", path = "/process/{id}/logs/{kind}",
	params(
	("id" = usize, Path, description = "Process id to get logs for", example = 0),
	("kind" = String, Path, description = "Log output type", example = "out")
	),
	responses(
	(status = 200, description = "Process logs of {type} fetched", body = LogResponse),
	(status = NOT_FOUND, description = "Process was not found", body = ErrorMessage)
	)
	)]
	pub async fn log_handler(id: usize, kind: String) -> Result<impl Reply, Rejection> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["log"]).start_timer();

	HTTP_COUNTER.inc();
	match Runner::new().info(id) {
	Some(item) => {
	let log_file = match kind.as_str() {
	"out" \| "stdout" => global!("pmc.logs.out", item.name.as_str()),
	"error" \| "stderr" => global!("pmc.logs.error", item.name.as_str()),
	_ => global!("pmc.logs.out", item.name.as_str()),
	};

	match File::open(log_file) {
	Ok(data) => {
	let reader = BufReader::new(data);
	let logs: Vec<String> = reader.lines().collect::<io::Result<_>>().unwrap();

	timer.observe_duration();
	Ok(json(&json!(LogResponse { logs })))
	}
	Err(_) => Ok(json(&json!(LogResponse { logs: vec![] }))),
	}
	}
	None => {
	timer.observe_duration();
	Err(reject::not_found())
	}
	}
	}

	#[inline]
	#[utoipa::path(get, tag = "Process", path = "/process/{id}/logs/{kind}/raw",
	params(
	("id" = usize, Path, description = "Process id to get logs for", example = 0),
	("kind" = String, Path, description = "Log output type", example = "out")
	),
	responses(
	(status = 200, description = "Process logs of {type} fetched raw", body = String),
	(status = NOT_FOUND, description = "Process was not found", body = ErrorMessage)
	)
	)]
	pub async fn log_handler_raw(id: usize, kind: String) -> Result<impl Reply, Rejection> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["log"]).start_timer();

	HTTP_COUNTER.inc();
	match Runner::new().info(id) {
	Some(item) => {
	let log_file = match kind.as_str() {
	"out" \| "stdout" => global!("pmc.logs.out", item.name.as_str()),
	"error" \| "stderr" => global!("pmc.logs.error", item.name.as_str()),
	_ => global!("pmc.logs.out", item.name.as_str()),
	};

	let data = match fs::read_to_string(log_file) {
	Ok(data) => data,
	Err(err) => err.to_string(),
	};

	timer.observe_duration();
	Ok(Response::new(Body::from(data)))
	}
	None => {
	timer.observe_duration();
	Err(reject::not_found())
	}
	}
	}

	#[inline]
	#[utoipa::path(get, tag = "Process", path = "/process/{id}/info",
	params(("id" = usize, Path, description = "Process id to get information for", example = 0)),
	responses(
	(status = 200, description = "Current process info retrieved", body = ItemSingle),
	(status = NOT_FOUND, description = "Process was not found", body = ErrorMessage)
	)
	)]
	pub async fn info_handler(id: usize) -> Result<impl Reply, Rejection> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["info"]).start_timer();

	HTTP_COUNTER.inc();
	match Runner::new().info(id) {
	Some(item) => {
	timer.observe_duration();
	Ok(json(&item.clone().json()))
	}
	None => {
	timer.observe_duration();
	Err(reject::not_found())
	}
	}
	}

	#[inline]
	#[utoipa::path(post, tag = "Process", path = "/process/{id}/rename", request_body(content = String),
	params(("id" = usize, Path, description = "Process id to rename", example = 0)),
	responses(
	(status = 200, description = "Rename process successful", body = ActionResponse),
	(status = NOT_FOUND, description = "Process was not found", body = ErrorMessage)
	)
	)]
	pub async fn rename_handler(id: usize, body: String) -> Result<impl Reply, Rejection> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["rename"]).start_timer();
	let mut runner = Runner::new();

	HTTP_COUNTER.inc();
	if runner.exists(id) {
	let item = runner.get(id);
	item.rename(body.trim().replace("\n", ""));
	then!(item.running, item.restart());
	timer.observe_duration();
	Ok(attempt(true, "rename"))
	} else {
	timer.observe_duration();
	Err(reject::not_found())
	}
	}

	#[inline]
	#[utoipa::path(get, tag = "Process", path = "/process/{id}/env",
	params(("id" = usize, Path, description = "Process id to fetch env from", example = 0)),
	responses(
	(status = 200, description = "Current process env", body = HashMap<String, String>),
	(status = NOT_FOUND, description = "Process was not found", body = ErrorMessage)
	)
	)]
	pub async fn env_handler(id: usize) -> Result<impl Reply, Rejection> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["env"]).start_timer();

	HTTP_COUNTER.inc();
	match Runner::new().info(id) {
	Some(item) => {
	timer.observe_duration();
	Ok(json(&item.clone().env))
	}
	None => {
	timer.observe_duration();
	Err(reject::not_found())
	}
	}
	}

	#[inline]
	#[utoipa::path(post, tag = "Process", path = "/process/{id}/action", request_body = ActionBody,
	params(("id" = usize, Path, description = "Process id to run action on", example = 0)),
	responses(
	(status = 200, description = "Run action on process successful", body = ActionResponse),
	(status = NOT_FOUND, description = "Process/action was not found", body = ErrorMessage)
	)
	)]
	pub async fn action_handler(id: usize, body: ActionBody) -> Result<impl Reply, Rejection> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["action"]).start_timer();
	let mut runner = Runner::new();
	let method = body.method.as_str();

	HTTP_COUNTER.inc();
	match method {
	"start" \| "restart" => {
	runner.get(id).restart();
	timer.observe_duration();
	Ok(attempt(true, method))
	}
	"stop" \| "kill" => {
	runner.get(id).stop();
	timer.observe_duration();
	Ok(attempt(true, method))
	}
	"remove" \| "delete" => {
	runner.remove(id);
	timer.observe_duration();
	Ok(attempt(true, method))
	}
	_ => {
	timer.observe_duration();
	Err(reject::not_found())
	}
	}
	}

	#[inline]
	#[utoipa::path(get, tag = "Daemon", path = "/metrics", responses((status = 200, description = "Get daemon metrics", body = MetricsRoot)))]
	pub async fn metrics_handler() -> Result<impl Reply, Infallible> {
	let timer = HTTP_REQ_HISTOGRAM.with_label_values(&["metrics"]).start_timer();
	let mut pid: Option<i32> = None;
	let mut cpu_percent: Option<f32> = None;
	let mut uptime: Option<DateTime<Utc>> = None;
	let mut memory_usage: Option<MemoryInfo> = None;
	let mut runner: Runner = file::read_rmp(global!("pmc.dump"));

	HTTP_COUNTER.inc();
	if pid::exists() {
	if let Ok(process_id) = pid::read() {
	if let Ok(mut process) = Process::new(process_id as u32) {
	pid = Some(process_id);
	uptime = Some(pid::uptime().unwrap());
	memory_usage = process.memory_info().ok();
	cpu_percent = process.cpu_percent().ok();
	}
	}
	}

	let memory_usage =
	match memory_usage {
	Some(usage) => helpers::format_memory(usage.rss()),
	None => string!("0b"),
	};

	let cpu_percent = match cpu_percent {
	Some(percent) => format!("{:.2}%", percent),
	None => string!("0%"),
	};

	let uptime = match uptime {
	Some(uptime) => helpers::format_duration(uptime),
	None => string!("none"),
	};

	- let pid = match pid {
	- Some(pid) => string!(pid),
	- None => string!("n/a"),
	- };
	-
	let response = json!(MetricsRoot {
	version: Version {
	pkg: format!("v{}", env!("CARGO_PKG_VERSION")),
	- hash: env!("GIT_HASH"),
	+ hash: env!("GIT_HASH_FULL"),
	build_date: env!("BUILD_DATE"),
	target: env!("PROFILE"),
	},
	daemon: Daemon {
	pid: pid,
	running: pid::exists(),
	uptime: uptime,
	process_count: runner.count(),
	daemon_type: global!("pmc.daemon.kind"),
	stats: Stats { memory_usage, cpu_percent }
	}
	});

	timer.observe_duration();
	Ok(json(&response))
	}
	diff --git a/src/process/mod.rs b/src/process/mod.rs
	index f29264d..b7120f8 100644
	--- a/src/process/mod.rs
	+++ b/src/process/mod.rs
	@@ -1,384 +1,386 @@
	use crate::{
	config, file, helpers,
	service::{run, stop, ProcessMetadata},
	};

	use chrono::serde::ts_milliseconds;
	use chrono::{DateTime, Utc};
	use global_placeholders::global;
	use macros_rs::{crashln, string, ternary, then};
	use psutil::process::{self, MemoryInfo};
	use serde::{Deserialize, Serialize};
	use serde_json::{json, Value};
	use std::collections::{BTreeMap, HashMap};
	use std::{env, path::PathBuf};
	use utoipa::ToSchema;

	#[derive(Serialize, ToSchema)]
	pub struct ItemSingle {
	info: Info,
	stats: Stats,
	watch: Watch,
	log: Log,
	raw: Raw,
	}

	#[derive(Serialize, ToSchema)]
	pub struct Info {
	id: usize,
	pid: i64,
	name: String,
	status: String,
	#[schema(value_type = String, example = "/path")]
	path: PathBuf,
	uptime: String,
	command: String,
	}

	#[derive(Serialize, ToSchema)]
	pub struct Stats {
	restarts: u64,
	start_time: i64,
	cpu_percent: Option<f32>,
	memory_usage: Option<MemoryInfo>,
	}

	#[derive(Serialize, ToSchema)]
	pub struct Log {
	out: String,
	error: String,
	}

	#[derive(Serialize, ToSchema)]
	pub struct Raw {
	running: bool,
	crashed: bool,
	crashes: u64,
	}

	#[derive(Serialize, ToSchema)]
	pub struct ProcessItem {
	pid: i64,
	id: usize,
	cpu: String,
	mem: String,
	name: String,
	restarts: u64,
	status: String,
	uptime: String,
	+ #[schema(example = "/path")]
	watch_path: String,
	#[schema(value_type = String, example = "2000-01-01T01:00:00.000Z")]
	start_time: DateTime<Utc>,
	}

	#[derive(Clone, Debug, Deserialize, Serialize)]
	pub struct Process {
	pub id: usize,
	pub pid: i64,
	pub name: String,
	pub path: PathBuf,
	pub script: String,
	pub env: HashMap<String, String>,
	#[serde(with = "ts_milliseconds")]
	pub started: DateTime<Utc>,
	pub restarts: u64,
	pub running: bool,
	pub crash: Crash,
	pub watch: Watch,
	}

	#[derive(Clone, Debug, Deserialize, Serialize)]
	pub struct Crash {
	pub crashed: bool,
	pub value: u64,
	}

	#[derive(Clone, Debug, Deserialize, Serialize, ToSchema)]
	pub struct Watch {
	pub enabled: bool,
	+ #[schema(example = "/path")]
	pub path: String,
	pub hash: String,
	}

	#[derive(Clone, Debug, Deserialize, Serialize)]
	pub struct Runner {
	pub id: id::Id,
	pub list: BTreeMap<usize, Process>,
	}

	pub enum Status {
	Offline,
	Running,
	}

	impl Status {
	pub fn to_bool(&self) -> bool {
	match self {
	Status::Offline => false,
	Status::Running => true,
	}
	}
	}

	impl Runner {
	pub fn new() -> Self { dump::read() }

	pub fn start(&mut self, name: &String, command: &String, watch: &Option<String>) -> &mut Self {
	let id = self.id.next();
	let config = config::read().runner;
	let crash = Crash { crashed: false, value: 0 };

	let watch = match watch {
	Some(watch) => Watch {
	enabled: true,
	path: string!(watch),
	hash: hash::create(file::cwd().join(watch)),
	},
	None => {
	Watch {
	enabled: false,
	path: string!(""),
	hash: string!(""),
	}
	}
	};

	let pid = run(ProcessMetadata {
	args: config.args,
	name: name.clone(),
	shell: config.shell,
	command: command.clone(),
	log_path: config.log_path,
	});

	self.list.insert(
	id,
	Process {
	id,
	pid,
	watch,
	crash,
	restarts: 0,
	running: true,
	path: file::cwd(),
	name: name.clone(),
	started: Utc::now(),
	script: command.clone(),
	env: env::vars().collect(),
	},
	);

	return self;
	}

	pub fn restart(&mut self, id: usize, dead: bool) -> &mut Self {
	let item = self.get(id);
	let Process { path, script, name, .. } = item.clone();

	if let Err(err) = std::env::set_current_dir(&item.path) {
	crashln!("{} Failed to set working directory {:?}\nError: {:#?}", *helpers::FAIL, path, err);
	};

	item.stop();

	let config = config::read().runner;

	item.crash.crashed = false;
	item.pid = run(ProcessMetadata {
	command: script,
	args: config.args,
	name: name.clone(),
	shell: config.shell,
	log_path: config.log_path,
	});

	item.running = true;
	item.started = Utc::now();
	then!(dead, item.restarts += 1);

	return self;
	}

	pub fn remove(&mut self, id: usize) {
	self.stop(id);
	self.list.remove(&id);
	dump::write(&self);
	}

	pub fn set_id(&mut self, id: id::Id) {
	self.id = id;
	self.id.next();
	dump::write(&self);
	}

	pub fn set_status(&mut self, id: usize, status: Status) {
	self.get(id).running = status.to_bool();
	dump::write(&self);
	}

	pub fn save(&self) { dump::write(&self); }
	pub fn count(&mut self) -> usize { self.list().count() }
	pub fn is_empty(&self) -> bool { self.list.is_empty() }
	pub fn items(&mut self) -> &mut BTreeMap<usize, Process> { &mut self.list }
	pub fn exists(&mut self, id: usize) -> bool { self.list.contains_key(&id) }
	pub fn info(&mut self, id: usize) -> Option<&Process> { self.list.get(&id) }
	pub fn list<'a>(&'a mut self) -> impl Iterator<Item = (&'a usize, &'a mut Process)> { self.list.iter_mut().map(\|(k, v)\| (k, v)) }
	pub fn get(&mut self, id: usize) -> &mut Process { self.list.get_mut(&id).unwrap_or_else(\|\| crashln!("{} Process ({id}) not found", *helpers::FAIL)) }

	pub fn set_crashed(&mut self, id: usize) -> &mut Self {
	self.get(id).crash.crashed = true;
	return self;
	}

	pub fn new_crash(&mut self, id: usize) -> &mut Self {
	self.get(id).crash.value += 1;
	return self;
	}

	pub fn stop(&mut self, id: usize) -> &mut Self {
	let item = self.get(id);
	stop(item.pid);

	item.running = false;
	item.crash.crashed = false;
	item.crash.value = 0;

	return self;
	}

	pub fn rename(&mut self, id: usize, name: String) -> &mut Self {
	self.get(id).name = name;
	return self;
	}

	pub fn watch(&mut self, id: usize, path: &str, enabled: bool) -> &mut Self {
	let item = self.get(id);
	item.watch = Watch {
	enabled,
	path: string!(path),
	hash: ternary!(enabled, hash::create(item.path.join(path)), string!("")),
	};

	return self;
	}

	pub fn json(&mut self) -> Value {
	let mut processes: Vec<ProcessItem> = Vec::new();

	for (id, item) in self.items() {
	let mut memory_usage: Option<MemoryInfo> = None;
	let mut cpu_percent: Option<f32> = None;

	if let Ok(mut process) = 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.00%"),
	};

	let memory_usage = match memory_usage {
	Some(usage) => helpers::format_memory(usage.rss()),
	None => string!("0b"),
	};

	let status =
	if item.running {
	string!("online")
	} else {
	match item.crash.crashed {
	true => string!("crashed"),
	false => string!("stopped"),
	}
	};

	processes.push(ProcessItem {
	status,
	id: *id,
	pid: item.pid,
	cpu: cpu_percent,
	mem: memory_usage,
	restarts: item.restarts,
	name: item.name.clone(),
	start_time: item.started,
	watch_path: item.watch.path.clone(),
	uptime: helpers::format_duration(item.started),
	});
	}

	json!(processes)
	}
	}

	impl Process {
	pub fn stop(&mut self) { Runner::new().stop(self.id).save(); }
	pub fn watch(&mut self, path: &str) { Runner::new().watch(self.id, path, true).save(); }
	pub fn disable_watch(&mut self) { Runner::new().watch(self.id, "", false).save(); }
	pub fn rename(&mut self, name: String) { Runner::new().rename(self.id, name).save(); }
	pub fn restart(&mut self) { Runner::new().restart(self.id, false).save(); }

	pub fn crashed(&mut self) -> &mut Process {
	Runner::new().new_crash(self.id).save();
	Runner::new().restart(self.id, true).save();
	return self;
	}

	pub fn json(&mut self) -> Value {
	let config = config::read().runner;

	let mut memory_usage: Option<MemoryInfo> = None;
	let mut cpu_percent: Option<f32> = None;

	if let Ok(mut process) = process::Process::new(self.pid as u32) {
	memory_usage = process.memory_info().ok();
	cpu_percent = process.cpu_percent().ok();
	}

	let status = if self.running {
	string!("online")
	} else {
	match self.crash.crashed {
	true => string!("crashed"),
	false => string!("stopped"),
	}
	};

	json!(ItemSingle {
	info: Info {
	status,
	id: self.id,
	pid: self.pid,
	name: self.name.clone(),
	path: self.path.clone(),
	uptime: helpers::format_duration(self.started),
	command: format!("{} {} '{}'", config.shell, config.args.join(" "), self.script.clone()),
	},
	stats: Stats {
	cpu_percent,
	memory_usage,
	restarts: self.restarts,
	start_time: self.started.timestamp_millis(),
	},
	watch: Watch {
	enabled: self.watch.enabled,
	hash: self.watch.hash.clone(),
	path: self.watch.path.clone(),
	},
	log: Log {
	out: global!("pmc.logs.out", self.name.as_str()),
	error: global!("pmc.logs.error", self.name.as_str()),
	},
	raw: Raw {
	running: self.running,
	crashed: self.crash.crashed,
	crashes: self.crash.value,
	}
	})
	}
	}

	pub mod dump;
	pub mod hash;
	pub mod id;

File Metadata

Mime Type: text/x-diff
Expires: Thu, Mar 19, 10:36 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 506498
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions