use std::net::SocketAddr;
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use crate::netpolicy::{TcpPolicy, UdpPolicy};
#[derive(Clone, Debug, PartialEq)]
pub struct RecordedEntry {
pub at: Duration,
pub seq: u64,
pub event: RecordedEvent,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Transport {
Tcp,
Udp,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Toward {
Tester,
CodeUnderTest,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum LinkFault {
Lost,
TooBig,
Duplicated,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Direction {
Receive,
Send,
Both,
}
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub enum RecordedEvent {
Accepted {
tester: SocketAddr,
peer: SocketAddr,
},
Received {
transport: Transport,
tester: SocketAddr,
peer: SocketAddr,
len: usize,
},
Sent {
transport: Transport,
tester: SocketAddr,
peer: SocketAddr,
len: usize,
},
Closed {
tester: SocketAddr,
peer: SocketAddr,
},
Reset {
tester: SocketAddr,
peer: SocketAddr,
},
PeerClosed {
tester: SocketAddr,
peer: SocketAddr,
},
PeerReset {
tester: SocketAddr,
peer: SocketAddr,
},
Quiesced {
tester: SocketAddr,
peer: SocketAddr,
span: Duration,
},
Suppressed {
tester: SocketAddr,
peer: SocketAddr,
toward: Toward,
len: usize,
},
Link {
from: SocketAddr,
to: SocketAddr,
len: usize,
fault: LinkFault,
},
UdpPolicyChanged { addr: SocketAddr, policy: UdpPolicy },
TcpPolicyChanged { addr: SocketAddr, policy: TcpPolicy },
NicChanged {
nic: String,
admin_up: bool,
carrier: bool,
},
Fault {
addr: Option<SocketAddr>,
fault: Fault,
},
UnmodelledOption {
socket: crate::SocketId,
local: Option<SocketAddr>,
option: crate::UnmodelledOption,
refused: bool,
},
Signal {
signal: crate::Signal,
origin: crate::SignalOrigin,
delivery: crate::SignalDelivery,
},
}
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub enum Fault {
Error { errno: i32, call: &'static str },
ConnectRefused,
ConnectTimedOut,
ConnectDelayed { until: Duration },
IcmpPortUnreachable { from: SocketAddr },
Stalled {
span: Duration,
direction: Direction,
},
LinkDown { nic: String },
Unreachable { errno: i32 },
Dns {
name: String,
failure: crate::DnsFailure,
},
}
struct Log {
next_seq: u64,
last_at: Duration,
entries: Vec<RecordedEntry>,
}
pub(crate) struct EventLog {
log: Mutex<Log>,
enabled: AtomicBool,
}
impl EventLog {
pub(crate) fn new() -> Self {
EventLog {
log: Mutex::new(Log {
next_seq: 0,
last_at: Duration::ZERO,
entries: Vec::new(),
}),
enabled: AtomicBool::new(true),
}
}
pub(crate) fn set_enabled(&self, on: bool) {
self.enabled.store(on, Ordering::Relaxed);
}
pub(crate) fn enabled(&self) -> bool {
self.enabled.load(Ordering::Relaxed)
}
pub(crate) fn push(&self, stamp: impl FnOnce() -> Duration, event: RecordedEvent) {
snare_interpose::real(|| {
let mut log = self.log.lock().unwrap_or_else(|e| e.into_inner());
let at = stamp().max(log.last_at);
let seq = log.next_seq;
log.next_seq += 1;
log.last_at = at;
log.entries.push(RecordedEntry { at, seq, event });
});
}
pub(crate) fn snapshot(&self) -> Vec<RecordedEntry> {
snare_interpose::real(|| {
self.log
.lock()
.unwrap_or_else(|e| e.into_inner())
.entries
.clone()
})
}
pub(crate) fn clear(&self) {
snare_interpose::real(|| {
self.log
.lock()
.unwrap_or_else(|e| e.into_inner())
.entries
.clear()
});
}
}
#[track_caller]
pub fn recorded_events() -> Vec<RecordedEntry> {
let shared = crate::scope::here();
shared.settle_links();
shared.events.snapshot()
}
#[track_caller]
pub fn clear_recorded_events() {
crate::scope::here().events.clear();
}