WEB Debug + Trace

Co-Authored-By: brekotis <93345790+brekotis@users.noreply.github.com>

src/web/http/response.rs

@@ -0,0 +1,88 @@
+use bytes::Bytes;
+use http_body_util::{BodyExt, Full};
+use hyper::header::{self, HeaderName, HeaderValue};
+use hyper::{Request, Response, StatusCode};
+
+use super::request::canonical_u64_header;
+use super::{BoxError, HttpResponse};
+use crate::config::WebCarrier;
+use crate::web::frame;
+
+/// Validates and resolves the optional carrier lane header.
+pub(super) fn carrier_lane<B>(
+    request: &Request<B>,
+    carrier: WebCarrier,
+) -> Option<Option<u32>> {
+    match carrier {
+        WebCarrier::Https => (!request.headers().contains_key("x-lane-id")).then_some(None),
+        WebCarrier::HttpsLanes => canonical_u64_header(request, "x-lane-id")
+            .and_then(|value| u32::try_from(value).ok())
+            .filter(|value| *value <= frame::MAX_STREAM_ID)
+            .map(Some),
+    }
+}
+
+/// Applies common binary carrier response headers.
+pub(super) fn carrier_headers(response: &mut HttpResponse) {
+    response.headers_mut().insert(
+        header::CONTENT_TYPE,
+        HeaderValue::from_static("application/octet-stream"),
+    );
+    response
+        .headers_mut()
+        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+}
+
+/// Builds an empty no-store carrier response.
+pub(super) fn carrier_empty(status: StatusCode) -> HttpResponse {
+    let mut response = empty_response(status);
+    response
+        .headers_mut()
+        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+    response
+}
+
+/// Builds the bounded retryable carrier saturation response.
+pub(super) fn service_unavailable() -> HttpResponse {
+    let mut response = carrier_empty(StatusCode::SERVICE_UNAVAILABLE);
+    response
+        .headers_mut()
+        .insert(header::RETRY_AFTER, HeaderValue::from_static("1"));
+    response
+}
+
+/// Builds the ordinary decoy upstream failure response.
+pub(super) fn bad_gateway() -> HttpResponse {
+    full_response(
+        StatusCode::BAD_GATEWAY,
+        Bytes::from_static(b"site unavailable\n"),
+    )
+}
+
+/// Builds the ordinary unmatched-host response.
+pub(super) fn generic_not_found() -> HttpResponse {
+    full_response(StatusCode::NOT_FOUND, Bytes::from_static(b"not found\n"))
+}
+
+/// Builds one in-memory response with an exact content length.
+pub(super) fn full_response(status: StatusCode, body: Bytes) -> HttpResponse {
+    let length = body.len();
+    let body = Full::new(body)
+        .map_err(|never| -> BoxError { match never {} })
+        .boxed_unsync();
+    let mut response = Response::new(body);
+    *response.status_mut() = status;
+    insert_header(&mut response, header::CONTENT_LENGTH, &length.to_string());
+    response
+}
+
+fn empty_response(status: StatusCode) -> HttpResponse {
+    full_response(status, Bytes::new())
+}
+
+/// Inserts one validated dynamic response header value.
+pub(super) fn insert_header(response: &mut HttpResponse, name: HeaderName, value: &str) {
+    if let Ok(value) = HeaderValue::from_str(value) {
+        response.headers_mut().insert(name, value);
+    }
+}