repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-harness/src/http.rs
Raw//! Host-owned HTTP engine over the `smith::http` vocabulary (`SMH-SPEC-SPEC0001`, `SMH-SPEC-PLUG0001`).
//!
//! One executor serves provider traffic today and plugin net-scope
//! effects later; every call is bounded, cancellable, and recordable.
use serde_json::Value;
use smith::error::{ProviderFault, Result, SmithError};
use smith::http::{
HttpBodyEnd, HttpBodyItem, HttpChunk, HttpExchange, HttpExecutor, HttpExecutorRef, HttpHead,
HttpResponse,
};
use smith::tool::CancelHandle;
use std::io::Read;
use std::sync::Arc;
use std::sync::mpsc;
use std::time::{Duration, Instant};
use ureq::unversioned::resolver::DefaultResolver;
use ureq::unversioned::transport::{
Buffers, ConnectionDetails, Connector, DefaultConnector, NextTimeout, Transport,
};
const LIFECYCLE_RESPONSE_HEADER_BYTES_MAX: usize = 4096;
const CREDENTIAL_RESPONSE_BYTES_MAX: u64 = 128 * 1024;
const CREDENTIAL_CANCEL_CHECK: Duration = Duration::from_millis(50);
/// Credential effect outcome, independent of transport diagnostic strings.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum CredentialFault {
Cancelled,
Deadline,
Network,
ExchangeUncertain,
Rejected,
InvalidGrant,
}
/// Bounded, no-redirect client for host-owned credential mechanisms.
pub(crate) struct CredentialHttp;
impl CredentialHttp {
fn agent(cancel: &CancelHandle, timeout: Duration) -> ureq::Agent {
let config = ureq::Agent::config_builder()
.max_redirects(0)
.proxy(None)
.http_status_as_error(false)
.timeout_global(Some(timeout))
.timeout_connect(Some(timeout))
.timeout_recv_response(Some(timeout))
.build();
ureq::Agent::with_parts(
config,
DefaultConnector::default().chain(CancelTransport {
cancel: cancel.clone(),
}),
DefaultResolver::default(),
)
}
pub(crate) fn get(
url: &str,
deadline: Instant,
cancel: &CancelHandle,
) -> std::result::Result<Value, CredentialFault> {
let timeout = credential_timeout(deadline, cancel)?;
let response = Self::agent(cancel, timeout)
.get(url)
.call()
.map_err(|_| credential_error(cancel))?;
Self::response(response, cancel)
}
pub(crate) fn post(
url: &str,
body: &str,
deadline: Instant,
cancel: &CancelHandle,
) -> std::result::Result<Value, CredentialFault> {
Self::post_body(
url,
body,
"application/x-www-form-urlencoded",
deadline,
cancel,
)
}
pub(crate) fn post_json(
url: &str,
body: &Value,
deadline: Instant,
cancel: &CancelHandle,
) -> std::result::Result<Value, CredentialFault> {
let body = serde_json::to_string(body).map_err(|_| CredentialFault::Rejected)?;
Self::post_body(url, &body, "application/json", deadline, cancel)
}
fn post_body(
url: &str,
body: &str,
content_type: &str,
deadline: Instant,
cancel: &CancelHandle,
) -> std::result::Result<Value, CredentialFault> {
let timeout = credential_timeout(deadline, cancel)?;
let request = Self::agent(cancel, timeout)
.post(url)
.header("content-type", content_type);
let response = if content_type == "application/json" {
request.header("accept", "application/json").send(body)
} else {
request.send(body)
}
.map_err(|_| CredentialFault::ExchangeUncertain)?;
Self::response(response, cancel).map_err(|fault| match fault {
CredentialFault::Rejected | CredentialFault::InvalidGrant => fault,
_ => CredentialFault::ExchangeUncertain,
})
}
pub(crate) fn control(
url: &str,
body: Option<&Value>,
access: &str,
deadline: Instant,
cancel: &CancelHandle,
) -> std::result::Result<Value, CredentialFault> {
let timeout = credential_timeout(deadline, cancel)?;
let agent = Self::agent(cancel, timeout);
let authorization = format!("Bearer {access}");
let response = match body {
Some(body) => {
let body = serde_json::to_string(body).map_err(|_| CredentialFault::Rejected)?;
agent
.post(url)
.header("authorization", &authorization)
.header("content-type", "application/json")
.header("accept", "application/json")
.send(&body)
.map_err(|_| CredentialFault::ExchangeUncertain)?
}
None => agent
.get(url)
.header("authorization", &authorization)
.header("accept", "application/json")
.call()
.map_err(|_| credential_error(cancel))?,
};
Self::response(response, cancel)
}
pub(crate) fn revoke(
url: &str,
body: &str,
deadline: Instant,
cancel: &CancelHandle,
) -> std::result::Result<(), CredentialFault> {
let timeout = credential_timeout(deadline, cancel)?;
let response = Self::agent(cancel, timeout)
.post(url)
.header("content-type", "application/x-www-form-urlencoded")
.send(body)
.map_err(|_| CredentialFault::ExchangeUncertain)?;
if response.status().as_u16() == 200 {
Ok(())
} else {
Err(CredentialFault::Rejected)
}
}
fn response(
response: ureq::http::Response<ureq::Body>,
cancel: &CancelHandle,
) -> std::result::Result<Value, CredentialFault> {
let status = response.status().as_u16();
let mut bytes = Vec::new();
if cancel.is_cancelled() {
return Err(CredentialFault::Cancelled);
}
#[expect(
clippy::disallowed_methods,
reason = "Take caps credential response bytes before reporting overflow"
)]
response
.into_body()
.into_reader()
.take(CREDENTIAL_RESPONSE_BYTES_MAX + 1)
.read_to_end(&mut bytes)
.map_err(|_| credential_error(cancel))?;
if bytes.len() as u64 > CREDENTIAL_RESPONSE_BYTES_MAX {
return Err(CredentialFault::Network);
}
let value: Value = serde_json::from_slice(&bytes).map_err(|_| CredentialFault::Network)?;
if status != 200 {
return Err(
if status == 400 && value["error"].as_str() == Some("invalid_grant") {
CredentialFault::InvalidGrant
} else {
CredentialFault::Rejected
},
);
}
Ok(value)
}
}
fn credential_timeout(
deadline: Instant,
cancel: &CancelHandle,
) -> std::result::Result<Duration, CredentialFault> {
if cancel.is_cancelled() {
return Err(CredentialFault::Cancelled);
}
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
return Err(CredentialFault::Deadline);
}
Ok(remaining.min(Duration::from_secs(15)))
}
fn credential_error(cancel: &CancelHandle) -> CredentialFault {
if cancel.is_cancelled() {
CredentialFault::Cancelled
} else {
CredentialFault::Network
}
}
/// Adds cancellation checks to every credential transport wait.
#[derive(Debug)]
struct CancelTransport {
cancel: CancelHandle,
}
impl Connector<Box<dyn Transport>> for CancelTransport {
type Out = CancelledTransport;
fn connect(
&self,
_details: &ConnectionDetails,
chained: Option<Box<dyn Transport>>,
) -> std::result::Result<Option<Self::Out>, ureq::Error> {
if self.cancel.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"OAuth login cancelled",
)
.into());
}
Ok(chained.map(|inner| CancelledTransport {
inner,
cancel: self.cancel.clone(),
}))
}
}
#[derive(Debug)]
struct CancelledTransport {
inner: Box<dyn Transport>,
cancel: CancelHandle,
}
impl CancelledTransport {
fn check(&self, timeout: &NextTimeout) -> std::result::Result<NextTimeout, ureq::Error> {
if self.cancel.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"OAuth login cancelled",
)
.into());
}
Ok(NextTimeout {
after: timeout.after.min(CREDENTIAL_CANCEL_CHECK.into()),
reason: timeout.reason,
})
}
}
impl Transport for CancelledTransport {
fn buffers(&mut self) -> &mut dyn Buffers {
self.inner.buffers()
}
fn transmit_output(
&mut self,
amount: usize,
timeout: NextTimeout,
) -> std::result::Result<(), ureq::Error> {
self.inner.transmit_output(amount, self.check(&timeout)?)
}
fn await_input(&mut self, timeout: NextTimeout) -> std::result::Result<bool, ureq::Error> {
use ureq::unversioned::transport::time::Duration as TransportDuration;
let budget = match timeout.after {
TransportDuration::Exact(duration) => duration,
TransportDuration::NotHappening => Duration::from_secs(15),
};
let deadline = Instant::now() + budget;
loop {
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
return Err(ureq::Error::Timeout(timeout.reason));
}
let slice = self.check(&NextTimeout {
after: remaining.into(),
reason: timeout.reason,
})?;
match self.inner.await_input(slice) {
Err(ureq::Error::Timeout(_)) => {}
Err(ureq::Error::Io(error))
if matches!(
error.kind(),
std::io::ErrorKind::TimedOut | std::io::ErrorKind::WouldBlock
) => {}
result => return result,
}
}
}
fn is_open(&mut self) -> bool {
self.inner.is_open()
}
fn is_tls(&self) -> bool {
self.inner.is_tls()
}
}
/// Largest accepted response body, in bytes.
pub const BODY_BYTES_MAX: u64 = 64 * 1024 * 1024;
/// Largest accepted single request body, in bytes.
pub const REQUEST_BYTES_MAX: usize = 16 * 1024 * 1024;
/// Timeout for the response head.
pub const HEAD_TIMEOUT: Duration = Duration::from_secs(120);
/// Deadline for one chunk gap.
pub const CHUNK_TIMEOUT: Duration = Duration::from_secs(300);
/// The HTTP engine: `ureq`, blocking, pure Rust, no async runtime
/// (`SMH-SPEC-SPEC0001`, network transport).
#[derive(Clone)]
pub struct UreqHttpExecutor {
agent: ureq::Agent,
body_bytes_max: u64,
}
impl UreqHttpExecutor {
/// A default executor with [`HEAD_TIMEOUT`] and [`CHUNK_TIMEOUT`].
#[must_use]
pub fn new() -> Self {
Self::with_timeouts(HEAD_TIMEOUT, CHUNK_TIMEOUT)
}
/// An executor bounding the connect and the response head wait each by
/// `head`, and every single socket wait by `gap`.
#[must_use]
pub fn with_timeouts(head: Duration, gap: Duration) -> Self {
let config = ureq::Agent::config_builder()
.http_status_as_error(false)
.timeout_connect(Some(head))
.timeout_recv_response(Some(head))
.build();
Self::from_config(config, gap)
}
/// Inline lifecycle transport: no redirects/proxies, absolute request deadline,
/// bounded response headers/body and cancellable blocking socket waits.
pub(crate) fn lifecycle(timeout: Duration, cancel: &CancelHandle, body_bytes_max: u64) -> Self {
let config = ureq::Agent::config_builder()
.max_redirects(0)
.proxy(None)
.http_status_as_error(false)
.max_response_header_size(LIFECYCLE_RESPONSE_HEADER_BYTES_MAX)
.timeout_global(Some(timeout))
.timeout_connect(Some(timeout))
.timeout_recv_response(Some(timeout))
.build();
let connector = DefaultConnector::default().chain(CancelTransport {
cancel: cancel.clone(),
});
Self {
agent: ureq::Agent::with_parts(config, connector, DefaultResolver::default()),
body_bytes_max,
}
}
fn from_config(config: ureq::config::Config, gap: Duration) -> Self {
let connector = DefaultConnector::default().chain(GapTimeout(gap));
Self {
agent: ureq::Agent::with_parts(config, connector, DefaultResolver::default()),
body_bytes_max: BODY_BYTES_MAX,
}
}
}
impl Default for UreqHttpExecutor {
fn default() -> Self {
Self::new()
}
}
impl HttpExecutor for UreqHttpExecutor {
fn execute(&self, exchange: HttpExchange, cancel: CancelHandle) -> Result<HttpResponse> {
admit(&exchange, &cancel)?;
let response = match exchange.method {
smith::http::HttpMethod::Get => {
let mut prepared = self.agent.get(&exchange.url);
for header in &exchange.headers {
prepared = prepared.header(&header.name, &header.value);
}
prepared
.call()
.map_err(|error| transient(error.to_string()))?
}
smith::http::HttpMethod::Post => {
let mut prepared = self.agent.post(&exchange.url);
for header in &exchange.headers {
prepared = prepared.header(&header.name, &header.value);
}
prepared
.send(&exchange.body[..])
.map_err(|error| transient(error.to_string()))?
}
};
let head = HttpHead {
status: response.status().as_u16(),
};
Ok(stream_body_bounded(
head,
response.into_body().into_reader(),
cancel,
self.body_bytes_max,
))
}
}
/// Connector stage capping every socket wait at a gap duration, so a
/// stalled body fails per gap instead of per whole-body budget.
#[derive(Debug)]
struct GapTimeout(Duration);
impl Connector<Box<dyn Transport>> for GapTimeout {
type Out = GapTransport;
fn connect(
&self,
_details: &ConnectionDetails,
chained: Option<Box<dyn Transport>>,
) -> std::result::Result<Option<Self::Out>, ureq::Error> {
Ok(chained.map(|inner| GapTransport { inner, gap: self.0 }))
}
}
#[derive(Debug)]
struct GapTransport {
inner: Box<dyn Transport>,
gap: Duration,
}
impl GapTransport {
fn cap(&self, timeout: &NextTimeout) -> NextTimeout {
NextTimeout {
after: timeout.after.min(self.gap.into()),
reason: timeout.reason,
}
}
}
impl Transport for GapTransport {
fn buffers(&mut self) -> &mut dyn Buffers {
self.inner.buffers()
}
fn transmit_output(
&mut self,
amount: usize,
timeout: NextTimeout,
) -> std::result::Result<(), ureq::Error> {
let timeout = self.cap(&timeout);
self.inner.transmit_output(amount, timeout)
}
fn await_input(&mut self, timeout: NextTimeout) -> std::result::Result<bool, ureq::Error> {
let timeout = self.cap(&timeout);
self.inner.await_input(timeout)
}
fn is_open(&mut self) -> bool {
self.inner.is_open()
}
fn is_tls(&self) -> bool {
self.inner.is_tls()
}
}
/// Subscription traffic never follows redirects or inherits proxy authority from the environment.
pub(crate) fn subscription_executor() -> HttpExecutorRef {
let config = ureq::Agent::config_builder()
.max_redirects(0)
.proxy(None)
.http_status_as_error(false)
.timeout_connect(Some(HEAD_TIMEOUT))
.timeout_recv_response(Some(HEAD_TIMEOUT))
.build();
Arc::new(UreqHttpExecutor::from_config(config, CHUNK_TIMEOUT))
}
/// The shared default executor.
#[must_use]
pub fn default_executor() -> HttpExecutorRef {
Arc::new(UreqHttpExecutor::new())
}
fn admit(exchange: &HttpExchange, cancel: &CancelHandle) -> Result<()> {
if exchange.body.len() > REQUEST_BYTES_MAX {
return Err(transient(
"http effect: request body exceeds the size bound".to_string(),
));
}
if cancel.is_cancelled() {
return Err(SmithError::Cancelled);
}
Ok(())
}
/// Body chunks in flight before the reader thread blocks on the consumer.
const BODY_CHANNEL_CHUNKS: usize = 16;
/// Pump `body` into ordered items on a reader thread.
///
/// The body ends with [`HttpBodyEnd::Complete`] at end of body,
/// [`HttpBodyEnd::Failed`] on a read error or gap timeout,
/// [`HttpBodyEnd::Truncated`] past [`MAX_BODY_BYTES`], or
/// [`HttpBodyEnd::Cancelled`] once `cancel` fires; no chunk read after
/// cancellation is delivered.
fn stream_body_bounded(
head: HttpHead,
mut body: impl Read + Send + 'static,
cancel: CancelHandle,
body_bytes_max: u64,
) -> HttpResponse {
let (sender, receiver) = mpsc::sync_channel(BODY_CHANNEL_CHUNKS);
let allocation = smith_alloc::AllocationGroup::current();
std::thread::spawn(move || {
let _allocation = allocation.as_ref().map(smith_alloc::AllocationGroup::enter);
let mut buffer = [0u8; 16 * 1024];
let mut total: u64 = 0;
let end = loop {
let read = match body.read(&mut buffer) {
Ok(0) => break HttpBodyEnd::Complete,
Err(error) => {
break HttpBodyEnd::Failed {
message: error.to_string(),
};
}
Ok(read) => read,
};
if cancel.is_cancelled() {
break HttpBodyEnd::Cancelled;
}
total = total.saturating_add(u64::try_from(read).unwrap_or(u64::MAX));
if total > body_bytes_max {
break HttpBodyEnd::Truncated {
limit: body_bytes_max,
};
}
let chunk = HttpChunk {
bytes: buffer[..read].to_vec(),
};
if sender.send(HttpBodyItem::Chunk(chunk)).is_err() {
return;
}
};
// The receiver may abandon the body before its terminal item arrives.
let _send_result: std::result::Result<(), std::sync::mpsc::SendError<HttpBodyItem>> =
sender.send(HttpBodyItem::End(end));
});
HttpResponse {
head,
body: receiver,
}
}
const fn transient(message: String) -> SmithError {
SmithError::Provider {
fault: ProviderFault::Transient { message },
}
}
#[cfg(test)]
mod credential_tests {
use super::*;
use std::io::{Read, Write};
use std::net::TcpListener;
fn cancelled_request(method: &str, response_head: &[u8]) {
let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap();
let address = listener.local_addr().unwrap();
let response_head = response_head.to_vec();
let (accepted, accepted_wait) = std::sync::mpsc::sync_channel(1);
let (release, released) = std::sync::mpsc::sync_channel(1);
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut request = [0u8; 1024];
assert!(stream.read(&mut request).unwrap() > 0);
if !response_head.is_empty() {
stream.write_all(&response_head).unwrap();
}
accepted.send(()).unwrap();
released.recv().unwrap();
});
let cancel = CancelHandle::new();
let canceller = cancel.clone();
let cancellation = std::thread::spawn(move || {
accepted_wait.recv().unwrap();
canceller.cancel();
});
let deadline = Instant::now() + Duration::from_secs(15);
let start = Instant::now();
let result = if method == "GET" {
CredentialHttp::get(&format!("http://{address}/credential"), deadline, &cancel)
} else {
CredentialHttp::post(
&format!("http://{address}/credential"),
"code=fixture",
deadline,
&cancel,
)
};
release.send(()).unwrap();
cancellation.join().unwrap();
server.join().unwrap();
assert_eq!(
result.unwrap_err(),
if method == "POST" {
CredentialFault::ExchangeUncertain
} else {
CredentialFault::Cancelled
}
);
assert!(
start.elapsed() < Duration::from_secs(1),
"cancellation must not wait for credential transport timeout"
);
}
#[derive(Debug)]
struct OneCheckInterval {
buffers: ureq::unversioned::transport::LazyBuffers,
cancel: Option<CancelHandle>,
timed_out: bool,
}
impl Transport for OneCheckInterval {
fn buffers(&mut self) -> &mut dyn Buffers {
&mut self.buffers
}
fn transmit_output(
&mut self,
_: usize,
_: NextTimeout,
) -> std::result::Result<(), ureq::Error> {
Ok(())
}
fn await_input(&mut self, _: NextTimeout) -> std::result::Result<bool, ureq::Error> {
if self.timed_out {
Ok(true)
} else {
self.timed_out = true;
if let Some(cancel) = self.cancel.take() {
cancel.cancel();
}
Err(std::io::Error::new(
std::io::ErrorKind::TimedOut,
"fixture cancellation-check interval",
)
.into())
}
}
fn is_open(&mut self) -> bool {
true
}
fn is_tls(&self) -> bool {
false
}
}
#[test]
fn subscription_transport_does_not_follow_redirects_into_private_backend_paths() {
let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap();
let address = listener.local_addr().unwrap();
let (finished, completion) = std::sync::mpsc::sync_channel(1);
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
stream
.set_read_timeout(Some(Duration::from_secs(3)))
.unwrap();
stream
.set_write_timeout(Some(Duration::from_secs(3)))
.unwrap();
let mut request = [0; 2048];
assert!(stream.read(&mut request).unwrap() > 0);
stream.write_all(b"HTTP/1.1 302 Found\r\nLocation: /backend-api/private\r\nContent-Length: 0\r\nConnection: close\r\n\r\n").unwrap();
drop(stream);
let (mut stream, _) = listener.accept().unwrap();
stream
.set_read_timeout(Some(Duration::from_secs(3)))
.unwrap();
stream
.set_write_timeout(Some(Duration::from_secs(3)))
.unwrap();
let bytes = stream.read(&mut request).unwrap();
let redirected = request[..bytes].starts_with(b"GET ");
if redirected {
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
.unwrap();
}
finished.send(redirected).unwrap();
});
let response = subscription_executor()
.execute(
HttpExchange {
method: smith::http::HttpMethod::Get,
url: format!("http://{address}/v1/models"),
headers: Vec::new(),
body: Vec::new(),
},
CancelHandle::new(),
)
.unwrap();
if response.head.status == 302 {
let mut wake =
std::net::TcpStream::connect_timeout(&address, Duration::from_secs(3)).unwrap();
wake.write_all(b"stop").unwrap();
}
let redirected = completion.recv_timeout(Duration::from_secs(3)).unwrap();
server.join().unwrap();
assert_eq!(
response.head.status, 302,
"subscription endpoints must not redirect to another path"
);
assert!(!redirected);
}
#[test]
fn cancellation_check_interval_is_not_the_credential_request_deadline() {
let mut transport = CancelledTransport {
inner: Box::new(OneCheckInterval {
buffers: ureq::unversioned::transport::LazyBuffers::new(1024, 1024),
cancel: None,
timed_out: false,
}),
cancel: CancelHandle::new(),
};
assert!(
transport
.await_input(NextTimeout {
after: Duration::from_secs(1).into(),
reason: ureq::Timeout::Global
})
.unwrap()
);
}
#[test]
fn cancelling_during_discovery_wait_terminates_request() {
cancelled_request("GET", b"");
}
#[test]
fn cancelling_during_token_exchange_wait_marks_exchange_uncertain() {
cancelled_request("POST", b"");
}
#[test]
fn cancelling_during_jwks_body_read_terminates_request() {
let cancel = CancelHandle::new();
let mut transport = CancelledTransport {
inner: Box::new(OneCheckInterval {
buffers: ureq::unversioned::transport::LazyBuffers::new(1024, 1024),
cancel: Some(cancel.clone()),
timed_out: false,
}),
cancel,
};
let error = transport
.await_input(NextTimeout {
after: Duration::from_secs(1).into(),
reason: ureq::Timeout::Global,
})
.unwrap_err();
assert!(
matches!(error, ureq::Error::Io(error) if error.kind() == std::io::ErrorKind::Interrupted)
);
}
}
#[cfg(test)]
mod lifecycle_tests {
//! SMH-SPEC-PLUG0001: blocking imports honor boundary deadlines and root cancellation.
use super::*;
use std::{io::Write, net::TcpListener};
#[test]
fn stalled_lifecycle_headers_and_body_interrupt_without_server_cooperation() {
for headers in [false, true] {
for cancelled in [false, true] {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let (accepted, ready) = mpsc::sync_channel(1);
let (release, released) = mpsc::sync_channel(1);
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
stream
.set_read_timeout(Some(Duration::from_secs(3)))
.unwrap();
let mut bytes = [0; 4096];
assert!(stream.read(&mut bytes).unwrap() > 0);
if headers {
stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\nConnection: close\r\n\r\n").unwrap();
}
accepted.send(()).unwrap();
released.recv_timeout(Duration::from_secs(5)).unwrap();
});
let cancel = CancelHandle::new();
let handle = cancel.clone();
let (finished, done) = mpsc::sync_channel(1);
let client = std::thread::spawn(move || {
let timeout = if cancelled {
Duration::from_secs(5)
} else {
Duration::from_millis(200)
};
let executor = UreqHttpExecutor::lifecycle(timeout, &handle, 256);
let response = executor.execute(
HttpExchange {
method: smith::http::HttpMethod::Post,
url: format!("http://{address}"),
headers: vec![],
body: vec![],
},
handle,
);
let interrupted = match response {
Err(_) => true,
Ok(response) => response.body.into_iter().any(|item| {
matches!(
item,
HttpBodyItem::End(
HttpBodyEnd::Cancelled | HttpBodyEnd::Failed { .. }
)
)
}),
};
finished.send(interrupted).unwrap();
});
ready.recv_timeout(Duration::from_secs(3)).unwrap();
if cancelled {
cancel.cancel();
}
let interrupted = done.recv_timeout(Duration::from_secs(2));
release.send(()).unwrap();
server.join().unwrap();
client.join().unwrap();
assert!(interrupted.expect("HTTP must interrupt before server release"));
}
}
}
}