use std::panic::{AssertUnwindSafe, catch_unwind};
use std::rc::Rc;
use std::sync::{Arc, Mutex, OnceLock};
use rustduck_sys::bridge::{self as sys_bridge, ffi};
use crate::buffer::{decode_utf16, encode_utf16};
use crate::error::native_exception;
use crate::{Error, Result};
#[repr(i32)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
#[non_exhaustive]
pub enum Severity {
Fatal = -5,
Severe = -4,
Error = -3,
Warning = -2,
Info = -1,
Verbose = 0,
Debug = 1,
}
impl Severity {
const fn abi_value(self) -> i32 {
self as i32
}
fn from_i32(value: i32) -> Option<Self> {
match value {
-5 => Some(Self::Fatal),
-4 => Some(Self::Severe),
-3 => Some(Self::Error),
-2 => Some(Self::Warning),
-1 => Some(Self::Info),
0 => Some(Self::Verbose),
1 => Some(Self::Debug),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AsyncReportConfig {
pub severity: Severity,
pub synchronous_log: bool,
pub timed_log: bool,
pub log_message_count: usize,
}
impl Default for AsyncReportConfig {
fn default() -> Self {
Self {
severity: Severity::Info,
synchronous_log: false,
timed_log: false,
log_message_count: 512,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ReportForwarderError {
InvalidMessage,
InvalidSeverity {
severity: i32,
},
Panic,
}
#[derive(Clone)]
pub struct ReportForwarder {
state: Arc<ReportForwarderState>,
}
type ReportForwarderCallback = dyn Fn(Severity, &str) + Send + Sync + 'static;
struct ReportForwarderState {
callback: Arc<ReportForwarderCallback>,
error: Mutex<Option<ReportForwarderError>>,
}
struct RegisteredReportForwarder {
state: Arc<ReportForwarderState>,
report_count: usize,
}
impl ReportForwarder {
pub fn new<F>(callback: F) -> Self
where
F: Fn(Severity, &str) + Send + Sync + 'static,
{
Self {
state: Arc::new(ReportForwarderState {
callback: Arc::new(callback),
error: Mutex::new(None),
}),
}
}
#[must_use]
pub fn take_error(&self) -> Option<ReportForwarderError> {
self.state
.error
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.take()
}
}
struct ActiveReportForwarder {
state: Arc<ReportForwarderState>,
}
impl Drop for ActiveReportForwarder {
fn drop(&mut self) {
let mut active = active_report_forwarder()
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
let Some(registered) = active.as_mut() else {
return;
};
if !Arc::ptr_eq(®istered.state, &self.state) {
return;
}
if registered.report_count == 1 {
*active = None;
} else {
registered.report_count -= 1;
}
}
}
fn active_report_forwarder() -> &'static Mutex<Option<RegisteredReportForwarder>> {
static ACTIVE: OnceLock<Mutex<Option<RegisteredReportForwarder>>> = OnceLock::new();
ACTIVE.get_or_init(|| Mutex::new(None))
}
fn acquire_report_forwarder(forwarder: &ReportForwarder) -> Result<ActiveReportForwarder> {
let mut active = active_report_forwarder()
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
match active.as_mut() {
None => {
*active = Some(RegisteredReportForwarder {
state: Arc::clone(&forwarder.state),
report_count: 1,
});
}
Some(registered) if Arc::ptr_eq(®istered.state, &forwarder.state) => {
registered.report_count += 1;
}
Some(_) => {
return Err(Error::InvalidState {
object: "ReportForwarder",
operation: "create a forwarding report",
state: "a different forwarder is active",
});
}
}
Ok(ActiveReportForwarder {
state: Arc::clone(&forwarder.state),
})
}
fn record_forwarder_error(state: &ReportForwarderState, error: ReportForwarderError) {
let mut recorded = state
.error
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
if recorded.is_none() {
*recorded = Some(error);
}
}
fn dispatch_report_forwarder(severity: i32, message: &[u8], message_valid: bool) {
let state = {
let active = active_report_forwarder()
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
active
.as_ref()
.map(|registered| Arc::clone(®istered.state))
};
let Some(state) = state else {
return;
};
if !message_valid {
record_forwarder_error(&state, ReportForwarderError::InvalidMessage);
return;
}
let Some(severity) = Severity::from_i32(severity) else {
record_forwarder_error(&state, ReportForwarderError::InvalidSeverity { severity });
return;
};
let Ok(message) = decode_utf16("ReportForwarder", message) else {
record_forwarder_error(&state, ReportForwarderError::InvalidMessage);
return;
};
if catch_unwind(AssertUnwindSafe(|| (state.callback)(severity, &message))).is_err() {
record_forwarder_error(&state, ReportForwarderError::Panic);
}
}
pub struct Report {
native: cxx::UniquePtr<RustDuckReport>,
_forwarder: Option<ActiveReportForwarder>,
asynchronous: bool,
terminated: bool,
}
type RustDuckReport = ffi::RustDuckReport;
impl Report {
fn from_native(
native: std::result::Result<cxx::UniquePtr<RustDuckReport>, cxx::Exception>,
asynchronous: bool,
forwarder: Option<ActiveReportForwarder>,
) -> Result<Rc<Self>> {
let native = native.map_err(|error| native_exception("Report::new", error))?;
if native.is_null() {
return Err(Error::NativeFailure {
operation: "Report::new",
});
}
Ok(Rc::new(Self {
native,
_forwarder: forwarder,
asynchronous,
terminated: false,
}))
}
pub fn null() -> Result<Rc<Self>> {
Self::from_native(ffi::rustduck_report_null(), false, None)
}
pub fn stderr() -> Result<Rc<Self>> {
Self::from_native(ffi::rustduck_report_stderr(), false, None)
}
pub fn asynchronous(config: AsyncReportConfig) -> Result<Rc<Self>> {
Self::from_native(
ffi::rustduck_report_asynchronous(
config.severity.abi_value(),
config.synchronous_log,
config.timed_log,
config.log_message_count,
),
true,
None,
)
}
pub fn asynchronous_with_forwarder(
config: AsyncReportConfig,
forwarder: ReportForwarder,
) -> Result<Rc<Self>> {
if config.timed_log {
return Err(Error::InvalidArgument {
field: "AsyncReportConfig::timed_log",
message: "TSDuck callback reports do not support timed logging".to_owned(),
});
}
if !sys_bridge::install_report_callback_dispatcher(dispatch_report_forwarder) {
return Err(Error::InvalidState {
object: "ReportForwarder",
operation: "install callback dispatcher",
state: "incompatible dispatcher installed",
});
}
let active = acquire_report_forwarder(&forwarder)?;
Self::from_native(
ffi::rustduck_report_asynchronous_with_forwarder(
config.severity.abi_value(),
config.synchronous_log,
config.log_message_count,
),
true,
Some(active),
)
}
pub fn set_max_severity(&mut self, severity: Severity) -> Result<()> {
self.ensure_active("set maximum severity")?;
ffi::rustduck_report_set_max_severity(self.native.pin_mut(), severity.abi_value())
.map_err(|error| native_exception("Report::set_max_severity", error))
}
pub fn log(&self, severity: Severity, message: &str) -> Result<()> {
self.ensure_active("log")?;
let message = encode_utf16(message);
ffi::rustduck_report_log(self.native(), severity.abi_value(), &message)
.map_err(|error| native_exception("Report::log", error))
}
pub fn terminate(&mut self) -> Result<()> {
if !self.asynchronous {
return Err(Error::InvalidState {
object: "Report",
operation: "terminate",
state: "static",
});
}
if self.terminated {
return Ok(());
}
ffi::rustduck_report_terminate(self.native.pin_mut())
.map_err(|error| native_exception("Report::terminate", error))?;
self.terminated = true;
self._forwarder.take();
Ok(())
}
fn ensure_active(&self, operation: &'static str) -> Result<()> {
if self.terminated {
return Err(Error::InvalidState {
object: "Report",
operation,
state: "terminated",
});
}
Ok(())
}
pub(crate) fn native(&self) -> &RustDuckReport {
self.native
.as_ref()
.expect("Report construction rejects null owners")
}
}
#[cfg(test)]
mod tests {
use super::*;
fn forwarder_test_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
LOCK.get_or_init(|| Mutex::new(()))
.lock()
.expect("forwarder test lock")
}
#[test]
fn severity_uses_stable_abi_values() {
assert_eq!(Severity::Error.abi_value(), -3);
assert_eq!(Severity::from_i32(42), None);
}
#[test]
fn rejects_timed_callback_reports_before_reserving_the_forwarder() {
let forwarder = ReportForwarder::new(|_, _| {});
assert!(matches!(
Report::asynchronous_with_forwarder(
AsyncReportConfig {
timed_log: true,
..AsyncReportConfig::default()
},
forwarder
),
Err(Error::InvalidArgument {
field: "AsyncReportConfig::timed_log",
..
})
));
}
#[test]
fn contains_forwarder_panics() {
let _lock = forwarder_test_lock();
let forwarder = ReportForwarder::new(|_, _| panic!("callback"));
let active = acquire_report_forwarder(&forwarder).expect("first forwarder");
dispatch_report_forwarder(Severity::Info.abi_value(), &[0xFF, 0xFE, b'x', 0], true);
assert_eq!(forwarder.take_error(), Some(ReportForwarderError::Panic));
drop(active);
}
#[test]
fn retains_the_first_callback_error() {
let _lock = forwarder_test_lock();
let forwarder = ReportForwarder::new(|_, _| {});
let active = acquire_report_forwarder(&forwarder).expect("first forwarder");
dispatch_report_forwarder(99, &[], true);
dispatch_report_forwarder(Severity::Info.abi_value(), &[0x01], true);
assert_eq!(
forwarder.take_error(),
Some(ReportForwarderError::InvalidSeverity { severity: 99 })
);
drop(active);
}
#[test]
fn permits_reports_sharing_one_forwarder() {
let _lock = forwarder_test_lock();
let forwarder = ReportForwarder::new(|_, _| {});
let first = acquire_report_forwarder(&forwarder).expect("first forwarder");
let second = acquire_report_forwarder(&forwarder).expect("shared forwarder");
drop(first);
let third = acquire_report_forwarder(&forwarder).expect("remaining shared forwarder");
drop(second);
drop(third);
}
#[test]
fn rejects_a_different_forwarder_while_one_is_active() {
let _lock = forwarder_test_lock();
let first = ReportForwarder::new(|_, _| {});
let second = ReportForwarder::new(|_, _| {});
let active = acquire_report_forwarder(&first).expect("first forwarder");
assert!(acquire_report_forwarder(&second).is_err());
drop(active);
}
}