use crate::telemetry::{TelemetryReader, telemetry_channel};
use crate::twin::{LiveReplay, TwinFrame, TwinReceiverStatus, TwinStatus, TwinWorker};
use crate::{
CaptureArchive, CuStreamRx, FiniteObjectLimits, SessionEvent, SessionRouter,
SessionRouterLimits, StreamIdentity,
};
use cu29_traits::{CuError, CuResult};
use std::marker::PhantomData;
use std::num::NonZeroUsize;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
const REPLAY_CAPACITY: NonZeroUsize = NonZeroUsize::new(32).unwrap();
const FRAME_CAPACITY: NonZeroUsize = NonZeroUsize::new(64).unwrap();
const SLAB_BYTES: usize = 16 * 1024 * 1024;
const SECTION_BYTES: usize = 65536;
const POLL_INTERVAL: Duration = Duration::from_millis(1);
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum CuTwinRecordingState {
#[default]
Waiting,
Recording,
Closed,
Failed,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct CuTwinStatus {
pub latest: Option<u64>,
pub recovery_point: Option<u64>,
pub gaps: usize,
pub packets: usize,
pub archived: u64,
pub structured_logs: u64,
pub identity: Option<StreamIdentity>,
pub last_packet: Option<Instant>,
pub state: CuTwinRecordingState,
pub twin: TwinStatus,
pub feedback_reports_sent: u64,
pub feedback_reports_dropped: u64,
pub feedback_failed: bool,
}
impl TwinReceiverStatus for CuTwinStatus {
fn with_twin(mut self, status: TwinStatus) -> Self {
self.twin = status;
self
}
}
pub struct CuTwinBuilder<A, R> {
rx: R,
feedback_tx: Option<Box<dyn crate::CuFeedbackTx>>,
log_base: Option<PathBuf>,
frame_capacity: NonZeroUsize,
reconstruct: bool,
app: PhantomData<fn() -> A>,
}
impl<A: LiveReplay, R: CuStreamRx + 'static> CuTwinBuilder<A, R> {
pub fn with_feedback<T: crate::CuFeedbackTx + 'static>(mut self, tx: T) -> Self {
self.feedback_tx = Some(Box::new(tx));
self
}
pub fn with_log_path(mut self, path: impl AsRef<Path>) -> Self {
self.log_base = Some(path.as_ref().to_path_buf());
self
}
pub fn with_frame_capacity(mut self, capacity: NonZeroUsize) -> Self {
self.frame_capacity = capacity;
self
}
pub fn archive_only(mut self) -> Self {
self.reconstruct = false;
self
}
pub fn spawn(self) -> CuResult<(CuTwin<A>, CuTwinReader<A>)> {
let path = self
.log_base
.ok_or_else(|| CuError::from("Copper twin requires a log path"))?;
if cu29_runtime::replay::first_slab_path(&path)?.exists() || path.exists() {
return Err(CuError::from(
"Copper twin archive already exists; choose a fresh log path",
));
}
if let Some(parent) = path
.parent()
.filter(|parent| !parent.as_os_str().is_empty())
{
std::fs::create_dir_all(parent)
.map_err(|e| CuError::new_with_cause("Create twin log directory", e))?;
}
let (publisher, reader) = telemetry_channel(self.frame_capacity, CuTwinStatus::default());
let (mut log_publisher, log_reader) = telemetry_channel(FRAME_CAPACITY, ());
let stop = Arc::new(AtomicBool::new(false));
let stopping = stop.clone();
let (ready_tx, ready_rx) = std::sync::mpsc::sync_channel(1);
let worker = thread::Builder::new()
.name("copper-twin-receiver".into())
.spawn(move || {
let mut status = CuTwinStatus::default();
let (replay, mut publisher) = if self.reconstruct {
match TwinWorker::spawn::<A>(REPLAY_CAPACITY, publisher) {
Ok(replay) => (Some(replay), None),
Err(error) => {
let _ = ready_tx.send(Err(error.clone()));
return Err(error);
}
}
} else {
(None, Some(publisher))
};
let mut publish_status = |status| {
if let Some(replay) = &replay {
replay.set_status(status);
}
if let Some(publisher) = &mut publisher {
publisher.set_status(status);
}
};
let mut archive = None;
let result = (|| {
let mut router = SessionRouter::<1128, 64, 64>::new(SessionRouterLimits {
max_sessions: 1,
max_startup_packets: 64,
max_recovery_records: 8,
max_pending_events: 64,
max_record_bytes: 4096,
max_buffered_records: 64,
equation_capacity: 64,
finite_objects: FiniteObjectLimits::new(65536, 1128, 4),
})
.map_err(stream_error)?;
let _ = ready_tx.send(Ok(()));
let mut rx = self.rx;
let mut feedback_tx = self.feedback_tx;
let feedback_clock = cu29_clock::RobotClock::new();
let receiver_id = crate::new_session_id();
let mut reporter = None;
let mut feedback_packet = [0; crate::feedback::FEEDBACK_BUFFER_BYTES];
let mut packet = [0; 1200];
while !stopping.load(Ordering::Acquire) {
if let Some(len) = rx
.try_recv(&mut packet)
.map_err(|e| CuError::from(format!("Twin receive: {e:?}")))?
{
let bytes = packet.get(..len).ok_or_else(|| {
CuError::from("Transport returned an invalid packet length")
})?;
status.last_packet = Some(Instant::now());
router
.receive_datagram(bytes, |event| {
if matches!(&event, SessionEvent::Object { record, .. } if record.decoded().kind != crate::RecordKind::StructuredLog) {
return Ok(());
}
if let SessionEvent::Manifest(manifest) = &event {
status.identity = Some(manifest.manifest().identity);
if feedback_tx.is_some() {
reporter = crate::feedback::FeedbackReporter::new(
manifest.manifest(),
receiver_id,
feedback_clock.now(),
);
}
archive = Some(CaptureArchive::<A::DataSet>::new(
&path,
manifest,
SLAB_BYTES,
SECTION_BYTES,
)?);
}
let writer =
archive.as_mut().ok_or(crate::Error::InvalidConfig(
"capture arrived before its manifest",
))?;
let capture = writer.accept(&event)?;
if let Some(entry) = writer.take_structured_log() {
status.structured_logs += 1;
if let SessionEvent::Object { identity, record } = &event {
log_publisher.publish(ReceivedStructuredLog {
identity: *identity, sequence: record.decoded().object_id, entry,
});
}
}
if let Some(capture) = &capture {
status.latest = Some(capture.copperlist.id);
status.archived += 1;
status.state = CuTwinRecordingState::Recording;
}
if let Some(replay) = &replay {
replay.accept(&event, capture)?;
}
match event {
SessionEvent::Gap { .. } => status.gaps += 1,
SessionEvent::VerifiedRecoveryPoint {
recovery_point,
..
} => {
status.recovery_point =
Some(recovery_point.copperlist_id)
}
_ => {}
}
Ok::<(), crate::Error>(())
})
.map_err(|e| CuError::from(format!("Twin receive: {e:?}")))?;
status.packets = router.stats().datagrams_seen;
publish_status(status);
} else {
thread::park_timeout(POLL_INTERVAL);
}
if let (Some(reporter), Some(tx), Some(identity)) =
(&mut reporter, &mut feedback_tx, status.identity)
&& let Some(mut counters) = router.feedback_counters(identity)
{
counters.latest_copperlist = status.latest;
if let Some(report) = reporter.report(feedback_clock.now(), counters) {
let len = report
.encode_into(&mut feedback_packet)
.map_err(stream_error)?;
match tx.try_send_feedback(&feedback_packet[..len]) {
Ok(()) => status.feedback_reports_sent += 1,
Err(crate::CuStreamTxError::WouldBlock) => {
status.feedback_reports_dropped += 1
}
Err(crate::CuStreamTxError::Failed(_)) => {
feedback_tx = None;
status.feedback_failed = true;
}
}
publish_status(status);
}
}
}
if let Some(archive) = archive.take() {
archive.finish().map_err(stream_error)?;
}
Ok(())
})();
status.state = if result.is_ok() {
CuTwinRecordingState::Closed
} else {
CuTwinRecordingState::Failed
};
publish_status(status);
if let Some(replay) = replay {
status.twin = replay.finish()?;
}
result.map(|()| status)
})
.map_err(|e| CuError::new_with_cause("Start Copper twin", e))?;
if let Err(error) = ready_rx
.recv()
.map_err(|_| CuError::from("Copper twin initialization failed"))
.and_then(|ready| ready)
{
stop.store(true, Ordering::Release);
let _ = worker.join();
return Err(error);
}
Ok((
CuTwin {
stop,
worker: Some(worker),
final_status: None,
log_reader: Some(log_reader),
app: PhantomData,
},
reader,
))
}
}
fn stream_error(error: crate::Error) -> CuError {
CuError::from(error.to_string())
}
pub type CuTwinReader<A> = TelemetryReader<TwinFrame<<A as LiveReplay>::DataSet>, CuTwinStatus>;
#[derive(Debug)]
pub struct ReceivedStructuredLog {
pub identity: StreamIdentity,
pub sequence: u64,
pub entry: cu29_log::CuLogEntry,
}
pub type CuTwinLogReader = TelemetryReader<ReceivedStructuredLog, ()>;
pub struct CuTwin<A: LiveReplay> {
stop: Arc<AtomicBool>,
worker: Option<JoinHandle<CuResult<CuTwinStatus>>>,
final_status: Option<CuTwinStatus>,
log_reader: Option<CuTwinLogReader>,
app: PhantomData<fn() -> A>,
}
impl<A: LiveReplay> CuTwin<A> {
pub fn builder<R: CuStreamRx + 'static>(rx: R) -> CuTwinBuilder<A, R> {
CuTwinBuilder {
rx,
feedback_tx: None,
log_base: None,
frame_capacity: FRAME_CAPACITY,
reconstruct: true,
app: PhantomData,
}
}
pub fn take_log_reader(&mut self) -> Option<CuTwinLogReader> {
self.log_reader.take()
}
pub fn stop(&mut self) -> CuResult<CuTwinStatus> {
self.stop.store(true, Ordering::Release);
if let Some(worker) = self.worker.take() {
worker.thread().unpark();
self.final_status = Some(
worker
.join()
.map_err(|_| CuError::from("Copper twin receiver panicked"))??,
);
}
self.final_status
.ok_or_else(|| CuError::from("Copper twin stopped after a worker failure"))
}
}
impl<A: LiveReplay> Drop for CuTwin<A> {
fn drop(&mut self) {
let _ = self.stop();
}
}