NotAShelf/pscand
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

treewide: set up rustfmt and taplo with custom rules

Browse source 
Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: I794f9152bb02e3dd91c9738369b94fc66a6a6964
This commit is contained in:
raf 2026-02-19 01:42:28 +03:00
commit ffae695240
Signed by: NotAShelf
GPG key ID: 29D95B64378DB4BF
27 changed files with 1851 additions and 1618 deletions
Download patch file Download diff file Expand all files Collapse all files

34
crates/pscand-cli/Cargo.toml
View file

@ -1,5 +1,5 @@
[package]
name = "pscand-cli"
name = "pscand-cli"
version.workspace = true
edition.workspace = true
license.workspace = true
@ -10,20 +10,20 @@ name = "pscand"
path = "src/main.rs"
[dependencies]
pscand-core.workspace = true
chrono.workspace = true
clap.workspace = true
dirs.workspace = true
env_logger.workspace = true
libloading.workspace = true
log.workspace = true
parking_lot.workspace = true
pscand-core.workspace = true
pscand-macros.workspace = true
tokio.workspace = true
serde.workspace = true
serde_json.workspace = true
toml.workspace = true
libloading.workspace = true
chrono.workspace = true
log.workspace = true
env_logger.workspace = true
thiserror.workspace = true
parking_lot.workspace = true
ringbuf.workspace = true
dirs.workspace = true
sysinfo.workspace = true
clap.workspace = true
sha2.workspace = true
ringbuf.workspace = true
serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
sysinfo.workspace = true
thiserror.workspace = true
tokio.workspace = true
toml.workspace = true

74
crates/pscand-cli/src/main.rs
View file

@ -1,19 +1,45 @@
#![allow(improper_ctypes_definitions)]
use std::{
fs,
io::Read,
path::{
Path,
PathBuf,
},
sync::{
atomic::{
AtomicBool,
Ordering,
},
Arc,
},
time::{
Duration,
Instant,
SystemTime,
UNIX_EPOCH,
},
};
use clap::Parser;
use libloading::Library;
use pscand_core::Config as CoreConfig;
use pscand_core::logging::{LogLevel, RingBufferLogger};
use pscand_core::scanner::Scanner;
use sha2::{Digest, Sha256};
use std::fs;
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use tokio::sync::RwLock;
use tokio::time::interval;
use pscand_core::{
logging::{
LogLevel,
RingBufferLogger,
},
scanner::Scanner,
Config as CoreConfig,
};
use sha2::{
Digest,
Sha256,
};
use tokio::{
sync::RwLock,
time::interval,
};
type ScannerCreator = pscand_core::ScannerCreatorFfi;
@ -79,22 +105,22 @@ fn verify_library(path: &Path) -> Result<(), String> {
}
struct LoadedScanner {
name: String,
scanner: Arc<RwLock<Box<dyn Scanner>>>,
name: String,
scanner: Arc<RwLock<Box<dyn Scanner>>>,
interval: Duration,
#[allow(dead_code)]
library: Library,
library: Library,
}
#[derive(Clone)]
struct DaemonState {
running: Arc<AtomicBool>,
running: Arc<AtomicBool>,
shutdown_requested: Arc<AtomicBool>,
start_time: Arc<RwLock<SystemTime>>,
last_collection: Arc<RwLock<SystemTime>>,
collection_count: Arc<RwLock<u64>>,
error_count: Arc<RwLock<u64>>,
heartbeat_path: PathBuf,
start_time: Arc<RwLock<SystemTime>>,
last_collection: Arc<RwLock<SystemTime>>,
collection_count: Arc<RwLock<u64>>,
error_count: Arc<RwLock<u64>>,
heartbeat_path: PathBuf,
}
impl DaemonState {
@ -334,7 +360,8 @@ async fn run_daemon(args: RunArgs) -> Result<(), Box<dyn std::error::Error>> {
" 1. Scanner plugins are installed in one of the configured directories"
);
log::error!(
" 2. Scanner directories are correctly set in config file or PSCAND_SCANNER_DIRS env var"
" 2. Scanner directories are correctly set in config file or \
PSCAND_SCANNER_DIRS env var"
);
log::error!(" 3. Scanners are not disabled in the configuration");
logger.log(
@ -664,7 +691,8 @@ async fn list_scanners() -> Result<(), Box<dyn std::error::Error>> {
"\nDynamic scanners are loaded from $PSCAND_SCANNER_DIRS (colon-separated)"
);
println!(
" Default fallback: ~/.local/share/pscand/scanners/ or ~/.config/pscand/scanners/"
" Default fallback: ~/.local/share/pscand/scanners/ or \
~/.config/pscand/scanners/"
);
Ok(())
}

22
crates/pscand-core/Cargo.toml
View file

@ -1,22 +1,22 @@
[package]
name = "pscand-core"
name = "pscand-core"
version.workspace = true
edition.workspace = true
license.workspace = true
authors.workspace = true
[dependencies]
tokio.workspace = true
serde.workspace = true
serde_json.workspace = true
toml.workspace = true
chrono.workspace = true
log.workspace = true
thiserror.workspace = true
chrono.workspace = true
dirs.workspace = true
log.workspace = true
parking_lot.workspace = true
dirs.workspace = true
sysinfo.workspace = true
ringbuf.workspace = true
ringbuf.workspace = true
serde.workspace = true
serde_json.workspace = true
sysinfo.workspace = true
thiserror.workspace = true
tokio.workspace = true
toml.workspace = true
[lib]
name = "pscand_core"

173
crates/pscand-core/src/config.rs
View file

@ -1,126 +1,135 @@
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::{
collections::HashMap,
path::{
Path,
PathBuf,
},
};
use serde::{
Deserialize,
Serialize,
};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum ConfigError {
#[error("IO error: {0}")]
Io(#[from] std::io::Error),
#[error("Parse error: {0}")]
Parse(#[from] toml::de::Error),
#[error("Scanner {0} not configured")]
ScannerNotConfigured(String),
#[error("Invalid scanner name: {0}")]
InvalidScannerName(String),
#[error("IO error: {0}")]
Io(#[from] std::io::Error),
#[error("Parse error: {0}")]
Parse(#[from] toml::de::Error),
#[error("Scanner {0} not configured")]
ScannerNotConfigured(String),
#[error("Invalid scanner name: {0}")]
InvalidScannerName(String),
}
pub type ConfigResult<T> = std::result::Result<T, ConfigError>;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScannerConfig {
pub enabled: bool,
pub interval_secs: Option<u64>,
pub extra: HashMap<String, toml::Value>,
pub enabled: bool,
pub interval_secs: Option<u64>,
pub extra: HashMap<String, toml::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
#[serde(default = "default_scanner_dirs")]
pub scanner_dirs: Vec<PathBuf>,
#[serde(default = "default_log_dir")]
pub log_dir: PathBuf,
#[serde(default = "default_retention_days")]
pub retention_days: u32,
#[serde(default = "default_ring_buffer_size")]
pub ring_buffer_size: usize,
#[serde(default)]
pub scanners: HashMap<String, ScannerConfig>,
#[serde(default)]
pub journal_enabled: bool,
#[serde(default)]
pub file_enabled: bool,
#[serde(default = "default_scanner_dirs")]
pub scanner_dirs: Vec<PathBuf>,
#[serde(default = "default_log_dir")]
pub log_dir: PathBuf,
#[serde(default = "default_retention_days")]
pub retention_days: u32,
#[serde(default = "default_ring_buffer_size")]
pub ring_buffer_size: usize,
#[serde(default)]
pub scanners: HashMap<String, ScannerConfig>,
#[serde(default)]
pub journal_enabled: bool,
#[serde(default)]
pub file_enabled: bool,
}
fn default_scanner_dirs() -> Vec<PathBuf> {
let mut dirs = Vec::new();
let mut dirs = Vec::new();
if let Ok(env_var) = std::env::var("PSCAND_SCANNER_DIRS") {
for path in env_var.split(':') {
let path = PathBuf::from(path);
if !path.as_os_str().is_empty() {
dirs.push(path);
}
}
if !dirs.is_empty() {
return dirs;
}
if let Ok(env_var) = std::env::var("PSCAND_SCANNER_DIRS") {
for path in env_var.split(':') {
let path = PathBuf::from(path);
if !path.as_os_str().is_empty() {
dirs.push(path);
}
}
if let Some(lib) = std::env::var_os("LIB_PSCAND") {
dirs.push(PathBuf::from(lib));
if !dirs.is_empty() {
return dirs;
}
}
if let Ok(lib_dir) = std::env::var("LIBDIR_PSCAND") {
dirs.push(PathBuf::from(lib_dir));
}
if let Some(lib) = std::env::var_os("LIB_PSCAND") {
dirs.push(PathBuf::from(lib));
}
if let Some(local) = dirs::data_local_dir() {
dirs.push(local.join("pscand/scanners"));
}
if let Ok(lib_dir) = std::env::var("LIBDIR_PSCAND") {
dirs.push(PathBuf::from(lib_dir));
}
if let Some(config) = dirs::config_dir() {
dirs.push(config.join("pscand/scanners"));
}
if let Some(local) = dirs::data_local_dir() {
dirs.push(local.join("pscand/scanners"));
}
if dirs.is_empty() {
dirs.push(PathBuf::from(".pscand/scanners"));
}
if let Some(config) = dirs::config_dir() {
dirs.push(config.join("pscand/scanners"));
}
dirs
if dirs.is_empty() {
dirs.push(PathBuf::from(".pscand/scanners"));
}
dirs
}
fn default_log_dir() -> PathBuf {
dirs::data_local_dir()
.map(|p| p.join("pscand/logs"))
.unwrap_or_else(|| PathBuf::from(".pscand/logs"))
dirs::data_local_dir()
.map(|p| p.join("pscand/logs"))
.unwrap_or_else(|| PathBuf::from(".pscand/logs"))
}
fn default_retention_days() -> u32 {
7
7
}
fn default_ring_buffer_size() -> usize {
60
60
}
impl Default for Config {
fn default() -> Self {
Self {
scanner_dirs: default_scanner_dirs(),
log_dir: default_log_dir(),
retention_days: default_retention_days(),
ring_buffer_size: default_ring_buffer_size(),
scanners: HashMap::new(),
journal_enabled: true,
file_enabled: true,
}
fn default() -> Self {
Self {
scanner_dirs: default_scanner_dirs(),
log_dir: default_log_dir(),
retention_days: default_retention_days(),
ring_buffer_size: default_ring_buffer_size(),
scanners: HashMap::new(),
journal_enabled: true,
file_enabled: true,
}
}
}
impl Config {
pub fn load(path: &Path) -> ConfigResult<Self> {
let content = std::fs::read_to_string(path)?;
let mut config: Config = toml::from_str(&content)?;
config.scanner_dirs.retain(|p| p.exists());
Ok(config)
}
pub fn load(path: &Path) -> ConfigResult<Self> {
let content = std::fs::read_to_string(path)?;
let mut config: Config = toml::from_str(&content)?;
config.scanner_dirs.retain(|p| p.exists());
Ok(config)
}
pub fn scanner_config(&self, name: &str) -> Option<&ScannerConfig> {
self.scanners.get(name)
}
pub fn scanner_config(&self, name: &str) -> Option<&ScannerConfig> {
self.scanners.get(name)
}
pub fn is_scanner_enabled(&self, name: &str) -> bool {
self.scanners.get(name).map(|c| c.enabled).unwrap_or(true)
}
pub fn is_scanner_enabled(&self, name: &str) -> bool {
self.scanners.get(name).map(|c| c.enabled).unwrap_or(true)
}
}

255
crates/pscand-core/src/helpers/power.rs
View file

@ -1,157 +1,160 @@
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use std::{
collections::HashMap,
fs,
path::PathBuf,
};
pub struct PowerHelper;
#[derive(Debug, Clone)]
pub struct BatteryInfo {
pub name: String,
pub status: String,
pub capacity: u32,
pub charge_percent: i32,
pub voltage: f64,
pub current_now: i64,
pub power_now: i64,
pub present: bool,
pub name: String,
pub status: String,
pub capacity: u32,
pub charge_percent: i32,
pub voltage: f64,
pub current_now: i64,
pub power_now: i64,
pub present: bool,
}
impl PowerHelper {
pub fn battery_info() -> std::io::Result<Option<BatteryInfo>> {
let battery_path = PathBuf::from("/sys/class/power_supply");
pub fn battery_info() -> std::io::Result<Option<BatteryInfo>> {
let battery_path = PathBuf::from("/sys/class/power_supply");
for entry in fs::read_dir(&battery_path)? {
let entry = entry?;
let path = entry.path();
let type_path = path.join("type");
for entry in fs::read_dir(&battery_path)? {
let entry = entry?;
let path = entry.path();
let type_path = path.join("type");
if type_path.exists() {
let battery_type = fs::read_to_string(&type_path)?.trim().to_string();
if battery_type == "Battery" {
let present_path = path.join("present");
let present = fs::read_to_string(&present_path)
.map(|s| s.trim() == "1")
.unwrap_or(false);
if type_path.exists() {
let battery_type = fs::read_to_string(&type_path)?.trim().to_string();
if battery_type == "Battery" {
let present_path = path.join("present");
let present = fs::read_to_string(&present_path)
.map(|s| s.trim() == "1")
.unwrap_or(false);
if !present {
continue;
}
if !present {
continue;
}
let name = fs::read_to_string(path.join("name"))
.unwrap_or_else(|_| "Unknown".to_string())
.trim()
.to_string();
let name = fs::read_to_string(path.join("name"))
.unwrap_or_else(|_| "Unknown".to_string())
.trim()
.to_string();
let status = fs::read_to_string(path.join("status"))
.unwrap_or_else(|_| "Unknown".to_string())
.trim()
.to_string();
let status = fs::read_to_string(path.join("status"))
.unwrap_or_else(|_| "Unknown".to_string())
.trim()
.to_string();
let capacity = fs::read_to_string(path.join("capacity"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.unwrap_or(0);
let capacity = fs::read_to_string(path.join("capacity"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.unwrap_or(0);
let charge_now = fs::read_to_string(path.join("charge_now"))
.or_else(|_| fs::read_to_string(path.join("energy_now")))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
let charge_now = fs::read_to_string(path.join("charge_now"))
.or_else(|_| fs::read_to_string(path.join("energy_now")))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
let charge_full = fs::read_to_string(path.join("charge_full"))
.or_else(|_| fs::read_to_string(path.join("energy_full")))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(1);
let charge_full = fs::read_to_string(path.join("charge_full"))
.or_else(|_| fs::read_to_string(path.join("energy_full")))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(1);
let charge_percent = if charge_full > 0 {
((charge_now as f64 / charge_full as f64) * 100.0) as i32
} else {
0
};
let charge_percent = if charge_full > 0 {
((charge_now as f64 / charge_full as f64) * 100.0) as i32
} else {
0
};
let voltage = fs::read_to_string(path.join("voltage_now"))
.ok()
.and_then(|s| s.trim().parse::<f64>().ok())
.unwrap_or(0.0)
/ 1_000_000.0;
let voltage = fs::read_to_string(path.join("voltage_now"))
.ok()
.and_then(|s| s.trim().parse::<f64>().ok())
.unwrap_or(0.0)
/ 1_000_000.0;
let current_now = fs::read_to_string(path.join("current_now"))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
let current_now = fs::read_to_string(path.join("current_now"))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
let power_now = fs::read_to_string(path.join("power_now"))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
let power_now = fs::read_to_string(path.join("power_now"))
.ok()
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
return Ok(Some(BatteryInfo {
name,
status,
capacity,
charge_percent,
voltage,
current_now,
power_now,
present,
}));
}
}
return Ok(Some(BatteryInfo {
name,
status,
capacity,
charge_percent,
voltage,
current_now,
power_now,
present,
}));
}
Ok(None)
}
}
pub fn power_supplies() -> std::io::Result<HashMap<String, HashMap<String, String>>> {
let mut supplies = HashMap::new();
let power_supply_path = PathBuf::from("/sys/class/power_supply");
Ok(None)
}
if !power_supply_path.exists() {
return Ok(supplies);
pub fn power_supplies(
) -> std::io::Result<HashMap<String, HashMap<String, String>>> {
let mut supplies = HashMap::new();
let power_supply_path = PathBuf::from("/sys/class/power_supply");
if !power_supply_path.exists() {
return Ok(supplies);
}
for entry in fs::read_dir(&power_supply_path)? {
let entry = entry?;
let path = entry.path();
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default();
let mut info = HashMap::new();
for attr in [
"type",
"status",
"capacity",
"voltage_now",
"power_now",
"online",
] {
let attr_path = path.join(attr);
if attr_path.exists() {
if let Ok(content) = fs::read_to_string(&attr_path) {
info.insert(attr.to_string(), content.trim().to_string());
}
}
}
for entry in fs::read_dir(&power_supply_path)? {
let entry = entry?;
let path = entry.path();
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default();
let mut info = HashMap::new();
for attr in [
"type",
"status",
"capacity",
"voltage_now",
"power_now",
"online",
] {
let attr_path = path.join(attr);
if attr_path.exists() {
if let Ok(content) = fs::read_to_string(&attr_path) {
info.insert(attr.to_string(), content.trim().to_string());
}
}
}
if !info.is_empty() {
supplies.insert(name, info);
}
}
Ok(supplies)
if !info.is_empty() {
supplies.insert(name, info);
}
}
pub fn suspend_state() -> std::io::Result<String> {
let state_path = PathBuf::from("/sys/power/state");
fs::read_to_string(state_path).map(|s| s.trim().to_string())
}
Ok(supplies)
}
pub fn mem_sleep_state() -> std::io::Result<String> {
let state_path = PathBuf::from("/sys/power/mem_sleep");
fs::read_to_string(state_path).map(|s| s.trim().to_string())
}
pub fn suspend_state() -> std::io::Result<String> {
let state_path = PathBuf::from("/sys/power/state");
fs::read_to_string(state_path).map(|s| s.trim().to_string())
}
pub fn mem_sleep_state() -> std::io::Result<String> {
let state_path = PathBuf::from("/sys/power/mem_sleep");
fs::read_to_string(state_path).map(|s| s.trim().to_string())
}
}

234
crates/pscand-core/src/helpers/process.rs
View file

@ -1,136 +1,144 @@
use std::collections::HashMap;
use std::fs;
use std::{
collections::HashMap,
fs,
};
pub struct ProcessHelper;
#[derive(Debug)]
pub struct ProcessInfo {
pub pid: u32,
pub name: String,
pub state: String,
pub ppid: u32,
pub memory_kb: u64,
pub cpu_percent: f32,
pub pid: u32,
pub name: String,
pub state: String,
pub ppid: u32,
pub memory_kb: u64,
pub cpu_percent: f32,
}
impl ProcessHelper {
pub fn list_processes() -> std::io::Result<Vec<ProcessInfo>> {
let mut processes = Vec::new();
let proc_path = fs::read_dir("/proc")?;
pub fn list_processes() -> std::io::Result<Vec<ProcessInfo>> {
let mut processes = Vec::new();
let proc_path = fs::read_dir("/proc")?;
for entry in proc_path.flatten() {
let path = entry.path();
if !path.is_dir() {
continue;
}
for entry in proc_path.flatten() {
let path = entry.path();
if !path.is_dir() {
continue;
}
let pid: u32 = match path.file_name() {
Some(name) => match name.to_str() {
Some(s) => s.parse().ok(),
None => None,
}
.ok_or(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"invalid pid",
))?,
None => continue,
};
let pid: u32 = match path.file_name() {
Some(name) => {
match name.to_str() {
Some(s) => s.parse().ok(),
None => None,
}
.ok_or(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"invalid pid",
))?
},
None => continue,
};
if let Ok(info) = Self::process_info(pid) {
processes.push(info);
}
}
Ok(processes)
if let Ok(info) = Self::process_info(pid) {
processes.push(info);
}
}
pub fn process_info(pid: u32) -> std::io::Result<ProcessInfo> {
let status_path = format!("/proc/{}/status", pid);
let content = fs::read_to_string(status_path)?;
Ok(processes)
}
let mut name = String::new();
let mut state = String::new();
let mut ppid: u32 = 0;
let mut memory_kb: u64 = 0;
pub fn process_info(pid: u32) -> std::io::Result<ProcessInfo> {
let status_path = format!("/proc/{}/status", pid);
let content = fs::read_to_string(status_path)?;
for line in content.lines() {
if line.starts_with("Name:") {
name = line
.split_whitespace()
.skip(1)
.collect::<Vec<_>>()
.join(" ");
} else if line.starts_with("State:") {
state = line.split_whitespace().nth(1).unwrap_or("").to_string();
} else if line.starts_with("PPid:") {
ppid = line
.split_whitespace()
.nth(1)
.and_then(|s| s.parse().ok())
.unwrap_or(0);
} else if line.starts_with("VmRSS:") {
memory_kb = line
.split_whitespace()
.nth(1)
.and_then(|s| s.parse().ok())
.unwrap_or(0);
}
}
let mut name = String::new();
let mut state = String::new();
let mut ppid: u32 = 0;
let mut memory_kb: u64 = 0;
Ok(ProcessInfo {
pid,
name,
state,
ppid,
memory_kb,
cpu_percent: 0.0,
})
for line in content.lines() {
if line.starts_with("Name:") {
name = line
.split_whitespace()
.skip(1)
.collect::<Vec<_>>()
.join(" ");
} else if line.starts_with("State:") {
state = line.split_whitespace().nth(1).unwrap_or("").to_string();
} else if line.starts_with("PPid:") {
ppid = line
.split_whitespace()
.nth(1)
.and_then(|s| s.parse().ok())
.unwrap_or(0);
} else if line.starts_with("VmRSS:") {
memory_kb = line
.split_whitespace()
.nth(1)
.and_then(|s| s.parse().ok())
.unwrap_or(0);
}
}
pub fn zombie_processes() -> std::io::Result<Vec<ProcessInfo>> {
Ok(Self::list_processes()?
.into_iter()
.filter(|p| p.state.starts_with('Z'))
.collect())
Ok(ProcessInfo {
pid,
name,
state,
ppid,
memory_kb,
cpu_percent: 0.0,
})
}
pub fn zombie_processes() -> std::io::Result<Vec<ProcessInfo>> {
Ok(
Self::list_processes()?
.into_iter()
.filter(|p| p.state.starts_with('Z'))
.collect(),
)
}
pub fn process_count() -> std::io::Result<HashMap<String, usize>> {
let mut counts = HashMap::new();
counts.insert("total".to_string(), 0);
counts.insert("running".to_string(), 0);
counts.insert("sleeping".to_string(), 0);
counts.insert("zombie".to_string(), 0);
for proc in Self::list_processes()? {
*counts.get_mut("total").unwrap() += 1;
let first_char = proc.state.chars().next().unwrap_or(' ');
match first_char {
'R' => *counts.get_mut("running").unwrap() += 1,
'S' | 'D' => *counts.get_mut("sleeping").unwrap() += 1,
'Z' => *counts.get_mut("zombie").unwrap() += 1,
_ => {},
}
}
pub fn process_count() -> std::io::Result<HashMap<String, usize>> {
let mut counts = HashMap::new();
counts.insert("total".to_string(), 0);
counts.insert("running".to_string(), 0);
counts.insert("sleeping".to_string(), 0);
counts.insert("zombie".to_string(), 0);
Ok(counts)
}
for proc in Self::list_processes()? {
*counts.get_mut("total").unwrap() += 1;
pub fn top_memory_processes(
count: usize,
) -> std::io::Result<Vec<ProcessInfo>> {
let mut processes = Self::list_processes()?;
processes.sort_by(|a, b| b.memory_kb.cmp(&a.memory_kb));
processes.truncate(count);
Ok(processes)
}
let first_char = proc.state.chars().next().unwrap_or(' ');
match first_char {
'R' => *counts.get_mut("running").unwrap() += 1,
'S' | 'D' => *counts.get_mut("sleeping").unwrap() += 1,
'Z' => *counts.get_mut("zombie").unwrap() += 1,
_ => {}
}
}
Ok(counts)
}
pub fn top_memory_processes(count: usize) -> std::io::Result<Vec<ProcessInfo>> {
let mut processes = Self::list_processes()?;
processes.sort_by(|a, b| b.memory_kb.cmp(&a.memory_kb));
processes.truncate(count);
Ok(processes)
}
pub fn top_cpu_processes(count: usize) -> std::io::Result<Vec<ProcessInfo>> {
let mut processes = Self::list_processes()?;
processes.sort_by(|a, b| {
b.cpu_percent
.partial_cmp(&a.cpu_percent)
.unwrap_or(std::cmp::Ordering::Equal)
});
processes.truncate(count);
Ok(processes)
}
pub fn top_cpu_processes(count: usize) -> std::io::Result<Vec<ProcessInfo>> {
let mut processes = Self::list_processes()?;
processes.sort_by(|a, b| {
b.cpu_percent
.partial_cmp(&a.cpu_percent)
.unwrap_or(std::cmp::Ordering::Equal)
});
processes.truncate(count);
Ok(processes)
}
}

208
crates/pscand-core/src/helpers/resource.rs
View file

@ -1,123 +1,129 @@
use std::collections::HashMap;
use std::fs;
use std::{
collections::HashMap,
fs,
};
pub struct ResourceHelper;
impl ResourceHelper {
pub fn cpu_usage() -> std::io::Result<HashMap<String, f64>> {
let content = fs::read_to_string("/proc/stat")?;
let mut result = HashMap::new();
pub fn cpu_usage() -> std::io::Result<HashMap<String, f64>> {
let content = fs::read_to_string("/proc/stat")?;
let mut result = HashMap::new();
for line in content.lines() {
if line.starts_with("cpu") {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 5 {
let cpu = parts[0];
let values: Vec<u64> = parts[1..]
.iter()
.take(7)
.filter_map(|s| s.parse().ok())
.collect();
for line in content.lines() {
if line.starts_with("cpu") {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 5 {
let cpu = parts[0];
let values: Vec<u64> = parts[1..]
.iter()
.take(7)
.filter_map(|s| s.parse().ok())
.collect();
if values.len() >= 4 {
let user = values[0] as f64;
let nice = values[1] as f64;
let system = values[2] as f64;
let idle = values[3] as f64;
let iowait = values.get(4).copied().unwrap_or(0) as f64;
let irq = values.get(5).copied().unwrap_or(0) as f64;
let softirq = values.get(6).copied().unwrap_or(0) as f64;
if values.len() >= 4 {
let user = values[0] as f64;
let nice = values[1] as f64;
let system = values[2] as f64;
let idle = values[3] as f64;
let iowait = values.get(4).copied().unwrap_or(0) as f64;
let irq = values.get(5).copied().unwrap_or(0) as f64;
let softirq = values.get(6).copied().unwrap_or(0) as f64;
let total = user + nice + system + idle + iowait + irq + softirq;
let active = user + nice + system + irq + softirq;
let total = user + nice + system + idle + iowait + irq + softirq;
let active = user + nice + system + irq + softirq;
if cpu == "cpu" {
result.insert("total_user".to_string(), user);
result.insert("total_nice".to_string(), nice);
result.insert("total_system".to_string(), system);
result.insert("total_idle".to_string(), idle);
result.insert("total_iowait".to_string(), iowait);
result.insert(
"total_usage_percent".to_string(),
(active / total) * 100.0,
);
} else {
let core = cpu.replace("cpu", "core_");
result.insert(format!("{}_user", core), user);
result.insert(
format!("{}_usage_percent", core),
(active / total) * 100.0,
);
}
}
}
if cpu == "cpu" {
result.insert("total_user".to_string(), user);
result.insert("total_nice".to_string(), nice);
result.insert("total_system".to_string(), system);
result.insert("total_idle".to_string(), idle);
result.insert("total_iowait".to_string(), iowait);
result.insert(
"total_usage_percent".to_string(),
(active / total) * 100.0,
);
} else {
let core = cpu.replace("cpu", "core_");
result.insert(format!("{}_user", core), user);
result.insert(
format!("{}_usage_percent", core),
(active / total) * 100.0,
);
}
}
}
Ok(result)
}
}
Ok(result)
}
pub fn memory_info() -> std::io::Result<HashMap<String, u64>> {
let content = fs::read_to_string("/proc/meminfo")?;
let mut result = HashMap::new();
pub fn memory_info() -> std::io::Result<HashMap<String, u64>> {
let content = fs::read_to_string("/proc/meminfo")?;
let mut result = HashMap::new();
for line in content.lines() {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 2 {
let key = parts[0].trim_end_matches(':');
if let Ok(value) = parts[1].parse::<u64>() {
result.insert(key.to_string(), value * 1024);
}
}
for line in content.lines() {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 2 {
let key = parts[0].trim_end_matches(':');
if let Ok(value) = parts[1].parse::<u64>() {
result.insert(key.to_string(), value * 1024);
}
Ok(result)
}
}
Ok(result)
}
pub fn disk_stats() -> std::io::Result<HashMap<String, HashMap<String, u64>>> {
let content = fs::read_to_string("/proc/diskstats")?;
let mut result = HashMap::new();
pub fn disk_stats() -> std::io::Result<HashMap<String, HashMap<String, u64>>>
{
let content = fs::read_to_string("/proc/diskstats")?;
let mut result = HashMap::new();
for line in content.lines() {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 14 {
let device = parts[2].to_string();
let mut stats = HashMap::new();
stats.insert("reads_completed".to_string(), parts[3].parse().unwrap_or(0));
stats.insert("reads_merged".to_string(), parts[4].parse().unwrap_or(0));
stats.insert("sectors_read".to_string(), parts[5].parse().unwrap_or(0));
stats.insert("reads_ms".to_string(), parts[6].parse().unwrap_or(0));
stats.insert(
"writes_completed".to_string(),
parts[7].parse().unwrap_or(0),
);
stats.insert("writes_merged".to_string(), parts[8].parse().unwrap_or(0));
stats.insert("sectors_written".to_string(), parts[9].parse().unwrap_or(0));
stats.insert("writes_ms".to_string(), parts[10].parse().unwrap_or(0));
result.insert(device, stats);
}
}
Ok(result)
for line in content.lines() {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 14 {
let device = parts[2].to_string();
let mut stats = HashMap::new();
stats
.insert("reads_completed".to_string(), parts[3].parse().unwrap_or(0));
stats.insert("reads_merged".to_string(), parts[4].parse().unwrap_or(0));
stats.insert("sectors_read".to_string(), parts[5].parse().unwrap_or(0));
stats.insert("reads_ms".to_string(), parts[6].parse().unwrap_or(0));
stats.insert(
"writes_completed".to_string(),
parts[7].parse().unwrap_or(0),
);
stats
.insert("writes_merged".to_string(), parts[8].parse().unwrap_or(0));
stats
.insert("sectors_written".to_string(), parts[9].parse().unwrap_or(0));
stats.insert("writes_ms".to_string(), parts[10].parse().unwrap_or(0));
result.insert(device, stats);
}
}
Ok(result)
}
pub fn net_dev() -> std::io::Result<HashMap<String, HashMap<String, u64>>> {
let content = fs::read_to_string("/proc/net/dev")?;
let mut result = HashMap::new();
pub fn net_dev() -> std::io::Result<HashMap<String, HashMap<String, u64>>> {
let content = fs::read_to_string("/proc/net/dev")?;
let mut result = HashMap::new();
for line in content.lines().skip(2) {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 17 {
let iface = parts[0].trim_end_matches(':');
let mut stats = HashMap::new();
stats.insert("rx_bytes".to_string(), parts[1].parse().unwrap_or(0));
stats.insert("rx_packets".to_string(), parts[2].parse().unwrap_or(0));
stats.insert("rx_errors".to_string(), parts[3].parse().unwrap_or(0));
stats.insert("rx_dropped".to_string(), parts[4].parse().unwrap_or(0));
stats.insert("tx_bytes".to_string(), parts[9].parse().unwrap_or(0));
stats.insert("tx_packets".to_string(), parts[10].parse().unwrap_or(0));
stats.insert("tx_errors".to_string(), parts[11].parse().unwrap_or(0));
stats.insert("tx_dropped".to_string(), parts[12].parse().unwrap_or(0));
result.insert(iface.to_string(), stats);
}
}
Ok(result)
for line in content.lines().skip(2) {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 17 {
let iface = parts[0].trim_end_matches(':');
let mut stats = HashMap::new();
stats.insert("rx_bytes".to_string(), parts[1].parse().unwrap_or(0));
stats.insert("rx_packets".to_string(), parts[2].parse().unwrap_or(0));
stats.insert("rx_errors".to_string(), parts[3].parse().unwrap_or(0));
stats.insert("rx_dropped".to_string(), parts[4].parse().unwrap_or(0));
stats.insert("tx_bytes".to_string(), parts[9].parse().unwrap_or(0));
stats.insert("tx_packets".to_string(), parts[10].parse().unwrap_or(0));
stats.insert("tx_errors".to_string(), parts[11].parse().unwrap_or(0));
stats.insert("tx_dropped".to_string(), parts[12].parse().unwrap_or(0));
result.insert(iface.to_string(), stats);
}
}
Ok(result)
}
}

183
crates/pscand-core/src/helpers/sensor.rs
View file

@ -1,102 +1,117 @@
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use std::{
collections::HashMap,
fs,
path::{
Path,
PathBuf,
},
};
pub struct SensorHelper;
impl SensorHelper {
pub fn discover_hwmon() -> std::io::Result<Vec<PathBuf>> {
let hwmon_path = PathBuf::from("/sys/class/hwmon");
let mut hwmons = Vec::new();
pub fn discover_hwmon() -> std::io::Result<Vec<PathBuf>> {
let hwmon_path = PathBuf::from("/sys/class/hwmon");
let mut hwmons = Vec::new();
if hwmon_path.exists() {
for entry in fs::read_dir(&hwmon_path)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
hwmons.push(path);
}
}
if hwmon_path.exists() {
for entry in fs::read_dir(&hwmon_path)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
hwmons.push(path);
}
Ok(hwmons)
}
}
Ok(hwmons)
}
pub fn read_hwmon_sensor(
hwmon_path: &Path,
sensor: &str,
) -> std::io::Result<Option<f64>> {
let sensor_path = hwmon_path.join(sensor);
if sensor_path.exists() {
let content = fs::read_to_string(sensor_path)?;
Ok(content.trim().parse::<f64>().ok())
} else {
Ok(None)
}
}
pub fn hwmon_info(
hwmon_path: &Path,
) -> std::io::Result<HashMap<String, String>> {
let mut info = HashMap::new();
let name_path = hwmon_path.join("name");
if name_path.exists() {
info.insert(
"name".to_string(),
fs::read_to_string(name_path)?.trim().to_string(),
);
}
pub fn read_hwmon_sensor(hwmon_path: &Path, sensor: &str) -> std::io::Result<Option<f64>> {
let sensor_path = hwmon_path.join(sensor);
if sensor_path.exists() {
let content = fs::read_to_string(sensor_path)?;
Ok(content.trim().parse::<f64>().ok())
} else {
Ok(None)
}
}
pub fn hwmon_info(hwmon_path: &Path) -> std::io::Result<HashMap<String, String>> {
let mut info = HashMap::new();
let name_path = hwmon_path.join("name");
if name_path.exists() {
if let Ok(files) = fs::read_dir(hwmon_path) {
for file in files.flatten() {
let filename = file.file_name().to_string_lossy().to_string();
if filename.starts_with("temp") && filename.ends_with("_input") {
let id = filename
.trim_start_matches("temp")
.trim_end_matches("_input");
if let Some(t) = Self::read_hwmon_sensor(hwmon_path, &filename)
.ok()
.flatten()
{
info.insert(
"name".to_string(),
fs::read_to_string(name_path)?.trim().to_string(),
format!("temp_{}_celsius", id),
format!("{}", t / 1000.0),
);
}
}
if let Ok(files) = fs::read_dir(hwmon_path) {
for file in files.flatten() {
let filename = file.file_name().to_string_lossy().to_string();
if filename.starts_with("temp") && filename.ends_with("_input") {
let id = filename
.trim_start_matches("temp")
.trim_end_matches("_input");
if let Some(t) = Self::read_hwmon_sensor(hwmon_path, &filename)
.ok()
.flatten()
{
info.insert(format!("temp_{}_celsius", id), format!("{}", t / 1000.0));
}
}
if filename.starts_with("fan") && filename.ends_with("_input") {
let id = filename
.trim_start_matches("fan")
.trim_end_matches("_input");
if let Some(f) = Self::read_hwmon_sensor(hwmon_path, &filename)
.ok()
.flatten()
{
info.insert(format!("fan_{}_rpm", id), format!("{}", f));
}
}
if filename.starts_with("in") && filename.ends_with("_input") {
let id = filename.trim_start_matches("in").trim_end_matches("_input");
if let Some(v) = Self::read_hwmon_sensor(hwmon_path, &filename)
.ok()
.flatten()
{
info.insert(format!("voltage_{}_mv", id), format!("{}", v / 1000.0));
}
}
}
if filename.starts_with("fan") && filename.ends_with("_input") {
let id = filename
.trim_start_matches("fan")
.trim_end_matches("_input");
if let Some(f) = Self::read_hwmon_sensor(hwmon_path, &filename)
.ok()
.flatten()
{
info.insert(format!("fan_{}_rpm", id), format!("{}", f));
}
}
Ok(info)
if filename.starts_with("in") && filename.ends_with("_input") {
let id = filename.trim_start_matches("in").trim_end_matches("_input");
if let Some(v) = Self::read_hwmon_sensor(hwmon_path, &filename)
.ok()
.flatten()
{
info
.insert(format!("voltage_{}_mv", id), format!("{}", v / 1000.0));
}
}
}
}
pub fn all_sensors() -> std::io::Result<HashMap<String, HashMap<String, String>>> {
let mut all = HashMap::new();
Ok(info)
}
for hwmon in Self::discover_hwmon()? {
if let Ok(info) = Self::hwmon_info(&hwmon) {
let name = info.get("name").cloned().unwrap_or_else(|| {
hwmon
.file_name()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_else(|| "unknown".to_string())
});
all.insert(name, info);
}
}
pub fn all_sensors(
) -> std::io::Result<HashMap<String, HashMap<String, String>>> {
let mut all = HashMap::new();
Ok(all)
for hwmon in Self::discover_hwmon()? {
if let Ok(info) = Self::hwmon_info(&hwmon) {
let name = info.get("name").cloned().unwrap_or_else(|| {
hwmon
.file_name()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_else(|| "unknown".to_string())
});
all.insert(name, info);
}
}
Ok(all)
}
}

77
crates/pscand-core/src/helpers/system.rs
View file

@ -1,45 +1,50 @@
use std::fs;
use std::time::Duration;
use std::{
fs,
time::Duration,
};
pub struct SystemHelper;
impl SystemHelper {
pub fn uptime() -> std::io::Result<Duration> {
let uptime_secs = fs::read_to_string("/proc/uptime")?
.split_whitespace()
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
Ok(Duration::from_secs_f64(uptime_secs))
}
pub fn uptime() -> std::io::Result<Duration> {
let uptime_secs = fs::read_to_string("/proc/uptime")?
.split_whitespace()
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
Ok(Duration::from_secs_f64(uptime_secs))
}
pub fn boot_id() -> std::io::Result<String> {
fs::read_to_string("/proc/sys/kernel/random/boot_id").map(|s| s.trim().to_string())
}
pub fn boot_id() -> std::io::Result<String> {
fs::read_to_string("/proc/sys/kernel/random/boot_id")
.map(|s| s.trim().to_string())
}
pub fn load_average() -> std::io::Result<(f64, f64, f64)> {
let content = fs::read_to_string("/proc/loadavg")?;
let mut parts = content.split_whitespace();
let load1 = parts
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
let load5 = parts
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
let load15 = parts
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
Ok((load1, load5, load15))
}
pub fn load_average() -> std::io::Result<(f64, f64, f64)> {
let content = fs::read_to_string("/proc/loadavg")?;
let mut parts = content.split_whitespace();
let load1 = parts
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
let load5 = parts
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
let load15 = parts
.next()
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(0.0);
Ok((load1, load5, load15))
}
pub fn hostname() -> std::io::Result<String> {
fs::read_to_string("/proc/sys/kernel/hostname").map(|s| s.trim().to_string())
}
pub fn hostname() -> std::io::Result<String> {
fs::read_to_string("/proc/sys/kernel/hostname")
.map(|s| s.trim().to_string())
}
pub fn kernel_version() -> std::io::Result<String> {
fs::read_to_string("/proc/sys/kernel/osrelease").map(|s| s.trim().to_string())
}
pub fn kernel_version() -> std::io::Result<String> {
fs::read_to_string("/proc/sys/kernel/osrelease")
.map(|s| s.trim().to_string())
}
}

13
crates/pscand-core/src/lib.rs
View file

@ -4,8 +4,17 @@ pub mod logging;
pub mod scanner;
pub use config::Config;
pub use logging::{DaemonLogEntry, LogLevel, RingBufferLogger};
pub use logging::{
DaemonLogEntry,
LogLevel,
RingBufferLogger,
};
pub use scanner::{
get_scanner, register_scanner, MetricValue, Scanner, ScannerCreatorFfi, ScannerError,
get_scanner,
register_scanner,
MetricValue,
Scanner,
ScannerCreatorFfi,
ScannerError,
};
pub type Result<T> = std::result::Result<T, ScannerError>;

1030
crates/pscand-core/src/logging.rs
View file

File diff suppressed because it is too large Load diff

194
crates/pscand-core/src/scanner.rs
View file

@ -1,36 +1,48 @@
use std::collections::HashMap;
use std::os::raw::c_void;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::LazyLock;
use std::sync::Mutex;
use std::time::Duration;
use std::{
collections::HashMap,
os::raw::c_void,
sync::{
atomic::{
AtomicUsize,
Ordering,
},
LazyLock,
Mutex,
},
time::Duration,
};
use serde::{Deserialize, Serialize};
use serde::{
Deserialize,
Serialize,
};
use thiserror::Error;
pub type ScannerBox = Box<dyn Scanner>;
pub type ScannerResult = Result<ScannerBox>;
pub type ScannerMetrics = HashMap<String, MetricValue>;
pub type ScannerCollectionResult = Result<ScannerMetrics>;
pub type ScannerCollectFn = Box<dyn Fn() -> ScannerCollectionResult + Send + Sync>;
pub type ScannerInitFnMut = Mutex<Box<dyn FnMut(&toml::Value) -> Result<()> + Send>>;
pub type ScannerCollectFn =
Box<dyn Fn() -> ScannerCollectionResult + Send + Sync>;
pub type ScannerInitFnMut =
Mutex<Box<dyn FnMut(&toml::Value) -> Result<()> + Send>>;
pub type ScannerCleanupFnMut = Mutex<Box<dyn FnMut() -> Result<()> + Send>>;
pub type ScannerCreatorFfi = unsafe extern "C" fn() -> *mut c_void;
pub type ScannerInitFn = unsafe extern "C" fn() -> *mut c_void;
pub type ScannerDropFn = unsafe extern "C" fn(*mut c_void);
pub type ScannerCreatorFfi = unsafe extern fn() -> *mut c_void;
pub type ScannerInitFn = unsafe extern fn() -> *mut c_void;
pub type ScannerDropFn = unsafe extern fn(*mut c_void);
#[derive(Error, Debug)]
pub enum ScannerError {
#[error("IO error: {0}")]
Io(#[from] std::io::Error),
#[error("Parse error: {0}")]
Parse(String),
#[error("Configuration error: {0}")]
Config(String),
#[error("Scanner not initialized")]
NotInitialized,
#[error("Scanner {0} not found")]
NotFound(String),
#[error("IO error: {0}")]
Io(#[from] std::io::Error),
#[error("Parse error: {0}")]
Parse(String),
#[error("Configuration error: {0}")]
Config(String),
#[error("Scanner not initialized")]
NotInitialized,
#[error("Scanner {0} not found")]
NotFound(String),
}
pub type Result<T> = std::result::Result<T, ScannerError>;
@ -38,40 +50,40 @@ pub type Result<T> = std::result::Result<T, ScannerError>;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum MetricValue {
Integer(i64),
Float(f64),
Boolean(bool),
String(String),
Integer(i64),
Float(f64),
Boolean(bool),
String(String),
}
impl MetricValue {
pub fn from_i64(v: i64) -> Self {
MetricValue::Integer(v)
}
pub fn from_i64(v: i64) -> Self {
MetricValue::Integer(v)
}
pub fn from_f64(v: f64) -> Self {
MetricValue::Float(v)
}
pub fn from_f64(v: f64) -> Self {
MetricValue::Float(v)
}
pub fn from_bool(v: bool) -> Self {
MetricValue::Boolean(v)
}
pub fn from_bool(v: bool) -> Self {
MetricValue::Boolean(v)
}
pub fn from_string(v: impl Into<String>) -> Self {
MetricValue::String(v.into())
}
pub fn from_string(v: impl Into<String>) -> Self {
MetricValue::String(v.into())
}
}
pub trait Scanner: Send + Sync {
fn name(&self) -> &'static str;
fn interval(&self) -> Duration;
fn init(&mut self, config: &toml::Value) -> Result<()>;
fn collect(&self) -> ScannerCollectionResult;
fn cleanup(&mut self) -> Result<()>;
fn name(&self) -> &'static str;
fn interval(&self) -> Duration;
fn init(&mut self, config: &toml::Value) -> Result<()>;
fn collect(&self) -> ScannerCollectionResult;
fn cleanup(&mut self) -> Result<()>;
}
static SCANNER_HANDLES: LazyLock<Mutex<HashMap<usize, ScannerBox>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
LazyLock::new(|| Mutex::new(HashMap::new()));
static NEXT_HANDLE: AtomicUsize = AtomicUsize::new(1);
#[inline]
@ -79,9 +91,9 @@ static NEXT_HANDLE: AtomicUsize = AtomicUsize::new(1);
/// # Safety
/// The handle must only be used with `get_scanner` from the same process.
pub unsafe fn register_scanner(scanner: ScannerBox) -> usize {
let handle = NEXT_HANDLE.fetch_add(1, Ordering::SeqCst);
SCANNER_HANDLES.lock().unwrap().insert(handle, scanner);
handle
let handle = NEXT_HANDLE.fetch_add(1, Ordering::SeqCst);
SCANNER_HANDLES.lock().unwrap().insert(handle, scanner);
handle
}
#[inline]
@ -90,65 +102,65 @@ pub unsafe fn register_scanner(scanner: ScannerBox) -> usize {
/// The handle must have been obtained from `register_scanner` in this process,
/// and the returned Box must be properly dropped.
pub unsafe fn get_scanner(handle: *mut c_void) -> Option<ScannerBox> {
let handle = handle as usize;
if handle == 0 {
None
} else {
SCANNER_HANDLES.lock().unwrap().remove(&handle)
}
let handle = handle as usize;
if handle == 0 {
None
} else {
SCANNER_HANDLES.lock().unwrap().remove(&handle)
}
}
pub trait ScannerRegistry: Send + Sync {
fn list_scanners(&self) -> Vec<&'static str>;
fn get_scanner(&self, name: &str) -> Option<ScannerBox>;
fn list_scanners(&self) -> Vec<&'static str>;
fn get_scanner(&self, name: &str) -> Option<ScannerBox>;
}
pub struct DynamicScanner {
name: &'static str,
interval: Duration,
collect_fn: ScannerCollectFn,
init_fn: ScannerInitFnMut,
cleanup_fn: ScannerCleanupFnMut,
name: &'static str,
interval: Duration,
collect_fn: ScannerCollectFn,
init_fn: ScannerInitFnMut,
cleanup_fn: ScannerCleanupFnMut,
}
impl DynamicScanner {
pub fn new(
name: &'static str,
interval: Duration,
collect_fn: impl Fn() -> ScannerCollectionResult + Send + Sync + 'static,
init_fn: impl FnMut(&toml::Value) -> Result<()> + Send + 'static,
cleanup_fn: impl FnMut() -> Result<()> + Send + 'static,
) -> Self {
Self {
name,
interval,
collect_fn: Box::new(collect_fn),
init_fn: Mutex::new(Box::new(init_fn)),
cleanup_fn: Mutex::new(Box::new(cleanup_fn)),
}
pub fn new(
name: &'static str,
interval: Duration,
collect_fn: impl Fn() -> ScannerCollectionResult + Send + Sync + 'static,
init_fn: impl FnMut(&toml::Value) -> Result<()> + Send + 'static,
cleanup_fn: impl FnMut() -> Result<()> + Send + 'static,
) -> Self {
Self {
name,
interval,
collect_fn: Box::new(collect_fn),
init_fn: Mutex::new(Box::new(init_fn)),
cleanup_fn: Mutex::new(Box::new(cleanup_fn)),
}
}
}
impl Scanner for DynamicScanner {
fn name(&self) -> &'static str {
self.name
}
fn name(&self) -> &'static str {
self.name
}
fn interval(&self) -> Duration {
self.interval
}
fn interval(&self) -> Duration {
self.interval
}
fn init(&mut self, config: &toml::Value) -> Result<()> {
let mut init_fn = self.init_fn.lock().unwrap();
(init_fn)(config)
}
fn init(&mut self, config: &toml::Value) -> Result<()> {
let mut init_fn = self.init_fn.lock().unwrap();
(init_fn)(config)
}
fn collect(&self) -> ScannerCollectionResult {
(self.collect_fn)()
}
fn collect(&self) -> ScannerCollectionResult {
(self.collect_fn)()
}
fn cleanup(&mut self) -> Result<()> {
let mut cleanup_fn = self.cleanup_fn.lock().unwrap();
(cleanup_fn)()
}
fn cleanup(&mut self) -> Result<()> {
let mut cleanup_fn = self.cleanup_fn.lock().unwrap();
(cleanup_fn)()
}
}

6
crates/pscand-macros/Cargo.toml
View file

@ -1,5 +1,5 @@
[package]
name = "pscand-macros"
name = "pscand-macros"
version.workspace = true
edition.workspace = true
license.workspace = true
@ -10,5 +10,5 @@ proc-macro = true
[dependencies]
proc-macro2 = "1"
quote = "1"
syn = { version = "2", features = ["full"] }
quote = "1"
syn = { features = [ "full" ], version = "2" }

87
crates/pscand-macros/src/lib.rs
View file

@ -1,64 +1,67 @@
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn};
use syn::{
parse_macro_input,
ItemFn,
};
#[proc_macro_attribute]
pub fn scanner(name: TokenStream, input: TokenStream) -> TokenStream {
let name_str = parse_macro_input!(name as syn::LitStr).value();
let input = parse_macro_input!(input as ItemFn);
let name_str = parse_macro_input!(name as syn::LitStr).value();
let input = parse_macro_input!(input as ItemFn);
let _fn_name = input.sig.ident.clone();
let body = &input.block;
let _fn_name = input.sig.ident.clone();
let body = &input.block;
let result = quote! {
#[no_mangle]
pub extern "C" fn pscand_scanner() -> *mut std::os::raw::c_void {
struct ScannerImpl;
let result = quote! {
#[no_mangle]
pub extern "C" fn pscand_scanner() -> *mut std::os::raw::c_void {
struct ScannerImpl;
impl pscand_core::Scanner for ScannerImpl {
fn name(&self) -> &'static str {
#name_str
}
impl pscand_core::Scanner for ScannerImpl {
fn name(&self) -> &'static str {
#name_str
}
fn interval(&self) -> std::time::Duration {
std::time::Duration::from_secs(1)
}
fn interval(&self) -> std::time::Duration {
std::time::Duration::from_secs(1)
}
fn init(&mut self, _config: &toml::Value) -> pscand_core::Result<()> {
Ok(())
}
fn init(&mut self, _config: &toml::Value) -> pscand_core::Result<()> {
Ok(())
}
fn collect(&self) -> pscand_core::Result<std::collections::HashMap<String, pscand_core::MetricValue>> {
#body
}
fn collect(&self) -> pscand_core::Result<std::collections::HashMap<String, pscand_core::MetricValue>> {
#body
}
fn cleanup(&mut self) -> pscand_core::Result<()> {
Ok(())
}
}
fn cleanup(&mut self) -> pscand_core::Result<()> {
Ok(())
}
}
let handle = unsafe { pscand_core::register_scanner(Box::new(ScannerImpl)) };
handle as *mut std::os::raw::c_void
}
};
let handle = unsafe { pscand_core::register_scanner(Box::new(ScannerImpl)) };
handle as *mut std::os::raw::c_void
}
};
result.into()
result.into()
}
#[proc_macro]
pub fn register_scanner(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as ItemFn);
let fn_name = input.sig.ident.clone();
let input = parse_macro_input!(input as ItemFn);
let fn_name = input.sig.ident.clone();
let result = quote! {
#input
let result = quote! {
#input
#[no_mangle]
pub extern "C" fn pscand_scanner() -> *mut std::os::raw::c_void {
let handle = unsafe { pscand_core::register_scanner(Box::new(#fn_name())) };
handle as *mut std::os::raw::c_void
}
};
#[no_mangle]
pub extern "C" fn pscand_scanner() -> *mut std::os::raw::c_void {
let handle = unsafe { pscand_core::register_scanner(Box::new(#fn_name())) };
handle as *mut std::os::raw::c_void
}
};
result.into()
result.into()
}