use super::super::{TimeoutCache, TimeoutRead};
use indicatrix_net::messages::{ClientMessage, ContributionHeader, NetError, RenderRequest};
use std::{io::Read, time::Duration};
pub(in crate::stream_emit) enum ClientPoll {
Pending,
Cancelled,
Stale,
Closed,
NextRequest(Box<RenderRequest>),
Ping(u64),
Contribution(ContributionHeader),
}
pub enum RawPoll {
Pending,
Closed,
Message(ClientMessage),
}
pub fn poll_raw_client_message<S: Read + TimeoutRead>(
stream: &mut S,
poll_timeout: Duration,
timeouts: &mut TimeoutCache,
) -> Result<RawPoll, NetError> {
timeouts
.apply(stream, Some(poll_timeout))
.map_err(|e| NetError::Framing(indicatrix_net::framing::FramingError::Io(e)))?;
let mut len_bytes = [0u8; indicatrix_net::framing::LEN_PREFIX_BYTES];
let n = match stream.read(&mut len_bytes) {
Ok(0) => return Ok(RawPoll::Closed),
Ok(n) => n,
Err(e) if super::super::is_stream_timeout(&e) => {
return Ok(RawPoll::Pending);
}
Err(e) => {
return Err(NetError::Framing(
indicatrix_net::framing::FramingError::Io(e),
));
}
};
timeouts
.apply(stream, Some(super::super::FRAME_REMAINDER_TIMEOUT))
.map_err(|e| NetError::Framing(indicatrix_net::framing::FramingError::Io(e)))?;
let payload = indicatrix_net::framing::read_frame_continuing(
stream,
&len_bytes[..n],
indicatrix_net::framing::MAX_CONTROL_FRAME_LEN,
)?;
Ok(RawPoll::Message(
indicatrix_net::messages::decode_control_frame(&payload)?,
))
}
pub(in crate::stream_emit) fn poll_for_client_message<S: Read + TimeoutRead>(
stream: &mut S,
request_id: u32,
poll_timeout: Duration,
timeouts: &mut TimeoutCache,
) -> Result<ClientPoll, NetError> {
let msg = match poll_raw_client_message(stream, poll_timeout, timeouts)? {
RawPoll::Pending => return Ok(ClientPoll::Pending),
RawPoll::Closed => return Ok(ClientPoll::Closed),
RawPoll::Message(msg) => msg,
};
Ok(match msg {
ClientMessage::Cancel(cancel) if cancel.request_id == request_id => ClientPoll::Cancelled,
ClientMessage::Cancel(_) => ClientPoll::Stale,
ClientMessage::RenderRequest(next) => ClientPoll::NextRequest(next),
ClientMessage::Library(_) => {
tracing::debug!(
"received a LibraryRequest while request_id={request_id} was streaming -- library requests \
are not serviced mid-stream in this phase; ignoring"
);
ClientPoll::Stale
}
ClientMessage::TiltCurvesRequest(_) => {
tracing::debug!(
"received a TiltCurvesRequest while request_id={request_id} was streaming -- \
TILT_CURVES is not serviced mid-stream in this phase; ignoring"
);
ClientPoll::Stale
}
ClientMessage::Ping { nonce } => ClientPoll::Ping(nonce),
ClientMessage::FinalImageRequest(_) => {
tracing::debug!(
"received a FinalImageRequest while request_id={request_id} was streaming -- \
not supported by this server; ignoring"
);
ClientPoll::Stale
}
ClientMessage::Asset(header) => {
crate::assets::discard_asset(stream, &header)?;
ClientPoll::Stale
}
ClientMessage::Contribution(header) => ClientPoll::Contribution(header),
})
}