use std::{
sync::{
Arc,
atomic::{
AtomicU64,
Ordering,
},
},
time::Duration,
};
use simulcrypt::{
CasConfig,
EcmgConfig,
Event,
ServiceCas,
ServiceConfig,
Simulcrypt,
};
fn env_or(name: &str, default: &str) -> String {
std::env::var(name).unwrap_or_else(|_| default.to_string())
}
fn env_parse<T: std::str::FromStr>(name: &str, default: T) -> T {
std::env::var(name)
.ok()
.and_then(|value| value.parse().ok())
.unwrap_or(default)
}
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let host: std::net::IpAddr = env_parse("ECMG_HOST", [127, 0, 0, 1].into());
let port: u16 = env_parse("ECMG_PORT", 2222);
let channel_id: u16 = env_parse("ECMG_CHANNEL_ID", 1);
let super_cas_id =
u32::from_str_radix(&env_or("SUPER_CAS_ID", "0b000001"), 16).expect("invalid SUPER_CAS_ID");
let crypto_period_secs: u64 = env_parse("CRYPTO_PERIOD_SECS", 10);
let simulcrypt = Simulcrypt::new();
let lease = simulcrypt
.acquire_cas(CasConfig {
id: "cas-1".into(),
name: "monitored-cas".into(),
super_cas_id,
first_stream_id: 0,
ecmg: EcmgConfig::new(channel_id, std::net::SocketAddr::new(host, port)),
emmg: None,
})
.expect("acquire_cas failed");
let mut service = simulcrypt
.open_service(&ServiceConfig {
name: "monitor-demo".into(),
crypto_period: Duration::from_secs(crypto_period_secs),
cas: vec![ServiceCas {
cas: lease.cas(),
ecm_pid: 100,
access_criteria: vec![],
}],
})
.expect("open_service failed");
let ecm_count = Arc::new(AtomicU64::new(0));
let counter = Arc::clone(&ecm_count);
tokio::spawn(async move {
while let Some(event) = service.recv().await {
if matches!(event, Event::Ecm { .. }) {
counter.fetch_add(1, Ordering::Relaxed);
}
}
});
let mut interval = tokio::time::interval(Duration::from_secs(2));
loop {
interval.tick().await;
println!("--- status ---");
for status in simulcrypt.status() {
println!(
"{:?} name={} state={:?}",
status.cas, status.name, status.state
);
}
println!("ecm received so far: {}", ecm_count.load(Ordering::Relaxed));
}
}