feat: velocity routing, server registry and RampartVelocity tests
This commit is contained in:
parent
c50cb67d9e
commit
cb183d42a2
41 changed files with 1239 additions and 532 deletions
|
|
@ -4,11 +4,26 @@ use rampart_core::filter::rate_limit::RateLimiter;
|
|||
use rampart_core::metrics;
|
||||
use rampart_core::pow::difficulty::DifficultyAdjuster;
|
||||
use rampart_core::proxy::listener::ProxyListener;
|
||||
use rampart_core::store::clickhouse::{ClickHouseEvent, ClickHouseWriter};
|
||||
use rampart_core::traffic::detector::{AttackDetector, AttackStatus};
|
||||
use rampart_core::traffic::reputation::IpReputation;
|
||||
use rampart_core::xdp::XdpFilter;
|
||||
use std::collections::HashSet;
|
||||
use std::net::IpAddr;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
use tokio::sync::watch;
|
||||
use tracing_subscriber::EnvFilter;
|
||||
|
||||
fn attack_status_value(status: AttackStatus) -> i64 {
|
||||
match status {
|
||||
AttackStatus::Normal => 0,
|
||||
AttackStatus::Suspicious => 1,
|
||||
AttackStatus::UnderAttack => 2,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
tracing_subscriber::fmt()
|
||||
|
|
@ -17,6 +32,7 @@ async fn main() -> anyhow::Result<()> {
|
|||
|
||||
let config_path = std::env::var("RAMPART_CONFIG").unwrap_or_else(|_| "/etc/rampart/config.toml".to_string());
|
||||
let config = Config::from_file(&config_path)?;
|
||||
let whitelist = build_whitelist(&config)?;
|
||||
let config = Arc::new(config);
|
||||
|
||||
let rate_limiter = Arc::new(RateLimiter::new(
|
||||
|
|
@ -24,6 +40,9 @@ async fn main() -> anyhow::Result<()> {
|
|||
config.limits.rate_limit_burst,
|
||||
));
|
||||
let blacklist = Arc::new(Blacklist::new());
|
||||
let reputation = Arc::new(IpReputation::new());
|
||||
let detector = Arc::new(Mutex::new(AttackDetector::new()));
|
||||
let allowed_1s = Arc::new(AtomicU64::new(0));
|
||||
|
||||
let (shutdown_tx, shutdown_rx) = watch::channel(false);
|
||||
|
||||
|
|
@ -64,35 +83,135 @@ async fn main() -> anyhow::Result<()> {
|
|||
});
|
||||
}
|
||||
|
||||
#[cfg(feature = "xdp")]
|
||||
if config.xdp.enabled {
|
||||
use rampart_core::xdp::{XdpFilter, XdpMetrics};
|
||||
let clickhouse: Option<Arc<tokio::sync::Mutex<ClickHouseWriter>>> = match &config.store.clickhouse_url {
|
||||
Some(url) if !url.is_empty() => {
|
||||
let writer = Arc::new(tokio::sync::Mutex::new(ClickHouseWriter::new(url)));
|
||||
rampart_core::store::clickhouse::start_flush_task(writer.clone(), shutdown_rx.clone());
|
||||
Some(writer)
|
||||
},
|
||||
_ => None,
|
||||
};
|
||||
|
||||
let mut filter = XdpFilter::new(&config.xdp.interface);
|
||||
filter.load()?;
|
||||
#[cfg(feature = "xdp")]
|
||||
let xdp_filter: Option<Arc<Mutex<XdpFilter>>> = if config.xdp.enabled {
|
||||
use rampart_core::xdp::XdpMetrics;
|
||||
|
||||
let filter = XdpFilter::new(&config.xdp.interface);
|
||||
let shared = Arc::new(Mutex::new(filter));
|
||||
shared.lock().expect("xdp lock poisoned").load()?;
|
||||
let xdp_metrics = XdpMetrics::register()?;
|
||||
|
||||
let sd = shutdown_rx.clone();
|
||||
let shared_thread = shared.clone();
|
||||
std::thread::spawn(move || {
|
||||
while !*sd.borrow() {
|
||||
filter.drain_events();
|
||||
if let Ok(stats) = filter.get_stats() {
|
||||
let guard = match shared_thread.lock() {
|
||||
Ok(g) => g,
|
||||
Err(_) => break,
|
||||
};
|
||||
guard.drain_events();
|
||||
if let Ok(stats) = guard.get_stats() {
|
||||
xdp_metrics.update(&stats);
|
||||
}
|
||||
drop(guard);
|
||||
std::thread::sleep(Duration::from_secs(5));
|
||||
}
|
||||
filter.unload().ok();
|
||||
if let Ok(mut guard) = shared_thread.lock() {
|
||||
guard.unload().ok();
|
||||
}
|
||||
});
|
||||
}
|
||||
Some(shared)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
#[cfg(not(feature = "xdp"))]
|
||||
let xdp_filter: Option<Arc<Mutex<XdpFilter>>> = None;
|
||||
|
||||
let rl = rate_limiter.clone();
|
||||
let bl = blacklist.clone();
|
||||
let det = detector.clone();
|
||||
let a1s = allowed_1s.clone();
|
||||
let ch = clickhouse.clone();
|
||||
let mut sd = shutdown_rx.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut sec_tick = tokio::time::interval(Duration::from_secs(1));
|
||||
let mut min_tick = tokio::time::interval(Duration::from_secs(60));
|
||||
sec_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
min_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
let mut was_under_attack = false;
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = sd.changed() => {
|
||||
if *sd.borrow() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
_ = sec_tick.tick() => {
|
||||
let pps = a1s.swap(0, Ordering::Relaxed) as f64;
|
||||
let status = det.lock().expect("detector lock poisoned").analyze(pps);
|
||||
metrics::ATTACK_STATUS.set(attack_status_value(status));
|
||||
if status == AttackStatus::UnderAttack {
|
||||
if !was_under_attack {
|
||||
was_under_attack = true;
|
||||
tracing::info!(pps, "attack detected: under attack");
|
||||
if let Some(writer) = &ch {
|
||||
let event = ClickHouseEvent {
|
||||
timestamp: chrono::Utc::now(),
|
||||
event_type: "attack".to_string(),
|
||||
ip: String::new(),
|
||||
data_float: pps,
|
||||
data_int: 0,
|
||||
data_string: "under_attack".to_string(),
|
||||
};
|
||||
if let Err(e) = writer.lock().await.push(event).await {
|
||||
tracing::debug!("clickhouse push error: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if was_under_attack {
|
||||
was_under_attack = false;
|
||||
}
|
||||
}
|
||||
_ = min_tick.tick() => {
|
||||
rl.sweep();
|
||||
bl.clear_expired();
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
tracing::info!("Rampart edge starting on {}:{}", config.bind.address, config.bind.port);
|
||||
tracing::info!("Backend: {}:{}", config.backend.address, config.backend.port);
|
||||
|
||||
let adjuster = Arc::new(Mutex::new(DifficultyAdjuster::default()));
|
||||
let listener = ProxyListener::new(config, rate_limiter, blacklist, adjuster);
|
||||
let listener = ProxyListener::new(
|
||||
config,
|
||||
rate_limiter,
|
||||
blacklist,
|
||||
adjuster,
|
||||
whitelist,
|
||||
reputation,
|
||||
xdp_filter,
|
||||
clickhouse,
|
||||
allowed_1s,
|
||||
);
|
||||
listener.run(shutdown_rx).await
|
||||
}
|
||||
|
||||
fn build_whitelist(config: &Config) -> anyhow::Result<Arc<HashSet<IpAddr>>> {
|
||||
let mut set = HashSet::with_capacity(config.whitelist.len());
|
||||
for entry in &config.whitelist {
|
||||
let ip: IpAddr = match entry.parse() {
|
||||
Ok(ip) => ip,
|
||||
Err(_) => anyhow::bail!("invalid whitelist entry: {entry}"),
|
||||
};
|
||||
set.insert(ip);
|
||||
}
|
||||
Ok(Arc::new(set))
|
||||
}
|
||||
|
||||
async fn wait_for_signal() {
|
||||
let ctrl_c = tokio::signal::ctrl_c();
|
||||
let mut term = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue