use super::*;
async fn close(
consumer: &SubcConsumer,
handle: RouteHandle,
by_handle: bool,
opts: CloseRouteOptions,
) {
if by_handle {
consumer.close_handle(&handle, opts).await.unwrap();
} else {
consumer
.close_route(restart_target("teardown"), restart_identity(), opts)
.await;
}
}
async fn assert_closed_once(
shared: &Arc<Shared>,
consumer: &SubcConsumer,
rx: &mut mpsc::Receiver<WriteCommand>,
route: &RouteState,
) {
tokio::time::timeout(Duration::from_secs(1), async {
while shared
.lock_inner()
.route_epochs
.contains_key(&route.handle.channel)
{
tokio::task::yield_now().await;
}
})
.await
.expect("cancelled close must queue GOODBYE and uninstall the handle");
assert!(route.sem.is_closed());
{
let inner = shared.lock_inner();
assert!(!inner.retired_routes.contains(&route.handle));
assert!(!inner.retirement_goodbyes.contains(&route.handle));
assert!(!inner.retirement_queue.contains(&route.handle));
}
tokio::time::timeout(
Duration::from_secs(1),
assert_reopened_request_after_goodbye(shared, consumer, rx, route.handle),
)
.await
.expect("GOODBYE must precede the reopened request");
assert!(
rx.try_recv().is_err(),
"close must not queue a second GOODBYE"
);
}
async fn cancel_during_writer_wait(by_handle: bool) {
let (shared, consumer, mut rx, _peer, key, route) = route_teardown_stand_in();
let mut preceding = route.clone();
preceding.handle = RouteHandle::new(route.handle.channel + 1, 31, 1);
let preceding_key = RouteKey::new(
&restart_target("preceding"),
&restart_identity(),
None,
None,
);
shared
.lock_inner()
.cache_route(preceding_key.clone(), preceding.clone());
shared.invalidate_route_with_deadline(&preceding_key, Some(preceding.handle), true);
let mut closing = Box::pin(close(
&consumer,
route.handle,
by_handle,
CloseRouteOptions::default(),
));
assert_pending(closing.as_mut()).await;
assert!(!shared.lock_inner().routes.contains_key(&key));
drop(closing);
assert_eq!(
shared.lock_inner().route_epochs.get(&route.handle.channel),
Some(&route.handle),
"the channel stays occupied while GOODBYE waits for writer capacity"
);
assert_eq!(rx.recv().await.unwrap().frame.body, b"filler");
let goodbye = tokio::time::timeout(Duration::from_secs(1), rx.recv())
.await
.unwrap()
.unwrap()
.frame;
assert_eq!(goodbye.header.ty, FrameType::Goodbye);
assert_eq!(
(goodbye.header.channel, goodbye.header.epoch),
(preceding.handle.channel, preceding.handle.epoch),
"cancelled closes must not overtake earlier retirement GOODBYEs"
);
assert_closed_once(&shared, &consumer, &mut rx, &route).await;
consumer.close().await;
}
async fn cancel_during_drain(by_handle: bool) {
let (shared, consumer, mut rx, _peer, key, route) = route_teardown_stand_in();
assert_eq!(rx.recv().await.unwrap().frame.body, b"filler");
let mut request = Box::pin(consumer.request(
&route.handle,
b"unanswered".to_vec(),
CallOptions::default(),
));
assert_pending(request.as_mut()).await;
let command = rx.recv().await.unwrap();
assert_eq!(command.frame.header.ty, FrameType::Request);
assert!(shared.mark_pending_accepted(command.pending.unwrap()));
let mut closing = Box::pin(close(
&consumer,
route.handle,
by_handle,
CloseRouteOptions {
drain: true,
..CloseRouteOptions::default()
},
));
assert_pending(closing.as_mut()).await;
assert!(!shared.lock_inner().routes.contains_key(&key));
assert!(!route.sem.is_closed(), "drain has not finished yet");
drop(closing);
assert!(route.sem.is_closed(), "cancellation must give up the drain");
let error = request.await.unwrap_err();
assert_eq!(error.close_reason(), Some(&RouteEndReason::ClosedByCaller));
assert_eq!(error.outcome_cause(), Some(OutcomeUnknownCause::RouteEnded));
assert!(shared.lock_inner().pending.is_empty());
assert!(shared.lock_inner().wire_slots.is_empty());
assert_closed_once(&shared, &consumer, &mut rx, &route).await;
consumer.close().await;
}
async fn cancel_when_writer_becomes_ready(by_handle: bool) {
for complete in [false, true] {
let (shared, consumer, mut rx, _peer, _key, route) = route_teardown_stand_in();
let mut closing = Box::pin(close(
&consumer,
route.handle,
by_handle,
CloseRouteOptions::default(),
));
assert_pending(closing.as_mut()).await;
assert_eq!(rx.recv().await.unwrap().frame.body, b"filler");
if complete {
closing.as_mut().await;
}
drop(closing);
assert_closed_once(&shared, &consumer, &mut rx, &route).await;
consumer.close().await;
}
}
#[tokio::test]
async fn route_close_cancel_route_during_writer_wait() {
cancel_during_writer_wait(false).await;
}
#[tokio::test]
async fn route_close_cancel_handle_during_writer_wait() {
cancel_during_writer_wait(true).await;
}
#[tokio::test]
async fn route_close_cancel_route_during_drain() {
cancel_during_drain(false).await;
}
#[tokio::test]
async fn route_close_cancel_handle_during_drain() {
cancel_during_drain(true).await;
}
#[tokio::test]
async fn route_close_cancel_route_when_writer_becomes_ready() {
cancel_when_writer_becomes_ready(false).await;
}
#[tokio::test]
async fn route_close_cancel_handle_when_writer_becomes_ready() {
cancel_when_writer_becomes_ready(true).await;
}
#[tokio::test]
async fn route_closed_terminal_survives_goodbye_for_sent_and_unsent_calls() {
for terminal in [Some(true), Some(false), None] {
for accepted in [false, true] {
for channels in [true, false] {
for reason in [RouteCloseReason::Restart, RouteCloseReason::Reload] {
let (shared, consumer, mut rx, _peer, _key, route) = route_teardown_stand_in();
rx.recv().await.unwrap();
shared
.lock_inner()
.route_modules
.insert(route.handle.channel, "provider".into());
let mut request = Box::pin(consumer.request(
&route.handle,
b"unanswered".to_vec(),
CallOptions::default(),
));
assert_pending(request.as_mut()).await;
let command = rx.recv().await.unwrap();
if accepted {
assert!(shared.mark_pending_accepted(command.pending.unwrap()));
}
let wire_reason = match reason {
RouteCloseReason::Restart => "restart",
RouteCloseReason::Reload => "reload",
_ => unreachable!(),
};
let mut body = serde_json::json!({
"op": "route.closed",
"module_id": "provider",
"reason": wire_reason,
});
if let Some(terminal) = terminal {
body["terminal"] = serde_json::json!(terminal);
}
if channels {
body["channels"] = serde_json::json!([route.handle.channel]);
}
let push = Frame::build(
FrameType::Push,
Flags(0),
0,
0,
0,
serde_json::to_vec(&body).unwrap(),
)
.unwrap();
dispatch_frame(&shared, 1, push).await;
let goodbye = Frame::build(
FrameType::Goodbye,
Flags(0),
route.handle.channel,
route.handle.epoch,
0,
vec![],
)
.unwrap();
dispatch_frame(&shared, 1, goodbye).await;
let error = request.await.unwrap_err();
assert_eq!(error.terminal(), terminal);
assert_eq!(
error.close_reason(),
Some(&RouteEndReason::Daemon(reason.clone()))
);
assert_eq!(
error.outcome_cause(),
accepted.then_some(OutcomeUnknownCause::RouteEnded)
);
assert_eq!(
error.not_sent_cause(),
(!accepted).then_some(NotSentCause::WriterRejected)
);
assert_eq!(reason.disposition(), RouteCloseDisposition::MayReopen);
consumer.close().await;
}
}
}
}
}