use super::{Capacity, ViewerSession, viewer_render_capability};
use crate::stream_emit::{FRAME_REMAINDER_TIMEOUT, TimeoutRead, is_stream_timeout};
use indicatrix_net::{
framing::{FramingError, IDLE_READ_TIMEOUT, LEN_PREFIX_BYTES, MAX_CONTROL_FRAME_LEN},
messages::{ClientMessage, NetError, RenderCapability, StreamEvent},
};
use std::{
io::{Read, Write},
sync::{Arc, mpsc},
time::{Duration, Instant},
};
const IDLE_POLL: Duration = Duration::from_millis(250);
pub struct CapabilityWatch {
changes: mpsc::Receiver<Capacity>,
registry: Arc<super::Registry>,
own: Option<RenderCapability>,
advertised: Option<RenderCapability>,
holds_assets: bool,
}
impl CapabilityWatch {
#[must_use]
pub fn new(session: &ViewerSession) -> Option<Self> {
let registry = Arc::clone(session.coordinator.registry()?);
Some(Self {
changes: registry.subscribe(),
registry,
own: session.own_capability.clone(),
advertised: session.advertised.clone(),
holds_assets: session.coordinator.assets().is_some(),
})
}
pub fn flush<S: Write>(&mut self, stream: &mut S) -> Result<(), NetError> {
let mut changed = false;
while self.changes.try_recv().is_ok() {
changed = true;
}
if !changed {
return Ok(());
}
let render = viewer_render_capability(
self.own.as_ref(),
Some(self.registry.capacity()),
self.holds_assets,
);
if render == self.advertised {
return Ok(());
}
tracing::debug!("coordinator: telling a viewer its render capability is now {render:?}");
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::CapabilityChanged {
render: render.clone(),
},
None,
)?;
self.advertised = render;
Ok(())
}
}
pub fn read_message_watching<S: Read + Write + TimeoutRead>(
stream: &mut S,
watch: &mut CapabilityWatch,
) -> Result<Option<ClientMessage>, NetError> {
let result = read_watching(stream, watch);
let _ = stream.set_read_timeout(None);
result
}
fn read_watching<S: Read + Write + TimeoutRead>(
stream: &mut S,
watch: &mut CapabilityWatch,
) -> Result<Option<ClientMessage>, NetError> {
let io = |e: std::io::Error| NetError::Framing(FramingError::Io(e));
stream.set_read_timeout(Some(IDLE_POLL)).map_err(io)?;
let waiting_since = Instant::now();
let mut len_bytes = [0u8; LEN_PREFIX_BYTES];
let first = loop {
watch.flush(stream)?;
if waiting_since.elapsed() >= IDLE_READ_TIMEOUT {
return Err(io(std::io::Error::new(
std::io::ErrorKind::TimedOut,
"idle timeout: the viewer sent no message",
)));
}
match stream.read(&mut len_bytes) {
Ok(0) => return Ok(None),
Ok(n) => break n,
Err(e) if is_stream_timeout(&e) => {}
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {}
Err(e) => return Err(io(e)),
}
};
stream
.set_read_timeout(Some(FRAME_REMAINDER_TIMEOUT))
.map_err(io)?;
let payload = indicatrix_net::framing::read_frame_continuing(
stream,
&len_bytes[..first],
MAX_CONTROL_FRAME_LEN,
)?;
Ok(Some(indicatrix_net::messages::decode_control_frame(
&payload,
)?))
}