#[cfg(all(feature = "engine-moli", feature = "metrics"))]
use metrics::gauge;
use std::sync::atomic::{AtomicU8, Ordering};
use std::sync::Arc;
use std::time::Duration;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
#[repr(u8)]
pub enum MemoryLevel {
Critical = 0,
Tight = 1,
Abundant = 2,
}
impl MemoryLevel {
fn from_u8(v: u8) -> Self {
match v {
0 => MemoryLevel::Critical,
1 => MemoryLevel::Tight,
_ => MemoryLevel::Abundant,
}
}
}
pub fn classify(available_mib: u64, critical_mib: u64, tight_mib: u64) -> MemoryLevel {
if available_mib < critical_mib {
MemoryLevel::Critical
} else if available_mib < tight_mib {
MemoryLevel::Tight
} else {
MemoryLevel::Abundant
}
}
const FAILURE_THRESHOLD: u8 = 3;
const TIGHT_MOLI_BOOST: u16 = 30;
static GLOBAL_MEMORY_WATERMARK: parking_lot::RwLock<Option<Arc<MemoryWatermark>>> =
parking_lot::RwLock::new(None);
pub fn set_global(watermark: Arc<MemoryWatermark>) {
*GLOBAL_MEMORY_WATERMARK.write() = Some(watermark);
}
pub fn get_global() -> Option<Arc<MemoryWatermark>> {
GLOBAL_MEMORY_WATERMARK.read().clone()
}
const BROWSER_ENGINES: [&str; 5] = [
"playwright",
"flaresolverr",
"flaresolverr_cdp",
"flaresolverr_tls",
"mllm",
];
pub fn apply_memory_policy(score: u8, engine_name: &str, level: MemoryLevel, needs_js: bool) -> u8 {
if !needs_js || level == MemoryLevel::Abundant {
return score;
}
match level {
MemoryLevel::Abundant => score,
MemoryLevel::Tight => {
if engine_name == "moli" {
(u16::from(score) + TIGHT_MOLI_BOOST).min(255) as u8
} else {
score
}
}
MemoryLevel::Critical => {
if engine_name == "moli" || !BROWSER_ENGINES.contains(&engine_name) {
score
} else {
0
}
}
}
}
pub struct MemoryWatermark {
level: AtomicU8,
critical_mib: u64,
tight_mib: u64,
consecutive_failures: AtomicU8,
}
impl MemoryWatermark {
pub fn new(critical_mib: u64, tight_mib: u64) -> Arc<Self> {
Arc::new(Self {
level: AtomicU8::new(MemoryLevel::Abundant as u8),
critical_mib,
tight_mib,
consecutive_failures: AtomicU8::new(0),
})
}
pub fn level(&self) -> MemoryLevel {
MemoryLevel::from_u8(self.level.load(Ordering::Relaxed))
}
pub fn apply_sample(&self, available_mib: Option<u64>) -> MemoryLevel {
match available_mib {
Some(available) => {
self.consecutive_failures.store(0, Ordering::Relaxed);
let next = classify(available, self.critical_mib, self.tight_mib);
let prev = self.level.swap(next as u8, Ordering::Relaxed);
#[cfg(all(feature = "engine-moli", feature = "metrics"))]
gauge!("crawlrs_memory_level").set(next as u8 as f64);
if prev != next as u8 {
log::info!(
target: "crawlrs::memory",
"memory level transition: {:?} -> {:?} (available={} MiB)",
MemoryLevel::from_u8(prev),
next,
available
);
}
next
}
None => {
let failures = self.consecutive_failures.fetch_add(1, Ordering::Relaxed) + 1;
if failures >= FAILURE_THRESHOLD {
let prev = self
.level
.swap(MemoryLevel::Critical as u8, Ordering::Relaxed);
#[cfg(all(feature = "engine-moli", feature = "metrics"))]
gauge!("crawlrs_memory_level").set(MemoryLevel::Critical as u8 as f64);
log::warn!(
target: "crawlrs::memory",
"memory sampling failed {} times consecutively, forcing Critical (was {:?})",
failures,
MemoryLevel::from_u8(prev)
);
MemoryLevel::Critical
} else {
log::warn!(
target: "crawlrs::memory",
"memory sampling failed ({}), keeping previous level {:?}",
failures,
self.level()
);
self.level()
}
}
}
}
pub fn mark_sampler_unavailable(&self) {
self.consecutive_failures
.store(FAILURE_THRESHOLD, Ordering::Relaxed);
let prev = self
.level
.swap(MemoryLevel::Critical as u8, Ordering::Relaxed);
#[cfg(all(feature = "engine-moli", feature = "metrics"))]
gauge!("crawlrs_memory_level").set(MemoryLevel::Critical as u8 as f64);
log::warn!(
target: "crawlrs::memory",
"memory sampler unavailable (sysinfo init failed), forcing Critical (was {:?})",
MemoryLevel::from_u8(prev)
);
}
pub async fn run(self: Arc<Self>, refresh_interval: Duration) {
let mut sys = match sysinfo::System::new() {
Ok(sys) => sys,
Err(e) => {
log::error!(
target: "crawlrs::engines::memory_watermark",
"sysinfo System 初始化失败,内存水位采样停用: {e}"
);
self.mark_sampler_unavailable();
return;
}
};
let mut ticker = tokio::time::interval(refresh_interval);
ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
ticker.tick().await;
sys.refresh_memory();
let available_mib = sys.available_memory() / 1024 / 1024;
let sample = if available_mib == 0 {
None
} else {
Some(available_mib)
};
self.apply_sample(sample);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_boundary_511_512() {
assert_eq!(classify(511, 512, 2048), MemoryLevel::Critical);
assert_eq!(classify(512, 512, 2048), MemoryLevel::Tight);
}
#[test]
fn classify_boundary_2047_2048() {
assert_eq!(classify(2047, 512, 2048), MemoryLevel::Tight);
assert_eq!(classify(2048, 512, 2048), MemoryLevel::Abundant);
}
#[test]
fn apply_sample_failure_keeps_previous_then_critical() {
let wm = MemoryWatermark::new(512, 2048);
assert_eq!(wm.apply_sample(Some(1500)), MemoryLevel::Tight);
assert_eq!(wm.apply_sample(None), MemoryLevel::Tight);
assert_eq!(wm.apply_sample(None), MemoryLevel::Tight);
assert_eq!(wm.apply_sample(None), MemoryLevel::Critical);
}
#[test]
fn apply_sample_success_resets_failure_counter() {
let wm = MemoryWatermark::new(512, 2048);
assert_eq!(wm.apply_sample(None), MemoryLevel::Abundant); assert_eq!(wm.apply_sample(None), MemoryLevel::Abundant); assert_eq!(wm.apply_sample(Some(4096)), MemoryLevel::Abundant); assert_eq!(wm.apply_sample(None), MemoryLevel::Abundant); assert_eq!(wm.apply_sample(None), MemoryLevel::Abundant); assert_eq!(wm.apply_sample(None), MemoryLevel::Critical); }
#[test]
fn sampler_unavailable_forces_critical() {
let wm = MemoryWatermark::new(512, 2048);
assert_eq!(wm.level(), MemoryLevel::Abundant);
wm.mark_sampler_unavailable();
assert_eq!(wm.level(), MemoryLevel::Critical);
assert_eq!(wm.apply_sample(None), MemoryLevel::Critical);
}
#[test]
fn sample_below_critical_reflected_in_mirror() {
let wm = MemoryWatermark::new(512, 2048);
assert_eq!(wm.apply_sample(Some(100)), MemoryLevel::Critical);
assert_eq!(wm.level(), MemoryLevel::Critical);
}
#[test]
fn policy_abundant_never_changes_score() {
for (engine, score) in [("moli", 100u8), ("playwright", 200), ("reqwest", 150)] {
for needs_js in [true, false] {
assert_eq!(
apply_memory_policy(score, engine, MemoryLevel::Abundant, needs_js),
score,
"Abundant 不改分: {engine}/{needs_js}"
);
}
}
}
#[test]
fn policy_non_needs_js_unaffected_by_any_level() {
for level in [
MemoryLevel::Abundant,
MemoryLevel::Tight,
MemoryLevel::Critical,
] {
for (engine, score) in [("moli", 100u8), ("playwright", 200), ("reqwest", 150)] {
assert_eq!(
apply_memory_policy(score, engine, level, false),
score,
"非 needs_js 不受水位影响: {engine}/{level:?}"
);
}
}
}
#[test]
fn policy_tight_boosts_only_moli() {
assert_eq!(
apply_memory_policy(100, "moli", MemoryLevel::Tight, true),
130,
"Tight 对 moli +30"
);
assert_eq!(
apply_memory_policy(250, "moli", MemoryLevel::Tight, true),
255,
"Tight 加成封顶 255"
);
assert_eq!(
apply_memory_policy(200, "playwright", MemoryLevel::Tight, true),
200,
"Tight 时 Playwright 不得加分"
);
assert_eq!(
apply_memory_policy(150, "reqwest", MemoryLevel::Tight, true),
150,
"Tight 时静态引擎不改分"
);
}
#[test]
fn policy_critical_zeroes_browser_engines_except_moli() {
assert_eq!(
apply_memory_policy(200, "playwright", MemoryLevel::Critical, true),
0,
"Critical 时 Playwright 归 0"
);
for browser in [
"flaresolverr",
"flaresolverr_cdp",
"flaresolverr_tls",
"mllm",
] {
assert_eq!(
apply_memory_policy(180, browser, MemoryLevel::Critical, true),
0,
"Critical 时浏览器系 {browser} 归 0"
);
}
assert_eq!(
apply_memory_policy(120, "moli", MemoryLevel::Critical, true),
120,
"Critical 时仅 moli 保留分数"
);
assert_eq!(
apply_memory_policy(150, "reqwest", MemoryLevel::Critical, true),
150,
"Critical 时静态引擎不改分(回退语义由 router 层处理)"
);
}
}