use crate::{
Capabilities, Message,
session::lock,
transport::{
Answer, Completion, Event, Events, Prepared, PreparedBody, QuestionId, Socket, Transfer,
Transport, WsEvent, WsEvents,
},
};
use std::{
collections::VecDeque,
sync::{Arc, Mutex, OnceLock},
time::Duration,
};
pub(crate) fn now() -> Duration {
#[cfg(not(target_arch = "wasm32"))]
{
static START: OnceLock<std::time::Instant> = OnceLock::new();
START.get_or_init(std::time::Instant::now).elapsed()
}
#[cfg(target_arch = "wasm32")]
{
Duration::from_secs_f64(crate::bridge::simulation_now() / 1000.0)
}
}
#[derive(Clone, Debug, Default)]
pub struct Statistics {
pub started: u64,
pub active: u64,
pub completed: u64,
pub failed: u64,
pub uploaded_bytes: u64,
pub downloaded_bytes: u64,
pub simulated_uploaded_bytes: u64,
pub simulated_downloaded_bytes: u64,
pub elapsed: Duration,
}
impl Statistics {
#[must_use]
pub fn upload_bytes_per_second(&self) -> f64 {
self.uploaded_bytes as f64 / self.elapsed.as_secs_f64().max(0.001)
}
#[must_use]
pub fn download_bytes_per_second(&self) -> f64 {
self.downloaded_bytes as f64 / self.elapsed.as_secs_f64().max(0.001)
}
#[must_use]
pub fn total_bytes(&self) -> u64 {
self.uploaded_bytes + self.downloaded_bytes
}
#[must_use]
pub fn global() -> Self {
global().snapshot()
}
}
#[derive(Clone, Debug)]
pub struct TransferStatistics {
pub id: u64,
pub method: String,
pub url: String,
pub simulated: bool,
pub statistics: Statistics,
pub error: Option<String>,
}
struct State {
start: Duration,
totals: Statistics,
history: VecDeque<Arc<Mutex<Record>>>,
}
struct Record {
start: Duration,
value: TransferStatistics,
ended: bool,
}
pub(crate) struct Store(Mutex<State>);
impl Default for Store {
fn default() -> Self {
Self(Mutex::new(State {
start: now(),
totals: Statistics::default(),
history: VecDeque::new(),
}))
}
}
fn global() -> &'static Arc<Store> {
static STORE: OnceLock<Arc<Store>> = OnceLock::new();
STORE.get_or_init(|| Arc::new(Store::default()))
}
impl Store {
pub fn snapshot(&self) -> Statistics {
let s = lock(&self.0);
let mut t = s.totals.clone();
t.elapsed = now().saturating_sub(s.start);
t
}
pub fn transfers(&self) -> Vec<TransferStatistics> {
let records = lock(&self.0).history.iter().cloned().collect::<Vec<_>>();
records
.into_iter()
.map(|r| {
let r = lock(&r);
let mut v = r.value.clone();
if !r.ended {
v.statistics.elapsed = now().saturating_sub(r.start);
}
v
})
.collect()
}
}
struct Meter {
record: Arc<Mutex<Record>>,
stores: [Arc<Store>; 2],
}
impl Meter {
fn new(store: Arc<Store>, req: &Prepared, simulated: bool) -> Arc<Self> {
static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
let record = Arc::new(Mutex::new(Record {
start: now(),
ended: false,
value: TransferStatistics {
id: NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
method: req.method.clone(),
url: req.url.clone(),
simulated,
statistics: Statistics {
started: 1,
active: 1,
..Default::default()
},
error: None,
},
}));
let stores = [store, global().clone()];
for s in &stores {
let mut st = lock(&s.0);
st.totals.started += 1;
st.totals.active += 1;
st.history.push_back(record.clone());
if st.history.len() > 256 {
st.history.pop_front();
}
}
Arc::new(Self { record, stores })
}
fn bytes(&self, upload: u64, download: u64) {
self.add_bytes(&mut lock(&self.record), upload, download);
}
fn add_bytes(&self, r: &mut Record, upload: u64, download: u64) {
fn add(s: &mut Statistics, u: u64, d: u64, sim: bool) {
s.uploaded_bytes += u;
s.downloaded_bytes += d;
if sim {
s.simulated_uploaded_bytes += u;
s.simulated_downloaded_bytes += d;
}
}
if r.ended {
return;
}
let sim = r.value.simulated;
add(&mut r.value.statistics, upload, download, sim);
for store in &self.stores {
add(&mut lock(&store.0).totals, upload, download, sim);
}
}
fn uploaded(&self, total: u64) {
let mut r = lock(&self.record);
let delta = total.saturating_sub(r.value.statistics.uploaded_bytes);
self.add_bytes(&mut r, delta, 0);
}
fn end(&self, error: Option<String>) {
fn finish(s: &mut Statistics, failed: bool) {
s.active = s.active.saturating_sub(1);
if failed {
s.failed += 1;
} else {
s.completed += 1;
}
}
let mut r = lock(&self.record);
if r.ended {
return;
}
r.ended = true;
r.value.statistics.elapsed = now().saturating_sub(r.start);
let failed = error.is_some();
r.value.error = error;
finish(&mut r.value.statistics, failed);
for store in &self.stores {
finish(&mut lock(&store.0).totals, failed);
}
}
}
struct Observed {
inner: Arc<dyn Transport>,
store: Arc<Store>,
simulated: bool,
}
pub(crate) fn observe(
inner: Arc<dyn Transport>,
store: Arc<Store>,
simulated: bool,
) -> Arc<dyn Transport> {
Arc::new(Observed {
inner,
store,
simulated,
})
}
impl Transport for Observed {
fn capabilities(&self) -> Capabilities {
self.inner.capabilities()
}
fn start(&self, req: Prepared, events: Events) -> Arc<dyn Transfer> {
let meter = Meter::new(self.store.clone(), &req, self.simulated);
let m = meter.clone();
let fallback_upload = if self.inner.capabilities().upload_progress {
0
} else {
match &req.body {
PreparedBody::Empty => 0,
PreparedBody::Bytes(bytes) => bytes.len() as u64,
PreparedBody::File { len, .. } => *len,
PreparedBody::Stream { len, .. } => len.unwrap_or(0),
}
};
let inner = self.inner.start(
req,
Arc::new(move |e| {
match &e {
Event::Head(_) => m.uploaded(fallback_upload),
Event::Chunk(b) => m.bytes(0, b.len() as u64),
Event::Sent { sent, .. } => m.uploaded(*sent),
Event::End => m.end(None),
Event::Failed(e) => m.end(Some(e.to_string())),
_ => {}
}
events(e);
}),
);
Arc::new(ObservedTransfer { inner, meter })
}
fn websocket(&self, req: Prepared, events: WsEvents) -> Arc<dyn Socket> {
let meter = Meter::new(self.store.clone(), &req, self.simulated);
let m = meter.clone();
let inner = self.inner.websocket(
req,
Arc::new(move |e| {
match &e {
WsEvent::Message(msg) => m.bytes(0, message_len(msg)),
WsEvent::Closed { .. } => m.end(None),
WsEvent::Failed(e) => m.end(Some(e.to_string())),
WsEvent::Open { .. } => {}
}
events(e);
}),
);
Arc::new(ObservedSocket { inner, meter })
}
fn cookies(&self) -> Vec<crate::Cookie> {
self.inner.cookies()
}
fn clear_cookies(&self) {
self.inner.clear_cookies();
}
fn clear_cache(&self) {
self.inner.clear_cache();
}
}
struct ObservedTransfer {
inner: Arc<dyn Transfer>,
meter: Arc<Meter>,
}
impl Transfer for ObservedTransfer {
fn demand(&self, n: u32) {
self.inner.demand(n);
}
fn answer(&self, id: QuestionId, a: Answer) {
self.inner.answer(id, a);
}
fn cancel(&self) {
self.meter.end(Some("cancelled".into()));
self.inner.cancel();
}
}
struct ObservedSocket {
inner: Arc<dyn Socket>,
meter: Arc<Meter>,
}
pub(crate) fn message_len(m: &Message) -> u64 {
match m {
Message::Text(t) => t.len() as u64,
Message::Binary(b) => b.len() as u64,
Message::Close { .. } => 0,
}
}
impl Socket for ObservedSocket {
fn send(&self, m: Message, done: Completion) {
let n = message_len(&m);
let meter = self.meter.clone();
self.inner.send(
m,
Box::new(move |r| {
if r.is_ok() {
meter.bytes(n, 0);
}
done(r);
}),
);
}
fn ping(&self, done: Completion) {
self.inner.ping(done);
}
fn close(&self, code: u16, reason: &str) {
self.meter.end(None);
self.inner.close(code, reason);
}
fn demand(&self, n: u32) {
self.inner.demand(n);
}
}