use hickory_resolver::TokioResolver;
use std::path::PathBuf;
use std::sync::Arc;
use crate::error_handling::ProcessingStats;
use crate::fingerprint::FingerprintRuleset;
use crate::runtime_metrics::RuntimeMetrics;
use crate::storage::DbPool;
use crate::utils::TimingStats;
#[derive(Clone)]
pub struct NetworkContext {
pub client: Arc<reqwest::Client>,
pub redirect_client: Arc<reqwest::Client>,
pub resolver: Arc<TokioResolver>,
}
#[derive(Clone)]
pub struct RuntimeContext {
pub error_stats: Arc<ProcessingStats>,
pub timing_stats: Arc<TimingStats>,
pub run_id: Option<String>,
pub enable_whois: bool,
pub whois_cache_dir: PathBuf,
pub scan_external_scripts: bool,
pub runtime_metrics: Arc<RuntimeMetrics>,
pub allow_localhost_for_tests: bool,
pub(crate) whois_client: Option<crate::whois::SharedWhoisClient>,
}
#[derive(Clone)]
pub struct ProcessingContext {
pub network: NetworkContext,
pub pool: DbPool,
pub runtime: RuntimeContext,
pub ruleset: Arc<FingerprintRuleset>,
}
impl NetworkContext {
pub fn new(
client: Arc<reqwest::Client>,
redirect_client: Arc<reqwest::Client>,
resolver: Arc<TokioResolver>,
) -> Self {
Self {
client,
redirect_client,
resolver,
}
}
}
impl RuntimeContext {
#[allow(clippy::too_many_arguments)] pub fn new(
error_stats: Arc<ProcessingStats>,
timing_stats: Arc<TimingStats>,
run_id: Option<String>,
enable_whois: bool,
whois_cache_dir: PathBuf,
scan_external_scripts: bool,
runtime_metrics: Arc<RuntimeMetrics>,
allow_localhost_for_tests: bool,
) -> Self {
Self {
error_stats,
timing_stats,
run_id,
enable_whois,
whois_cache_dir,
scan_external_scripts,
runtime_metrics,
allow_localhost_for_tests,
whois_client: None,
}
}
}
impl ProcessingContext {
pub fn new(
network: NetworkContext,
pool: DbPool,
runtime: RuntimeContext,
ruleset: Arc<FingerprintRuleset>,
) -> Self {
Self {
network,
pool,
runtime,
ruleset,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::initialization::test_resolver;
fn empty_ruleset() -> Arc<FingerprintRuleset> {
Arc::new(FingerprintRuleset::empty_for_tests())
}
#[tokio::test]
async fn test_processing_context_new() {
let client = Arc::new(
reqwest::Client::builder()
.build()
.expect("Failed to create HTTP client"),
);
let redirect_client = Arc::new(
reqwest::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.build()
.expect("Failed to create redirect client"),
);
let resolver = test_resolver();
let error_stats = Arc::new(ProcessingStats::new());
let run_id = Some("test-run-123".to_string());
let enable_whois = true;
let pool = Arc::new(
sqlx::SqlitePool::connect("sqlite::memory:")
.await
.expect("Failed to create test pool"),
);
let timing_stats = Arc::new(TimingStats::new());
let ruleset = empty_ruleset();
let context = ProcessingContext::new(
NetworkContext::new(client.clone(), redirect_client.clone(), resolver.clone()),
pool.clone(),
RuntimeContext::new(
error_stats.clone(),
timing_stats.clone(),
run_id.clone(),
enable_whois,
std::path::PathBuf::from("/tmp/domain_status_whois_test"),
false,
Arc::new(RuntimeMetrics::default()),
true,
),
Arc::clone(&ruleset),
);
assert_eq!(Arc::as_ptr(&context.network.client), Arc::as_ptr(&client));
assert_eq!(
Arc::as_ptr(&context.network.redirect_client),
Arc::as_ptr(&redirect_client)
);
assert_eq!(
Arc::as_ptr(&context.network.resolver),
Arc::as_ptr(&resolver)
);
assert_eq!(
Arc::as_ptr(&context.runtime.error_stats),
Arc::as_ptr(&error_stats)
);
assert_eq!(context.runtime.run_id, run_id);
assert_eq!(context.runtime.enable_whois, enable_whois);
assert_eq!(Arc::as_ptr(&context.pool), Arc::as_ptr(&pool));
assert_eq!(
Arc::as_ptr(&context.runtime.timing_stats),
Arc::as_ptr(&timing_stats)
);
assert_eq!(Arc::as_ptr(&context.ruleset), Arc::as_ptr(&ruleset));
}
#[tokio::test]
async fn test_processing_context_without_run_id() {
let client = Arc::new(
reqwest::Client::builder()
.build()
.expect("Failed to create HTTP client"),
);
let redirect_client = Arc::new(
reqwest::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.build()
.expect("Failed to create redirect client"),
);
let resolver = test_resolver();
let error_stats = Arc::new(ProcessingStats::new());
let run_id = None;
let enable_whois = false;
let pool = Arc::new(
sqlx::SqlitePool::connect("sqlite::memory:")
.await
.expect("Failed to create test pool"),
);
let timing_stats = Arc::new(TimingStats::new());
let context = ProcessingContext::new(
NetworkContext::new(client, redirect_client, resolver),
pool,
RuntimeContext::new(
error_stats,
timing_stats,
run_id,
enable_whois,
std::path::PathBuf::from("/tmp/domain_status_whois_test"),
false,
Arc::new(RuntimeMetrics::default()),
true,
),
empty_ruleset(),
);
assert_eq!(context.runtime.run_id, None);
}
}