use std::collections::VecDeque;
pub use subc_protocol::{
session::OperatorConfirmRequest, BindIdentity, Frame, FrameType, RouteTarget,
};
use super::{stand_in, *};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OperatorAnswer {
Confirmed,
Refused {
refusal: OperatorRefusal,
reason: String,
},
UnknownOp,
NoAnswer,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OperatorRefusal {
Declined,
PresenceUnavailable,
SummaryInvalid,
NotPermitted,
}
impl OperatorRefusal {
pub fn code(self) -> &'static str {
match self {
Self::Declined => error_codes::OPERATOR_DECLINED,
Self::PresenceUnavailable => error_codes::OPERATOR_PRESENCE_UNAVAILABLE,
Self::SummaryInvalid => error_codes::OPERATOR_SUMMARY_INVALID,
Self::NotPermitted => error_codes::OPERATOR_REQUEST_NOT_PERMITTED,
}
}
}
impl OperatorAnswer {
fn frame(self, corr: u64) -> Option<Frame> {
let (ty, body) = match self {
Self::Confirmed => (
FrameType::Response,
serde_json::to_vec(&OperatorConfirmReply::confirmed()).unwrap(),
),
Self::Refused { refusal, reason } => (
FrameType::Error,
serde_json::to_vec(
&ErrorBody::new(refusal.code(), "operator confirmation refused")
.with_detail(serde_json::json!({"reason": reason})),
)
.unwrap(),
),
Self::UnknownOp => (
FrameType::Error,
serde_json::to_vec(&ErrorBody::new(
"unsupported_control_frame",
"unknown module control operation: operator.confirm",
))
.unwrap(),
),
Self::NoAnswer => return None,
};
Some(Frame::build(ty, control_flags(), 0, 0, corr, body).unwrap())
}
}
pub struct ModuleHarness {
served: stand_in::Served,
answers: VecDeque<OperatorAnswer>,
observed: Vec<Frame>,
next_corr: u64,
}
impl ModuleHarness {
pub async fn start<H: ModuleHandler>(
make_handler: impl FnOnce(ModuleHandle) -> H,
answers: impl IntoIterator<Item = OperatorAnswer>,
) -> Self {
Self {
served: stand_in::serve_against_stand_in_with_ops(make_handler, &[OPERATOR_CONFIRM_OP])
.await,
answers: answers.into_iter().collect(),
observed: Vec::new(),
next_corr: HELLO_CORR + 1,
}
}
pub async fn bind_route(&mut self, request: RouteBindRequest) -> RouteHandle {
assert_ne!(request.handle.channel, 0, "route channel must be nonzero");
let route = self
.served
.handle
.route_handle(request.handle.channel, request.handle.epoch);
let body = ModuleControlRequest::RouteBind {
route_channel: route.channel,
epoch: route.epoch,
target: request.target,
identity: request.identity,
principal: request.principal,
consumer_capabilities: request.consumer_capabilities,
role_versions: request.role_versions,
admission_facts: request.admission_facts,
scope: request.scope,
call_mode: Some(request.call_mode),
};
let corr = self.allocate_corr();
self.send(
Frame::build(
FrameType::Request,
control_flags(),
0,
0,
corr,
serde_json::to_vec(&body).unwrap(),
)
.unwrap(),
)
.await;
let reply = self.read_terminal(0, 0, corr).await;
assert_eq!(
reply.header.ty,
FrameType::Response,
"route.bind refused: {reply:?}"
);
route
}
pub async fn send_request(&mut self, route: RouteHandle, body: Vec<u8>) -> u64 {
self.assert_own_route(route);
let corr = self.allocate_corr();
self.send(
Frame::build(
FrameType::Request,
data_flags(),
route.channel,
route.epoch,
corr,
body,
)
.unwrap(),
)
.await;
corr
}
pub async fn read_reply(&mut self, route: RouteHandle, corr: u64) -> Frame {
self.assert_own_route(route);
self.read_terminal(route.channel, route.epoch, corr).await
}
pub async fn cancel_request(&mut self, route: RouteHandle, corr: u64) {
self.assert_own_route(route);
self.send(
Frame::build(
FrameType::Cancel,
data_flags(),
route.channel,
route.epoch,
corr,
Vec::new(),
)
.unwrap(),
)
.await;
}
pub async fn next_frame(&mut self) -> Option<Frame> {
let frame = read_frame(&mut self.served.daemon).await.unwrap()?;
self.observed.push(frame.clone());
if frame.header.channel == 0
&& frame.header.ty == FrameType::Request
&& serde_json::from_slice::<OperatorConfirmRequest>(&frame.body).is_ok()
{
let answer = self
.answers
.pop_front()
.expect("operator.confirm script exhausted");
if let Some(reply) = answer.frame(frame.header.corr) {
self.send(reply).await;
}
}
Some(frame)
}
pub fn observed_frames(&self) -> &[Frame] {
&self.observed
}
pub fn confirm_requests(&self) -> impl Iterator<Item = (u64, OperatorConfirmRequest)> + '_ {
self.observed.iter().filter_map(|frame| {
if frame.header.channel == 0 && frame.header.ty == FrameType::Request {
serde_json::from_slice(&frame.body)
.ok()
.map(|request| (frame.header.corr, request))
} else {
None
}
})
}
pub async fn shutdown(&mut self) {
self.send(Frame::build(FrameType::Goodbye, control_flags(), 0, 0, 0, Vec::new()).unwrap())
.await;
while self.next_frame().await.is_some() {}
(&mut self.served.serve).await.unwrap().unwrap();
}
fn allocate_corr(&mut self) -> u64 {
let corr = self.next_corr;
self.next_corr = corr.checked_add(1).expect("test correlation exhausted");
corr
}
fn assert_own_route(&self, route: RouteHandle) {
assert_eq!(
route.connection_token(),
self.served.handle.shared.connection_token,
"route belongs to another connection"
);
}
async fn send(&mut self, frame: Frame) {
write_frame(&mut self.served.daemon, &frame).await.unwrap();
self.served.daemon.flush().await.unwrap();
}
async fn read_terminal(&mut self, channel: u16, epoch: u32, corr: u64) -> Frame {
let matches = |frame: &Frame| {
frame.header.channel == channel
&& frame.header.epoch == epoch
&& frame.header.corr == corr
&& matches!(
frame.header.ty,
FrameType::Response | FrameType::Error | FrameType::StreamEnd
)
};
if let Some(frame) = self.observed.iter().find(|frame| matches(frame)) {
return frame.clone();
}
loop {
let frame = self
.next_frame()
.await
.expect("connection ended before reply");
if matches(&frame) {
return frame;
}
}
}
}
impl Drop for ModuleHarness {
fn drop(&mut self) {
self.served.handle.close_connection();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn scripted_refusals_keep_the_exact_code_and_detail_reason() {
for (refusal, code) in [
(OperatorRefusal::Declined, "operator_declined"),
(
OperatorRefusal::PresenceUnavailable,
"operator_presence_unavailable",
),
(OperatorRefusal::SummaryInvalid, "operator_summary_invalid"),
(
OperatorRefusal::NotPermitted,
"operator_request_not_permitted",
),
] {
let frame = OperatorAnswer::Refused {
refusal,
reason: "audit reason".into(),
}
.frame(42)
.unwrap();
assert_eq!(frame.header.ty, FrameType::Error);
assert_eq!(
(frame.header.channel, frame.header.epoch, frame.header.corr),
(0, 0, 42)
);
let body: serde_json::Value = serde_json::from_slice(&frame.body).unwrap();
assert_eq!(body["code"], code);
assert_eq!(body["detail"]["reason"], "audit reason");
}
}
}