use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
use bytes::Bytes;
use lambda_http::RequestExt as _;
use lambda_http::http::{HeaderMap, HeaderName, HeaderValue, Method, StatusCode, header};
use lambda_runtime::streaming::Body;
use lambda_runtime::{LambdaEvent, MetadataPrelude};
use serde_json::Value;
use super::codes;
use super::failure::{Failure, FailureKind};
use super::policy::Policy;
use super::render::ErrorRenderer;
use super::request::Request;
use super::response::HttpResponse;
use crate::streaming::{Producer, StreamBody};
use crate::{Context, Deadline, Invocation, RuntimeError};
pub type StreamResponse = lambda_runtime::StreamResponse<Body>;
pub type Prepare = Box<dyn Fn(&mut lambda_http::Request) + Send + Sync>;
pub type HeaderFinalizer = Box<dyn Fn(&Invocation, &mut HeaderMap) + Send + Sync>;
pub const EVENT_STREAM: &str = "text/event-stream; charset=utf-8";
const SEND_TIMEOUT: Duration = Duration::from_secs(1);
const STREAM_CAPACITY: usize = 4;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Representation {
Json,
EventStream,
}
pub fn negotiate(accept: Option<&str>) -> Result<Representation, Failure> {
let Some(accept) = accept else {
return Ok(Representation::Json);
};
let mut json = (0, 0_f32);
let mut stream = (0, 0_f32);
for range in accept.split(',') {
let mut parts = range.trim().split(';');
let media = parts.next().unwrap_or("").trim();
let mut quality = 1_f32;
for parameter in parts {
let weight = parameter
.trim()
.split_once('=')
.filter(|(name, _)| name.eq_ignore_ascii_case("q"));
if let Some((_, q)) = weight {
quality = q
.parse()
.ok()
.filter(|q: &f32| q.is_finite() && (0.0..=1.0).contains(q))
.ok_or_else(|| {
Failure::new(
StatusCode::BAD_REQUEST,
codes::INVALID_ACCEPT,
"Invalid Accept quality",
)
.with_kind(FailureKind::Decode)
})?;
}
}
for (target, exact, group) in [
(&mut json, "application/json", "application/*"),
(&mut stream, "text/event-stream", "text/*"),
] {
let specificity = if media.eq_ignore_ascii_case(exact) {
3
} else if media.eq_ignore_ascii_case(group) {
2
} else if media == "*/*" {
1
} else {
0
};
if specificity > 0
&& (specificity > target.0 || (specificity == target.0 && quality > target.1))
{
*target = (specificity, quality);
}
}
}
if json.1 == 0.0 && stream.1 == 0.0 {
return Err(Failure::new(
StatusCode::NOT_ACCEPTABLE,
codes::NOT_ACCEPTABLE,
"Accept application/json or text/event-stream",
)
.with_kind(FailureKind::Decode));
}
Ok(if stream.1 > json.1 {
Representation::EventStream
} else {
Representation::Json
})
}
#[must_use]
pub fn json(status: StatusCode, value: &Value) -> StreamResponse {
let body = if status == StatusCode::NO_CONTENT {
Body::empty()
} else {
Body::from(value.to_string())
};
head(status, "application/json", body)
}
pub fn events<F, Fut>(deadline: Deadline, produce: F) -> StreamResponse
where
F: FnOnce(EventWriter) -> Fut + Send + 'static,
Fut: Future<Output = ()> + Send + 'static,
{
use futures_util::TryStreamExt as _;
let chunks = StreamBody::spawn(STREAM_CAPACITY, deadline, |producer| {
produce(EventWriter { producer })
});
let body = Body::new(http_body_util::StreamBody::new(
chunks.map_ok(http_body::Frame::data),
));
head(StatusCode::OK, EVENT_STREAM, body)
}
#[must_use]
pub fn from_response(response: HttpResponse) -> StreamResponse {
let (parts, body) = response.into_parts();
let bytes: &[u8] = body.as_ref();
let body = if bytes.is_empty() {
Body::empty()
} else {
Body::from(bytes.to_vec())
};
StreamResponse {
metadata_prelude: MetadataPrelude {
status_code: parts.status,
headers: parts.headers,
..MetadataPrelude::default()
},
stream: body,
}
}
fn move_cookies(prelude: &mut MetadataPrelude) {
let cookies: Vec<String> = prelude
.headers
.get_all(header::SET_COOKIE)
.iter()
.map(|value| String::from_utf8_lossy(value.as_bytes()).into_owned())
.collect();
prelude.headers.remove(header::SET_COOKIE);
prelude.cookies.extend(cookies);
}
fn head(status: StatusCode, content_type: &'static str, body: Body) -> StreamResponse {
let mut metadata = MetadataPrelude {
status_code: status,
..MetadataPrelude::default()
};
metadata
.headers
.insert(header::CONTENT_TYPE, HeaderValue::from_static(content_type));
StreamResponse {
metadata_prelude: metadata,
stream: body,
}
}
#[must_use]
pub fn sse_frame(id: Option<&str>, event: Option<&str>, data: &str) -> String {
let mut frame = String::with_capacity(data.len() + 32);
for (field, value) in [("id: ", id), ("event: ", event)] {
if let Some(value) = value {
frame.push_str(field);
frame.extend(value.chars().filter(|c| !matches!(c, '\r' | '\n')));
frame.push('\n');
}
}
for line in data.split("\r\n").flat_map(|part| part.split(['\r', '\n'])) {
frame.push_str("data: ");
frame.push_str(line);
frame.push('\n');
}
frame.push('\n');
frame
}
#[derive(Debug)]
pub struct EventWriter {
producer: Producer,
}
impl EventWriter {
pub async fn send(&self, frame: impl Into<Bytes>) -> Result<(), RuntimeError> {
match tokio::time::timeout(SEND_TIMEOUT, self.producer.send(frame)).await {
Ok(true) => Ok(()),
Ok(false) => Err(RuntimeError::message("the event stream was closed")),
Err(_) => Err(RuntimeError::message("the event stream reader stalled")),
}
}
#[must_use]
pub fn producer(&self) -> &Producer {
&self.producer
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Cors {
origins: Vec<String>,
allow_headers: String,
expose_headers: String,
max_age: Duration,
}
impl Cors {
#[must_use]
pub fn new(origins: Vec<String>) -> Self {
Self {
origins,
allow_headers: "accept,authorization,content-type".to_owned(),
expose_headers: String::new(),
max_age: Duration::from_secs(600),
}
}
#[must_use]
pub fn allow_headers(mut self, headers: &str) -> Self {
self.allow_headers = headers.to_owned();
self
}
#[must_use]
pub fn expose_headers(mut self, headers: &str) -> Self {
self.expose_headers = headers.to_owned();
self
}
#[must_use]
pub fn max_age(mut self, max_age: Duration) -> Self {
self.max_age = max_age;
self
}
#[must_use]
pub fn allows(&self, origin: &str) -> bool {
self.origins.iter().any(|allowed| allowed == origin)
}
fn apply(&self, origin: &str, methods: &str, headers: &mut HeaderMap) {
let values = [
("access-control-allow-origin", origin),
("access-control-allow-methods", methods),
("access-control-allow-headers", self.allow_headers.as_str()),
(
"access-control-expose-headers",
self.expose_headers.as_str(),
),
];
for (name, value) in values {
if value.is_empty() {
continue;
}
if let Ok(value) = HeaderValue::try_from(value) {
headers.insert(HeaderName::from_static(name), value);
}
}
headers.insert(
HeaderName::from_static("access-control-max-age"),
HeaderValue::from(self.max_age.as_secs()),
);
}
}
#[derive(Debug)]
pub struct StreamRequest {
native: lambda_http::Request,
event: Value,
representation: Representation,
}
impl StreamRequest {
#[must_use]
pub fn native(&self) -> &lambda_http::Request {
&self.native
}
#[must_use]
pub fn view(&self) -> Request<'_> {
Request::new(&self.native)
}
#[must_use]
pub fn path(&self) -> &str {
self.native.raw_http_path()
}
#[must_use]
pub fn event(&self) -> &Value {
&self.event
}
#[must_use]
pub fn representation(&self) -> Representation {
self.representation
}
#[must_use]
pub fn wants_events(&self) -> bool {
self.representation == Representation::EventStream
}
}
pub struct StreamApi<P, R> {
operation: &'static str,
policy: P,
renderer: R,
methods: Vec<Method>,
cors: Option<Cors>,
margin: Duration,
prepare: Option<Prepare>,
finalize: Option<HeaderFinalizer>,
}
impl<P, R> std::fmt::Debug for StreamApi<P, R> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StreamApi")
.field("operation", &self.operation)
.field("methods", &self.methods)
.field("cors", &self.cors)
.field("margin", &self.margin)
.finish_non_exhaustive()
}
}
impl<P, R> StreamApi<P, R>
where
P: Policy,
R: ErrorRenderer,
{
#[must_use]
pub fn new(operation: &'static str, policy: P, renderer: R) -> Self {
Self {
operation,
policy,
renderer,
methods: vec![Method::GET],
cors: None,
margin: Duration::from_secs(1),
prepare: None,
finalize: None,
}
}
#[must_use]
pub fn methods(mut self, methods: &[Method]) -> Self {
self.methods = methods.to_vec();
self
}
#[must_use]
pub fn cors(mut self, cors: Cors) -> Self {
self.cors = Some(cors);
self
}
#[must_use]
pub fn margin(mut self, margin: Duration) -> Self {
self.margin = margin;
self
}
#[must_use]
pub fn prepare<F>(mut self, prepare: F) -> Self
where
F: Fn(&mut lambda_http::Request) + Send + Sync + 'static,
{
self.prepare = Some(Box::new(prepare));
self
}
#[must_use]
pub fn finalize<F>(mut self, finalize: F) -> Self
where
F: Fn(&Invocation, &mut HeaderMap) + Send + Sync + 'static,
{
self.finalize = Some(Box::new(finalize));
self
}
pub fn operation(&self) -> &str {
self.operation
}
pub async fn handle<App, H, F>(
&self,
app: Arc<App>,
event: LambdaEvent<Value>,
handler: &H,
) -> StreamResponse
where
H: Fn(Arc<App>, StreamRequest, Context<P::Scope>) -> F,
F: Future<Output = Result<StreamResponse, Failure>>,
{
let (payload, context) = event.into_parts();
let invocation = crate::runtime::invocation_from(&context);
#[cfg(feature = "logs")]
let span = crate::telemetry::logs::invocation_span(self.operation, &invocation);
let work = self.execute(app, payload, context, &invocation, handler);
#[cfg(feature = "logs")]
let work = tracing::Instrument::instrument(work, span.clone());
let (origin, result) = work.await;
let mut response = result.unwrap_or_else(|failure| {
self.log(&failure, &invocation);
from_response(self.renderer.render(&failure))
});
let headers = &mut response.metadata_prelude.headers;
headers.insert(header::VARY, HeaderValue::from_static("Origin, Accept"));
if let Some(finalize) = &self.finalize {
finalize(&invocation, headers);
}
if let (Some(cors), Some(origin)) = (&self.cors, origin.as_deref())
&& cors.allows(origin)
{
cors.apply(origin, &self.allowed_methods(), headers);
}
move_cookies(&mut response.metadata_prelude);
#[cfg(feature = "otel")]
crate::telemetry::record_status(&span, response.metadata_prelude.status_code.as_u16());
response
}
async fn execute<App, H, F>(
&self,
app: Arc<App>,
payload: Value,
context: lambda_runtime::Context,
invocation: &Invocation,
handler: &H,
) -> (Option<String>, Result<StreamResponse, Failure>)
where
H: Fn(Arc<App>, StreamRequest, Context<P::Scope>) -> F,
F: Future<Output = Result<StreamResponse, Failure>>,
{
let Ok(native) = lambda_http::request::from_str(&payload.to_string()) else {
let failure = Failure::new(
StatusCode::BAD_REQUEST,
codes::MALFORMED_REQUEST,
"Invalid HTTP request",
)
.with_kind(FailureKind::Decode);
return (None, Err(failure));
};
let mut native = native.with_lambda_context(context);
if let Some(prepare) = &self.prepare {
prepare(&mut native);
}
let origin = Request::new(&native).header("origin").map(str::to_owned);
if let (Some(cors), Some(origin)) = (&self.cors, origin.as_deref())
&& !cors.allows(origin)
{
let failure = Failure::new(
StatusCode::FORBIDDEN,
codes::ORIGIN_NOT_ALLOWED,
"Origin not allowed",
)
.with_kind(FailureKind::Policy);
return (Some(origin.to_owned()), Err(failure));
}
if native.method() == Method::OPTIONS {
return (origin, Ok(json(StatusCode::NO_CONTENT, &Value::Null)));
}
if !self.methods.contains(native.method()) {
let names: Vec<&str> = self.methods.iter().map(Method::as_str).collect();
let failure = Failure::new(
StatusCode::METHOD_NOT_ALLOWED,
codes::METHOD_NOT_ALLOWED,
format!("Use {}", names.join(" or ")),
)
.with_kind(FailureKind::Decode)
.with_header("allow", &self.allowed_methods());
return (origin, Err(failure));
}
let deadline = invocation.deadline.with_margin(self.margin);
let result = deadline
.run(async {
let representation = negotiate(Request::new(&native).header("accept"))?;
let scope = self
.policy
.authorize(&Request::new(&native), invocation)
.await
.map_err(|failure| failure.with_kind(FailureKind::Policy))?;
let request = StreamRequest {
native,
event: payload,
representation,
};
Box::pin(handler(
app,
request,
Context::new(invocation.clone(), scope),
))
.await
})
.await
.map_err(super::api::timeout_failure)
.and_then(std::convert::identity);
(origin, result)
}
fn allowed_methods(&self) -> String {
let mut names: Vec<&str> = self.methods.iter().map(Method::as_str).collect();
names.push("OPTIONS");
names.join(", ")
}
fn log(&self, failure: &Failure, invocation: &Invocation) {
#[cfg(feature = "logs")]
{
if failure.is_server_error() {
tracing::error!(
operation = self.operation,
request_id = %invocation.request_id,
code = failure.code(),
kind = ?failure.kind(),
"request failed"
);
} else {
tracing::debug!(operation = self.operation, request_id = %invocation.request_id, code = failure.code(), status = failure.status().as_u16(), "request refused");
}
}
#[cfg(not(feature = "logs"))]
{
let _ = (failure, invocation);
}
}
pub async fn run<App, H, F>(self, app: Arc<App>, handler: H) -> Result<(), RuntimeError>
where
App: Send + Sync + 'static,
H: Fn(Arc<App>, StreamRequest, Context<P::Scope>) -> F + Send + Sync,
F: Future<Output = Result<StreamResponse, Failure>> + Send,
P::Scope: Send,
{
let api = &self;
let handler = &handler;
let service = lambda_runtime::service_fn(move |event: LambdaEvent<Value>| {
let app = Arc::clone(&app);
async move {
Ok::<_, lambda_runtime::Error>(Box::pin(api.handle(app, event, handler)).await)
}
});
lambda_runtime::Runtime::new(service)
.run()
.await
.map_err(crate::runtime::loop_failure)
}
}