use super::*;
pub type CorrelationId = u64;
#[derive(Debug)]
pub struct RequestBody(Frame);
impl RequestBody {
pub fn new(body: Vec<u8>) -> Result<Self, CallError> {
Frame::build(
FrameType::Request,
Flags::new(false, Priority::Interactive, false),
0,
0,
0,
body,
)
.map(Self)
.map_err(CallError::from)
}
}
#[must_use = "dropping a reservation releases it without sending"]
pub struct RequestReservation {
writer: mpsc::OwnedPermit<WriteCommand>,
key: PendingKey,
reply: PendingReply,
}
impl RequestReservation {
pub fn correlation_id(&self) -> CorrelationId {
self.key.corr
}
pub fn send(self, body: RequestBody, opts: CallOptions) -> (CorrelationId, PendingReply) {
let mut frame = body.0;
frame.header.channel = self.key.channel;
frame.header.epoch = self.key.epoch;
frame.header.corr = self.key.corr;
frame.header.flags =
Flags::new(false, opts.priority, false).with_admission_class(opts.admission_class);
self.writer.send(WriteCommand {
frame,
pending: Some(self.key),
});
(self.key.corr, self.reply)
}
}
#[must_use = "the reply must be awaited to observe the request outcome"]
pub struct PendingReply {
future: Pin<Box<dyn Future<Output = Result<Vec<u8>, CallError>> + Send>>,
}
impl Future for PendingReply {
type Output = Result<Vec<u8>, CallError>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
self.future.as_mut().poll(cx)
}
}
impl SubcConsumer {
pub async fn reserve(
&self,
route: &RouteHandle,
deadline: Instant,
) -> Result<RequestReservation, CallError> {
let state = self.shared.route_state(*route)?;
let permit = state.acquire(false, deadline, None).await?;
let writer = self
.shared
.lock_inner()
.writer
.clone()
.ok_or_else(|| CallError::not_sent("subc connection is down before send"))?;
let writer = match timeout_at(deadline, writer.reserve_owned()).await {
Ok(Ok(writer)) => writer,
Ok(Err(_)) => return Err(CallError::not_sent("writer task closed before reservation")),
Err(_) => {
return Err(CallError::not_sent_with_cause(
"call deadline elapsed waiting for writer capacity",
NotSentCause::WriterCapacity,
));
}
};
if Instant::now() >= deadline {
return Err(CallError::not_sent(
"call deadline elapsed before request was sent",
));
}
let (tx, rx) = oneshot::channel();
let (key, _) = self
.shared
.allocate_request(Some(*route), route.channel, route.epoch)?;
{
let mut inner = self.shared.lock_inner();
if inner.closed || inner.generation != key.generation || inner.writer.is_none() {
return Err(CallError::not_sent(
"connection changed before request registration",
));
}
if inner.route_epochs.get(&route.channel) != Some(route)
|| inner.retired_routes.contains(route)
{
return Err(CallError::StaleRouteHandle(*route));
}
let mut entry = PendingEntry::unary(tx, false, None, None);
entry.send_deadline = Some(deadline);
inner.pending.insert(key, entry);
if state.opted_in {
inner.wire_slots.insert(key, Arc::clone(&permit));
}
}
let registration = PendingRegistration::new(Arc::clone(&self.shared), key, false);
let shared = Arc::clone(&self.shared);
let reply = PendingReply {
future: Box::pin(async move {
let _permit = permit;
match shared.wait_for_reply(registration, rx, deadline).await? {
TerminalFrame::Response { body, .. } => Ok(body),
TerminalFrame::StreamEnd => Ok(Vec::new()),
TerminalFrame::Error { body, flags }
if error_codes::is_route_busy_retryable(
flags,
&body.code,
state.opted_in,
) =>
{
Err(busy_error(&body))
}
TerminalFrame::Error { body, .. } => Err(CallError::Module(body)),
}
}),
};
Ok(RequestReservation { writer, key, reply })
}
}