use std::rc::Rc;
use std::sync::{Arc, Mutex};
use rustduck_sys::bridge::ffi;
use crate::error::native_exception;
use crate::host::{invalid_state, require_state};
use crate::memory::{MemoryInputBinding, MemoryOutputBinding, install_dispatcher};
use crate::{CallbackError, Error, HostState, MemoryInput, MemoryOutput, Report, Result};
mod config;
mod native_config;
pub use config::{ProcessorConfig, ProcessorInput, ProcessorOutput};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum WaitStatus {
Pending,
Stopped,
}
#[derive(Clone)]
pub struct AbortToken {
native: cxx::SharedPtr<ffi::RustDuckProcessorAbortToken>,
endpoints: Arc<Mutex<Option<AbortEndpoints>>>,
}
struct AbortEndpoints {
input: Option<Arc<MemoryInput>>,
output: Option<Arc<MemoryOutput>>,
}
unsafe impl Send for AbortToken {}
unsafe impl Sync for AbortToken {}
impl AbortToken {
pub fn request(&self) {
{
let endpoints = self
.endpoints
.lock()
.unwrap_or_else(|error| error.into_inner());
if let Some(endpoints) = endpoints.as_ref() {
if let Some(input) = &endpoints.input {
input.abort();
}
if let Some(output) = &endpoints.output {
output.abort();
}
}
}
if let Some(token) = self.native.as_ref() {
let _ = ffi::rustduck_processor_abort_token_request(token);
}
}
fn detach_endpoints(&self) {
self.endpoints
.lock()
.unwrap_or_else(|error| error.into_inner())
.take();
}
}
pub struct TSProcessor {
native: cxx::UniquePtr<ffi::RustDuckTSProcessor>,
report: Rc<Report>,
handler: Option<cxx::UniquePtr<ffi::RustDuckMemoryHandler>>,
input_binding: Option<MemoryInputBinding>,
output_binding: Option<MemoryOutputBinding>,
input: Option<Arc<MemoryInput>>,
output: Option<Arc<MemoryOutput>>,
abort_token: AbortToken,
native_shutdown_required: bool,
state: HostState,
}
impl TSProcessor {
pub fn new(report: Rc<Report>) -> Result<Self> {
let native = ffi::rustduck_processor_new(report.native())
.map_err(|error| native_exception("TSProcessor::new", error))?;
let Some(native_ref) = native.as_ref() else {
return Err(Error::NativeFailure {
operation: "TSProcessor::new",
});
};
let abort_token = AbortToken {
native: ffi::rustduck_processor_abort_token(native_ref),
endpoints: Arc::new(Mutex::new(None)),
};
Ok(Self {
native,
report,
handler: None,
input_binding: None,
output_binding: None,
input: None,
output: None,
abort_token,
native_shutdown_required: false,
state: HostState::Created,
})
}
pub fn report(&self) -> &Rc<Report> {
&self.report
}
pub const fn state(&self) -> HostState {
self.state
}
pub fn abort_token(&self) -> AbortToken {
self.abort_token.clone()
}
pub fn start(&mut self, config: &ProcessorConfig) -> Result<()> {
require_state("TSProcessor", "start", self.state, HostState::Created)?;
config::validate(config)?;
let input = config::memory_input(config);
let output = config::memory_output(config);
if input.is_some() || output.is_some() {
install_dispatcher()?;
}
let handler = if input.is_some() || output.is_some() {
let handler = ffi::rustduck_memory_handler_new()
.map_err(|error| native_exception("TSProcessor::memory_handler", error))?;
if handler.is_null() {
return Err(Error::NativeFailure {
operation: "TSProcessor::memory_handler",
});
}
Some(handler)
} else {
None
};
let input_binding = input.as_ref().map(|endpoint| endpoint.bind()).transpose()?;
let output_binding = output
.as_ref()
.map(|endpoint| endpoint.bind())
.transpose()?;
self.handler = handler;
self.input_binding = input_binding;
self.output_binding = output_binding;
self.input = input;
self.output = output;
*self
.abort_token
.endpoints
.lock()
.unwrap_or_else(|error| error.into_inner()) = Some(AbortEndpoints {
input: self.input.as_ref().map(Arc::clone),
output: self.output.as_ref().map(Arc::clone),
});
self.native_shutdown_required = true;
if let Err(error) = self.register_memory_handlers() {
self.fail_memory_endpoints();
self.state = HostState::Failed;
return Err(error);
}
let native_config = self.native_config(config)?;
let started = ffi::rustduck_processor_start(self.native.pin_mut(), &native_config)
.map_err(|error| self.fail_after_native_exception("TSProcessor::start", error))?;
if !started {
self.fail_memory_endpoints();
self.state = HostState::Failed;
return Err(Error::NativeFailure {
operation: "TSProcessor::start",
});
}
self.state = HostState::Running;
Ok(())
}
pub fn abort(&mut self) -> Result<()> {
require_state("TSProcessor", "abort", self.state, HostState::Running)?;
self.fail_memory_endpoints();
self.state = HostState::Stopping;
ffi::rustduck_processor_abort(self.native.pin_mut())
.map_err(|error| self.fail_after_native_exception("TSProcessor::abort", error))
}
pub fn try_wait(&mut self) -> Result<WaitStatus> {
if !self.state.is_active() {
return Err(invalid_state("TSProcessor", "try_wait", self.state));
}
let started = ffi::rustduck_processor_is_started(
self.native
.as_ref()
.expect("TSProcessor construction rejects null owners"),
)
.map_err(|error| self.fail_after_native_exception("TSProcessor::try_wait", error))?;
if started {
Ok(WaitStatus::Pending)
} else {
ffi::rustduck_processor_wait(self.native.pin_mut()).map_err(|error| {
self.fail_after_native_exception("TSProcessor::try_wait", error)
})?;
self.finish_wait();
Ok(WaitStatus::Stopped)
}
}
pub fn wait_for_termination(&mut self) -> Result<()> {
if !self.state.is_active() {
return Err(invalid_state(
"TSProcessor",
"wait_for_termination",
self.state,
));
}
ffi::rustduck_processor_wait(self.native.pin_mut()).map_err(|error| {
self.fail_after_native_exception("TSProcessor::wait_for_termination", error)
})?;
self.finish_wait();
Ok(())
}
pub fn take_memory_error(&self) -> Option<CallbackError> {
self.input
.as_ref()
.and_then(|endpoint| endpoint.take_callback_error())
.or_else(|| {
self.output
.as_ref()
.and_then(|endpoint| endpoint.take_callback_error())
})
}
fn finish_wait(&mut self) {
self.abort_token.detach_endpoints();
self.close_memory_outputs();
self.native_shutdown_required = false;
self.state = HostState::Stopped;
}
fn native_config(&self, config: &ProcessorConfig) -> Result<ffi::RustDuckProcessorConfig> {
native_config::build(
config,
self.input_binding.as_ref(),
self.output_binding.as_ref(),
)
}
fn register_memory_handlers(&mut self) -> Result<()> {
let Some(handler) = self.handler.as_ref() else {
return Ok(());
};
if self.input_binding.is_some() {
ffi::rustduck_processor_register_input(self.native.pin_mut(), handler)
.map_err(|error| native_exception("TSProcessor::register_input", error))?;
}
if self.output_binding.is_some() {
ffi::rustduck_processor_register_output(self.native.pin_mut(), handler)
.map_err(|error| native_exception("TSProcessor::register_output", error))?;
}
Ok(())
}
fn fail_after_native_exception(
&mut self,
operation: &'static str,
error: cxx::Exception,
) -> Error {
self.fail_memory_endpoints();
self.state = HostState::Failed;
native_exception(operation, error)
}
fn fail_memory_endpoints(&self) {
if let Some(endpoint) = &self.input {
endpoint.abort();
}
if let Some(endpoint) = &self.output {
endpoint.abort();
}
}
fn close_memory_outputs(&self) {
if let Some(endpoint) = &self.output {
endpoint.close();
}
}
}
impl Drop for TSProcessor {
fn drop(&mut self) {
self.abort_token.detach_endpoints();
if self.native_shutdown_required {
self.fail_memory_endpoints();
let _ = ffi::rustduck_processor_abort(self.native.pin_mut());
let _ = ffi::rustduck_processor_wait(self.native.pin_mut());
}
}
}
#[cfg(test)]
mod tests {
use std::num::NonZeroUsize;
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
use super::*;
use crate::{MemoryQueuePolicy, PluginOptions, TS_PACKET_SIZE};
fn assert_token_wakes_callback(
config: ProcessorConfig,
wait_for_callback: impl FnOnce() -> bool,
rescue: impl FnOnce(),
) {
let (token_sender, token_receiver) = mpsc::channel();
let (done_sender, done_receiver) = mpsc::channel();
let owner = thread::spawn(move || {
let mut processor =
TSProcessor::new(Report::stderr().expect("report")).expect("processor");
token_sender
.send(processor.abort_token())
.expect("send token");
let started = processor.start(&config);
if started.is_ok() {
processor
.wait_for_termination()
.expect("wait after cancellation");
}
drop(processor);
done_sender.send(()).expect("send owner completion");
});
let token = token_receiver
.recv_timeout(Duration::from_secs(5))
.expect("token");
let waiting = wait_for_callback();
let requester = thread::spawn(move || token.request());
let completed = done_receiver.recv_timeout(Duration::from_secs(2));
rescue();
requester.join().expect("requester join");
owner.join().expect("owner join");
assert!(waiting, "native callback must reach the queue wait");
assert!(
completed.is_ok(),
"token must wake the blocked native callback"
);
}
#[test]
fn abort_token_wakes_input_callbacks_during_start_and_processing() {
let _lock = crate::host::native_test_lock();
for initially_queued in [false, true] {
let input = MemoryInput::new(
NonZeroUsize::new(TS_PACKET_SIZE).expect("capacity"),
MemoryQueuePolicy::Backpressure,
)
.expect("input");
if initially_queued {
input.push(&[0x47; TS_PACKET_SIZE]).expect("initial packet");
}
assert_token_wakes_callback(
ProcessorConfig {
initial_input_packets: 1,
max_input_packets: 1,
input: Some(ProcessorInput::Memory(Arc::clone(&input))),
output: Some(ProcessorOutput::Native(PluginOptions::without_arguments(
"drop",
))),
..ProcessorConfig::default()
},
|| input.inner.wait_for_waiter(),
|| input.abort(),
);
}
}
#[test]
fn abort_token_wakes_backpressured_output_callback() {
let _lock = crate::host::native_test_lock();
let output = MemoryOutput::new(
NonZeroUsize::new(TS_PACKET_SIZE).expect("capacity"),
MemoryQueuePolicy::Backpressure,
)
.expect("output");
assert_token_wakes_callback(
ProcessorConfig {
max_output_packets: 1,
input: Some(ProcessorInput::Native(PluginOptions::new("null", ["3"]))),
output: Some(ProcessorOutput::Memory(Arc::clone(&output))),
..ProcessorConfig::default()
},
|| output.inner.wait_for_waiter(),
|| output.abort(),
);
}
#[test]
fn abort_token_preserves_draining_output_after_wait_and_owner_drop() {
let _lock = crate::host::native_test_lock();
let output = MemoryOutput::new(
NonZeroUsize::new(TS_PACKET_SIZE).expect("capacity"),
MemoryQueuePolicy::Backpressure,
)
.expect("output");
let mut processor = TSProcessor::new(Report::null().expect("report")).expect("processor");
let token = processor.abort_token();
processor
.start(&ProcessorConfig {
input: Some(ProcessorInput::Native(PluginOptions::new("null", ["1"]))),
output: Some(ProcessorOutput::Memory(Arc::clone(&output))),
..ProcessorConfig::default()
})
.expect("start");
processor.wait_for_termination().expect("wait");
token.request();
drop(processor);
token.request();
assert_eq!(
output.recv_shared().expect("drain").expect("packet").len(),
TS_PACKET_SIZE
);
assert_eq!(output.recv_shared().expect("EOF"), None);
}
#[test]
fn rejects_untyped_memory_plugin_before_native_state_changes() {
let _lock = crate::host::native_test_lock();
let report = Report::null().expect("report");
let mut processor = TSProcessor::new(report).expect("processor");
let config = ProcessorConfig {
input: Some(ProcessorInput::Native(PluginOptions::without_arguments(
"memory",
))),
..ProcessorConfig::default()
};
assert!(matches!(
processor.start(&config),
Err(Error::InvalidArgument { .. })
));
assert_eq!(processor.state(), HostState::Created);
}
#[test]
fn abort_token_is_send_and_sync_and_becomes_a_no_op_after_owner_drop() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<AbortToken>();
let token = {
let _lock = crate::host::native_test_lock();
let report = Report::null().expect("report");
let processor = TSProcessor::new(report).expect("processor");
processor.abort_token()
};
thread::spawn(move || token.request())
.join()
.expect("post-drop request must not access deleted native processor");
}
#[test]
fn failed_native_start_keeps_memory_lease_until_owner_drop() {
let _lock = crate::host::native_test_lock();
let report = Report::null().expect("report");
let input = MemoryInput::new(
NonZeroUsize::new(TS_PACKET_SIZE).expect("capacity"),
MemoryQueuePolicy::Drop,
)
.expect("input");
let mut processor = TSProcessor::new(report).expect("processor");
let config = ProcessorConfig {
input: Some(ProcessorInput::Memory(Arc::clone(&input))),
output: Some(ProcessorOutput::Native(PluginOptions::without_arguments(
"rustduck-definitely-not-a-plugin",
))),
..ProcessorConfig::default()
};
assert!(matches!(
processor.start(&config),
Err(Error::NativeFailure {
operation: "TSProcessor::start"
})
));
assert_eq!(processor.state(), HostState::Failed);
assert!(matches!(input.bind(), Err(Error::InvalidState { .. })));
drop(processor);
input.bind().expect("lease released after owner deletion");
}
}