use super::message::{
InvokeRequest, ReadRequest, StatusResponse, SubscribeRequest, TimedRequest, WriteRequest,
opcode,
};
use super::server::{AccessControl, ClusterHandler, InteractionContext, ReadCursor, Server};
use super::status::Status;
use super::timed::TimedWindows;
use crate::error::Result;
use crate::msg::{ExchangeId, SessionId};
#[derive(Debug, Clone, Copy)]
pub struct Request<'a> {
pub opcode: u8,
pub payload: &'a [u8],
pub session: Option<SessionId>,
pub exchange: ExchangeId,
pub groupcast: bool,
}
impl<'a> Request<'a> {
#[must_use]
pub const fn new(
opcode: u8,
payload: &'a [u8],
session: SessionId,
exchange: ExchangeId,
) -> Self {
Self {
opcode,
payload,
session: Some(session),
exchange,
groupcast: false,
}
}
#[must_use]
pub const fn groupcast(mut self) -> Self {
self.groupcast = true;
self
}
}
#[derive(Debug)]
pub enum Served<'a> {
Reply {
opcode: u8,
len: usize,
more_chunks: bool,
},
Subscribe(SubscribeRequest<'a>),
Silent,
Unhandled {
opcode: u8,
},
}
#[derive(Debug)]
pub struct Dispatcher<const W: usize> {
timed: TimedWindows<W>,
max_paths_per_invoke: u16,
}
impl<const W: usize> Dispatcher<W> {
#[must_use]
pub const fn new(max_paths_per_invoke: u16) -> Self {
Self {
timed: TimedWindows::new(),
max_paths_per_invoke: if max_paths_per_invoke == 0 {
1
} else {
max_paths_per_invoke
},
}
}
pub const fn timed(&mut self) -> &mut TimedWindows<W> {
&mut self.timed
}
pub fn dispatch<'a, A: AccessControl, H: ClusterHandler>(
&mut self,
server: &Server<'_, A, H>,
request: Request<'a>,
ctx: &InteractionContext<'_>,
cursor: &mut ReadCursor,
scratch: &mut [u8],
buf: &mut [u8],
) -> Result<Served<'a>> {
match request.opcode {
opcode::READ_REQUEST => self.read(server, request, ctx, cursor, scratch, buf),
opcode::WRITE_REQUEST => self.write(server, request, ctx, buf),
opcode::INVOKE_REQUEST => self.invoke(server, request, ctx, scratch, buf),
opcode::TIMED_REQUEST => self.timed_request(request, ctx, buf),
opcode::SUBSCRIBE_REQUEST => {
let subscribe = SubscribeRequest::decode(request.payload)?;
if let Some(paths) = subscribe.attribute_paths()? {
for path in paths {
if !path?.is_valid_for_read() {
return status_reply(Status::InvalidAction, buf);
}
}
}
if subscribe.min_interval_floor_s > subscribe.max_interval_ceiling_s {
return status_reply(Status::InvalidAction, buf);
}
let has_events = subscribe
.event_paths()?
.is_some_and(|mut paths| paths.next().is_some());
let has_attributes = match subscribe.attribute_paths()? {
Some(paths) => server.any_readable(paths)?,
None => false,
};
if !has_attributes && !has_events {
return status_reply(Status::InvalidAction, buf);
}
Ok(Served::Subscribe(subscribe))
}
other => Ok(Served::Unhandled { opcode: other }),
}
}
fn read<'a, A: AccessControl, H: ClusterHandler>(
&mut self,
server: &Server<'_, A, H>,
request: Request<'a>,
ctx: &InteractionContext<'_>,
cursor: &mut ReadCursor,
scratch: &mut [u8],
buf: &mut [u8],
) -> Result<Served<'a>> {
let read = ReadRequest::decode(request.payload)?;
let mut ctx = *ctx;
ctx.timed = false;
ctx.fabric_filtered = read.fabric_filtered;
ctx.data_version_filters = read.data_version_filters_raw();
ctx.event_filters = read.event_filters_raw();
if let Some(paths) = read.attribute_paths()? {
for path in paths {
if !path?.is_valid_for_read() {
return status_reply(Status::InvalidAction, buf);
}
}
}
let paths = read.attribute_paths()?;
let events = read.event_paths()?;
let (bytes, outcome) = server.serve_chunk_with_events(
paths.into_iter().flatten(),
events.into_iter().flatten(),
&ctx,
None,
cursor,
scratch,
buf,
)?;
Ok(Served::Reply {
opcode: opcode::REPORT_DATA,
len: bytes.len(),
more_chunks: outcome.truncated,
})
}
fn write<'a, A: AccessControl, H: ClusterHandler>(
&mut self,
server: &Server<'_, A, H>,
request: Request<'a>,
ctx: &InteractionContext<'_>,
buf: &mut [u8],
) -> Result<Served<'a>> {
let write = WriteRequest::decode(request.payload)?;
let timed = match self.timed.check(
request.session,
request.exchange,
write.timed_request,
ctx.now,
) {
Ok(timed) => timed,
Err(status) => return status_reply(status, buf),
};
let mut ctx = *ctx;
ctx.timed = timed;
let writes = write.writes()?;
let (bytes, _) = server.serve_write(writes, &ctx, write.more_chunked_messages, buf)?;
let len = bytes.len();
if request.groupcast || write.suppress_response {
return Ok(Served::Silent);
}
Ok(Served::Reply {
opcode: opcode::WRITE_RESPONSE,
len,
more_chunks: false,
})
}
fn invoke<'a, A: AccessControl, H: ClusterHandler>(
&mut self,
server: &Server<'_, A, H>,
request: Request<'a>,
ctx: &InteractionContext<'_>,
scratch: &mut [u8],
buf: &mut [u8],
) -> Result<Served<'a>> {
let invoke = InvokeRequest::decode(request.payload)?;
let timed = match self.timed.check(
request.session,
request.exchange,
invoke.timed_request,
ctx.now,
) {
Ok(timed) => timed,
Err(status) => return status_reply(status, buf),
};
let mut commands = 0usize;
for command in invoke.commands()? {
if command.is_err() {
break;
}
commands = commands.saturating_add(1);
if commands > usize::from(self.max_paths_per_invoke) {
return status_reply(Status::InvalidAction, buf);
}
}
let mut ctx = *ctx;
ctx.timed = timed;
let (bytes, _) = server.serve_invoke(
invoke.commands()?,
&ctx,
invoke.suppress_response,
scratch,
buf,
)?;
if request.groupcast {
return Ok(Served::Silent);
}
Ok(Served::Reply {
opcode: opcode::INVOKE_RESPONSE,
len: bytes.len(),
more_chunks: false,
})
}
fn timed_request<'a>(
&mut self,
request: Request<'a>,
ctx: &InteractionContext<'_>,
buf: &mut [u8],
) -> Result<Served<'a>> {
let timed = TimedRequest::decode(request.payload)?;
if self
.timed
.open(request.session, request.exchange, timed.timeout_ms, ctx.now)
.is_err()
{
return status_reply(Status::Busy, buf);
}
status_reply(Status::Success, buf)
}
}
fn status_reply<'a>(status: Status, buf: &mut [u8]) -> Result<Served<'a>> {
let bytes = StatusResponse::new(status).encode(buf)?;
Ok(Served::Reply {
opcode: opcode::STATUS_RESPONSE,
len: bytes.len(),
more_chunks: false,
})
}