No OneTemporary
Actions

Size

27 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/daemon/api/mod.rs b/src/daemon/api/mod.rs
	index 0869010..1dff125 100644
	--- a/src/daemon/api/mod.rs
	+++ b/src/daemon/api/mod.rs
	@@ -1,219 +1,214 @@
	mod routes;

	+use crate::webui;
	use bytes::Bytes;
	use lazy_static::lazy_static;
	use macros_rs::{crashln, fmtstr};
	use pmc::{config, process};
	use prometheus::{opts, register_counter, register_gauge, register_histogram, register_histogram_vec};
	use prometheus::{Counter, Gauge, Histogram, HistogramVec};
	use serde::Serialize;
	use serde_json::json;
	use static_dir::static_dir;
	-use std::{convert::Infallible, error::Error, str::FromStr};
	-use tera::Tera;
	+use std::{convert::Infallible, str::FromStr};
	+
	use utoipa::{OpenApi, ToSchema};
	use utoipa_rapidoc::RapiDoc;

	use warp::{
	body, filters, get, header,
	http::{StatusCode, Uri},
	path, post, redirect, reject,
	reply::{self, html, json},
	serve, Filter, Rejection, Reply,
	};

	use routes::{action_handler, dashboard, env_handler, info_handler, list_handler, log_handler, log_handler_raw, login, metrics_handler, prometheus_handler, rename_handler, view_process};

	#[derive(Serialize, ToSchema)]
	struct ErrorMessage {
	#[schema(example = 404)]
	code: u16,
	#[schema(example = "NOT_FOUND")]
	message: String,
	}

	#[inline]
	async fn convert_to_string(bytes: Bytes) -> Result<String, Rejection> { String::from_utf8(bytes.to_vec()).map_err(\|_\| reject()) }

	#[inline]
	fn string_filter(limit: u64) -> impl Filter<Extract = (String,), Error = Rejection> + Clone { body::content_length_limit(limit).and(body::bytes()).and_then(convert_to_string) }

	lazy_static! {
	pub static ref HTTP_COUNTER: Counter = register_counter!(opts!("http_requests_total", "Number of HTTP requests made.")).unwrap();
	pub static ref DAEMON_START_TIME: Gauge = register_gauge!(opts!("process_start_time_seconds", "The uptime of the daemon.")).unwrap();
	pub static ref DAEMON_MEM_USAGE: Histogram = register_histogram!("daemon_memory_usage", "The memory usage graph of the daemon.").unwrap();
	pub static ref DAEMON_CPU_PERCENTAGE: Histogram = register_histogram!("daemon_cpu_percentage", "The cpu usage graph of the daemon.").unwrap();
	pub static ref HTTP_REQ_HISTOGRAM: HistogramVec = register_histogram_vec!("http_request_duration_seconds", "The HTTP request latencies in seconds.", &["route"]).unwrap();
	}

	pub async fn start(webui: bool) {
	const DOCS: &str = include_str!("docs/index.html");

	let config = config::read().daemon.web;
	let s_path = config::read().get_path();

	let docs_path = fmtstr!("{}/docs.json", s_path.trim_end_matches('/').to_string());
	let auth = header::exact("authorization", fmtstr!("token {}", config.secure.token));

	- let tmpl = match create_template_filter() {
	- Ok(template) => template,
	- Err(err) => crashln!("{err}"),
	- };
	+ let tmpl =
	+ match webui::create_template_filter() {
	+ Ok(template) => template,
	+ Err(err) => crashln!("{err}"),
	+ };

	#[derive(OpenApi)]
	#[openapi(
	paths(
	routes::action_handler,
	routes::env_handler,
	routes::info_handler,
	routes::list_handler,
	routes::log_handler,
	routes::log_handler_raw,
	routes::metrics_handler,
	routes::prometheus_handler,
	routes::rename_handler
	),
	components(schemas(
	ErrorMessage,
	process::Log,
	process::Raw,
	process::Info,
	process::Stats,
	process::Watch,
	process::ItemSingle,
	process::ProcessItem,
	routes::Stats,
	routes::Daemon,
	routes::Version,
	routes::ActionBody,
	routes::MetricsRoot,
	routes::LogResponse,
	routes::DocMemoryInfo,
	routes::ActionResponse,
	))
	)]
	struct ApiDoc;

	let app_metrics = path!("metrics").and(get()).and_then(metrics_handler);
	let app_prometheus = path!("prometheus").and(get()).and_then(prometheus_handler);
	let app_docs_json = path!("docs.json").and(get()).map(\|\| json(&ApiDoc::openapi()));
	let app_docs = path!("docs").and(get()).map(\|\| html(RapiDoc::new(docs_path).custom_html(DOCS).to_html()));

	let process_list = path!("list").and(get()).and_then(list_handler);
	let process_env = path!("process" / usize / "env").and(get()).and_then(env_handler);
	let process_info = path!("process" / usize / "info").and(get()).and_then(info_handler);
	let process_logs = path!("process" / usize / "logs" / String).and(get()).and_then(log_handler);
	let process_raw_logs = path!("process" / usize / "logs" / String / "raw").and(get()).and_then(log_handler_raw);
	let process_action = path!("process" / usize / "action").and(post()).and(body::json()).and_then(action_handler);
	let process_rename = path!("process" / usize / "rename").and(post()).and(string_filter(1024 * 16)).and_then(rename_handler);

	let web_login = warp::get().and(path!("login")).and(tmpl.clone()).and_then(login);
	let web_dashboard = warp::get().and(path::end()).and(tmpl.clone()).and_then(dashboard);
	let web_view_process = warp::get().and(path!("view" / usize)).and(tmpl.clone()).and_then(view_process);

	let log = warp::log::custom(\|info\| {
	log!(
	"[api] {} (method={}, status={}, ms={:?}, ver={:?})",
	info.path(),
	info.method(),
	info.status().as_u16(),
	info.elapsed(),
	info.version()
	)
	});

	let base = s_path
	.split('/')
	.enumerate()
	.filter(\|(_, p)\| !p.is_empty() \|\| *p == s_path)
	.fold(warp::any().boxed(), \|f, (_, path)\| f.and(warp::path(path.to_owned())).boxed());

	let routes = process_list
	.or(process_env)
	.or(process_info)
	.or(process_logs)
	.or(process_raw_logs)
	.or(process_action)
	.or(process_rename)
	.or(app_metrics)
	.or(app_prometheus);

	let use_routes_basic = \|\| async {
	- let web_routes = path::end().map(\|\| json(&json!({"healthy": true})).into_response()).boxed();
	+ let base_route = path::end().map(\|\| json(&json!({"healthy": true})).into_response());

	- let routes = match config.secure.enabled {
	- true => routes.clone().and(auth).or(root_redirect()).or(web_routes).or(app_docs_json).or(app_docs).boxed(),
	- false => routes.clone().or(root_redirect()).or(web_routes).or(app_docs_json).or(app_docs).boxed(),
	+ let internal = match config.secure.enabled {
	+ true => routes.clone().and(auth).or(root_redirect()).or(base_route).or(app_docs_json).or(app_docs).boxed(),
	+ false => routes.clone().or(root_redirect()).or(base_route).or(app_docs_json).or(app_docs).boxed(),
	};

	- serve(base.clone().and(routes).recover(handle_rejection).with(log)).run(config::read().get_address()).await
	+ serve(base.clone().and(internal).recover(handle_rejection).with(log)).run(config::read().get_address()).await
	};

	let use_routes_web = \|\| async {
	- let web_routes = web_login.or(web_dashboard).or(web_view_process).or(static_dir!("src/webui/assets")).boxed();
	+ let web_routes = web_login.or(web_dashboard).or(web_view_process).or(static_dir!("src/webui/assets"));

	- let routes = match config.secure.enabled {
	+ let internal = match config.secure.enabled {
	true => routes.clone().and(auth).or(root_redirect()).or(web_routes).or(app_docs_json).or(app_docs).boxed(),
	false => routes.clone().or(root_redirect()).or(web_routes).or(app_docs_json).or(app_docs).boxed(),
	};

	- serve(base.clone().and(routes).recover(handle_rejection).with(log)).run(config::read().get_address()).await
	+ serve(base.clone().and(internal).recover(handle_rejection).with(log)).run(config::read().get_address()).await
	};

	match webui {
	true => use_routes_web().await,
	false => use_routes_basic().await,
	}
	}

	async fn handle_rejection(err: Rejection) -> Result<impl Reply, Infallible> {
	let code;
	let message;

	HTTP_COUNTER.inc();
	if err.is_not_found() {
	code = StatusCode::NOT_FOUND;
	message = "NOT_FOUND";
	} else if let Some(_) = err.find::<reject::MissingHeader>() {
	code = StatusCode::UNAUTHORIZED;
	message = "UNAUTHORIZED";
	} else if let Some(_) = err.find::<reject::InvalidHeader>() {
	code = StatusCode::UNAUTHORIZED;
	message = "UNAUTHORIZED";
	} else if let Some(_) = err.find::<reject::MethodNotAllowed>() {
	code = StatusCode::METHOD_NOT_ALLOWED;
	message = "METHOD_NOT_ALLOWED";
	} else {
	log!("[api] unhandled rejection (err={:?})", err);
	code = StatusCode::INTERNAL_SERVER_ERROR;
	message = "INTERNAL_SERVER_ERROR";
	}

	let json = json(&ErrorMessage {
	code: code.as_u16(),
	message: message.into(),
	});

	Ok(reply::with_status(json, code))
	}

	-fn create_template_filter() -> Result<filters::BoxedFilter<((Tera, String),)>, Box<dyn Error>> {
	- let s_path = config::read().get_path();
	- let tera = Tera::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/webui/dist/*.html"))?;
	-
	- Ok(warp::any().map(move \|\| (tera.clone(), s_path.trim_end_matches('/').to_string())).boxed())
	-}
	-
	fn root_redirect() -> filters::BoxedFilter<(impl Reply,)> {
	warp::path::full()
	.and_then(move \|path: path::FullPath\| async move {
	let path = path.as_str();

	if path.ends_with("/") \|\| path.contains(".") {
	return Err(warp::reject());
	}

	Ok(redirect::redirect(Uri::from_str(&[path, "/"].concat()).unwrap()))
	})
	.boxed()
	}
	diff --git a/src/daemon/api/routes.rs b/src/daemon/api/routes.rs
	index 18ee552..0480eeb 100644
	--- a/src/daemon/api/routes.rs
	+++ b/src/daemon/api/routes.rs
	@@ -1,417 +1,417 @@
	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 tera::{Context, Tera};
	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: 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]
	fn render(name: &str, tmpl: &Tera, ctx: &Context) -> Result<String, Rejection> { tmpl.render(name, &ctx).or(Err(reject::not_found())) }

	#[inline]
	pub async fn login(store: (Tera, String)) -> Result<Box<dyn Reply>, Rejection> {
	let mut ctx = Context::new();
	let (tmpl, path) = store;

	ctx.insert("base_path", &path);
	- let payload = render("login.html", &tmpl, &ctx)?;
	+ let payload = render("login", &tmpl, &ctx)?;
	Ok(Box::new(reply::html(payload)))
	}

	#[inline]
	pub async fn dashboard(store: (Tera, String)) -> Result<Box<dyn Reply>, Rejection> {
	let mut ctx = Context::new();
	let (tmpl, path) = store;

	ctx.insert("base_path", &path);
	- let payload = render("index.html", &tmpl, &ctx)?;
	+ let payload = render("dashboard", &tmpl, &ctx)?;
	Ok(Box::new(reply::html(payload)))
	}

	#[inline]
	pub async fn view_process(id: usize, store: (Tera, String)) -> Result<Box<dyn Reply>, Rejection> {
	let mut ctx = Context::new();
	let (tmpl, path) = store;

	ctx.insert("base_path", &path);
	ctx.insert("process_id", &id);

	- let payload = render("view.html", &tmpl, &ctx)?;
	+ let payload = render("view", &tmpl, &ctx)?;
	Ok(Box::new(reply::html(payload)))
	}

	#[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 response = json!(MetricsRoot {
	version: Version {
	pkg: format!("v{}", env!("CARGO_PKG_VERSION")),
	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/main.rs b/src/main.rs
	index cd3a36e..b76881f 100644
	--- a/src/main.rs
	+++ b/src/main.rs
	@@ -1,141 +1,142 @@
	mod cli;
	mod daemon;
	mod globals;
	+mod webui;

	use crate::cli::Args;
	use clap::{Parser, Subcommand};
	use clap_verbosity_flag::Verbosity;
	use macros_rs::{str, string, then};

	fn validate_id_script(s: &str) -> Result<Args, String> {
	if let Ok(id) = s.parse::<usize>() {
	Ok(Args::Id(id))
	} else {
	Ok(Args::Script(s.to_owned()))
	}
	}

	#[derive(Parser)]
	#[command(version = str!(cli::get_version(false)))]
	struct Cli {
	#[command(subcommand)]
	command: Commands,
	#[clap(flatten)]
	verbose: Verbosity,
	}

	#[derive(Subcommand)]
	enum Daemon {
	/// Reset process index
	#[command(alias = "clean")]
	Reset,
	/// Stop daemon
	#[command(alias = "kill")]
	Stop,
	/// Restart daemon
	#[command(alias = "restart", alias = "start")]
	Restore {
	/// Daemon api
	#[arg(long)]
	api: bool,
	/// WebUI using api
	#[arg(long)]
	webui: bool,
	},
	/// Check daemon
	#[command(alias = "info", alias = "status")]
	Health {
	/// Format output
	#[arg(long, default_value_t = string!("default"))]
	format: String,
	},
	}

	// add pmc restore command
	#[derive(Subcommand)]
	enum Commands {
	/// Start/Restart a process
	#[command(alias = "restart")]
	Start {
	/// Process name
	#[arg(long)]
	name: Option<String>,
	#[clap(value_parser = validate_id_script)]
	args: Option<Args>,
	/// Watch to reload path
	#[arg(long)]
	watch: Option<String>,
	},

	/// Stop/Kill a process
	#[command(alias = "kill")]
	Stop { id: usize },

	/// Stop then remove a process
	#[command(alias = "rm")]
	Remove { id: usize },

	/// Get env of a process
	#[command(alias = "cmdline")]
	Env { id: usize },

	/// Get information of a process
	#[command(alias = "info")]
	Details {
	id: usize,
	/// Format output
	#[arg(long, default_value_t = string!("default"))]
	format: String,
	},

	/// List all processes
	#[command(alias = "ls")]
	List {
	/// Format output
	#[arg(long, default_value_t = string!("default"))]
	format: String,
	},

	/// Get logs from a process
	Logs {
	id: usize,
	#[arg(long, default_value_t = 15, help = "")]
	lines: usize,
	},

	/// Daemon management
	Daemon {
	#[command(subcommand)]
	command: Daemon,
	},
	}

	fn main() {
	let cli = Cli::parse();
	let mut env = env_logger::Builder::new();
	let level = cli.verbose.log_level_filter();

	globals::init();
	env.filter_level(level).init();

	match &cli.command {
	Commands::Start { name, args, watch } => cli::start(name, args, watch),
	Commands::Stop { id } => cli::stop(id),
	Commands::Remove { id } => cli::remove(id),
	Commands::Env { id } => cli::env(id),
	Commands::Details { id, format } => cli::info(id, format),
	Commands::List { format } => cli::list(format),
	Commands::Logs { id, lines } => cli::logs(id, lines),

	Commands::Daemon { command } => match command {
	Daemon::Stop => daemon::stop(),
	Daemon::Reset => daemon::reset(),
	Daemon::Health { format } => daemon::health(format),
	Daemon::Restore { api, webui } => daemon::restart(api, webui, level.as_str() != "ERROR"),
	},
	};

	if !matches!(&cli.command, Commands::Daemon { .. }) {
	then!(!daemon::pid::exists(), daemon::start(false));
	}
	}
	diff --git a/src/webui/mod.rs b/src/webui/mod.rs
	new file mode 100644
	index 0000000..a0d69cc
	--- /dev/null
	+++ b/src/webui/mod.rs
	@@ -0,0 +1,18 @@
	+use pmc::config;
	+use std::error::Error;
	+use tera::Tera;
	+use warp::{filters, Filter};
	+
	+pub fn create_template_filter() -> Result<filters::BoxedFilter<((Tera, String),)>, Box<dyn Error>> {
	+ let s_path = config::read().get_path();
	+ let mut tera = Tera::default();
	+
	+ tera.add_raw_templates(vec![
	+ ("view", include_str!("dist/view.html")),
	+ ("login", include_str!("dist/login.html")),
	+ ("dashboard", include_str!("dist/index.html")),
	+ ])
	+ .unwrap();
	+
	+ Ok(warp::any().map(move \|\| (tera.clone(), s_path.trim_end_matches('/').to_string())).boxed())
	+}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Feb 1, 10:33 PM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 494947
Default Alt Text: (27 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions