use crate::{
Response,
body::{
Incoming,
pipe::{self, Consumer, Producer, TakeError},
},
error::{Error, ErrorKind},
upgrade::{OnUpgrade, UpgradeSlot},
};
use karmaio::runtime::CancellationSource;
use std::{
cell::{Cell, RefCell},
future::poll_fn,
rc::Rc,
task::{Poll, Waker},
};
pub(crate) struct Control {
pub(crate) upload: CancellationSource,
pub(crate) exchange: CancellationSource,
pub(crate) upload_complete: Cell<bool>,
pub(crate) aborted: Cell<bool>,
continue_allowed: Cell<bool>,
continue_waker: RefCell<Option<Waker>>,
}
struct ContinueWait<'a>(&'a RefCell<Option<Waker>>);
impl Drop for ContinueWait<'_> {
fn drop(&mut self) {
self.0.borrow_mut().take();
}
}
#[derive(Clone)]
pub struct UploadControl {
pub(crate) inner: Rc<Control>,
}
impl Control {
pub(crate) fn allow_continue(&self) {
self.continue_allowed.set(true);
let waker = self.continue_waker.borrow_mut().take();
if let Some(waker) = waker {
waker.wake();
}
}
pub(crate) async fn wait_continue(&self) {
let _guard = ContinueWait(&self.continue_waker);
poll_fn(|cx| {
if self.continue_allowed.get() {
Poll::Ready(())
} else {
self.continue_waker.borrow_mut().replace(cx.waker().clone());
Poll::Pending
}
})
.await
}
pub(crate) fn cancel(&self) {
self.exchange.cancel();
self.upload.cancel();
}
}
impl UploadControl {
pub fn abort(&self) {
if !self.inner.upload_complete.get() {
self.inner.aborted.set(true);
self.inner.upload.cancel();
}
}
}
#[derive(Debug)]
pub enum ResponseEvent {
Informational(Response<()>),
Final(Response<Incoming>),
}
#[must_use = "dropping a pending response abandons the exchange"]
pub struct PendingResponse {
receiver: Consumer<ResponseEvent, Error>,
control: UploadControl,
delivered: bool,
finished: bool,
upgrade: UpgradeSlot,
}
impl PendingResponse {
pub fn control(&self) -> UploadControl {
self.control.clone()
}
pub fn on_upgrade<R: 'static, W: 'static>(&mut self) -> OnUpgrade<R, W> {
self.upgrade.claim()
}
pub async fn next_event(&mut self) -> Result<Option<ResponseEvent>, Error> {
if self.finished {
return Ok(None);
}
match self.receiver.take().await {
Ok(Some(event)) => {
if matches!(event, ResponseEvent::Final(_)) {
self.delivered = true;
self.finished = true;
}
Ok(Some(event))
}
Err(TakeError::Failed(error)) => {
self.finished = true;
Err(error)
}
_ => {
self.finished = true;
Err(Error::new(ErrorKind::Closed, "response driver closed"))
}
}
}
pub async fn response(mut self) -> Result<Response<Incoming>, Error> {
while let Some(event) = self.next_event().await? {
if let ResponseEvent::Final(response) = event {
return Ok(response);
}
}
Err(Error::new(ErrorKind::Closed, "final response already consumed"))
}
pub async fn response_with_upgrade<R: 'static, W: 'static>(
mut self,
) -> Result<(Response<Incoming>, OnUpgrade<R, W>), Error> {
let upgrade = self.on_upgrade();
while let Some(event) = self.next_event().await? {
if let ResponseEvent::Final(response) = event {
return Ok((response, upgrade));
}
}
Err(Error::new(ErrorKind::Closed, "final response already consumed"))
}
}
impl Drop for PendingResponse {
fn drop(&mut self) {
if !self.delivered {
self.control.inner.cancel();
}
}
}
pub(crate) fn channel(upgrade: UpgradeSlot) -> (Producer<ResponseEvent, Error>, PendingResponse, Rc<Control>) {
let (sender, receiver) = pipe::channel();
let control = Rc::new(Control {
upload: CancellationSource::new(),
exchange: CancellationSource::new(),
upload_complete: Cell::new(false),
aborted: Cell::new(false),
continue_allowed: Cell::new(false),
continue_waker: RefCell::new(None),
});
(
sender,
PendingResponse {
receiver,
control: UploadControl { inner: control.clone() },
delivered: false,
finished: false,
upgrade,
},
control,
)
}