pub use axum::body::Bytes;
use datumesh_core::json::{self, Value};
use datumesh_core::{ErrorCode, Fault, Pending, Receipt, Trust};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cache {
Immutable,
Public(u64),
Private,
NoStore,
}
impl Cache {
pub fn header(self) -> String {
match self {
Cache::Immutable => "public, max-age=31536000, immutable".to_string(),
Cache::Public(n) => format!("public, max-age={n}"),
Cache::Private => "private, no-store".to_string(),
Cache::NoStore => "no-store".to_string(),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Reply {
pub status: u16,
pub body: Bytes,
pub content_type: &'static str,
pub cache: Cache,
pub canonical: Option<String>,
pub retry_after: Option<u64>,
}
pub const JSON: &str = "application/json";
impl Reply {
pub fn json(status: u16, body: impl Into<Bytes>, cache: Cache) -> Reply {
Reply { status, body: body.into(), content_type: JSON, cache, canonical: None, retry_after: None }
}
pub fn outcome(&self) -> Option<String> {
if self.content_type != JSON {
return None;
}
const KEY: &[u8] = b"\"outcome\":\"";
let at = self.body.windows(KEY.len()).position(|w| w == KEY)? + KEY.len();
let end = self.body[at..].iter().position(|b| *b == b'"')?;
std::str::from_utf8(&self.body[at..at + end]).ok().map(str::to_string)
}
}
pub(crate) fn num(n: u64) -> Value {
json::parse(n.to_string().as_bytes()).unwrap_or(Value::Null)
}
fn s(v: &str) -> Value {
Value::String(v.to_string())
}
fn object(members: Vec<(&str, Value)>) -> Value {
Value::Object(members.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
}
fn bytes(v: Value) -> Vec<u8> {
v.to_jcs()
}
pub fn trust_of(receipt: &Receipt, mesh_host: &str) -> Trust {
let ns_host = receipt.cell().ns.split('/').next().unwrap_or("");
if receipt.signer_host() == ns_host && receipt.inputs().is_empty() {
Trust::Primary
} else if receipt.signer_host() == mesh_host {
Trust::Verified
} else {
Trust::Unverified
}
}
pub fn ok(receipt: &[u8], trust: Trust) -> Vec<u8> {
let r = json::parse(receipt).unwrap_or(Value::Null);
bytes(object(vec![("outcome", s("ok")), ("receipt", r), ("trust", s(trust.as_str()))]))
}
pub fn stale(receipt: &[u8], trust: Trust, age_seconds: u64) -> Vec<u8> {
let r = json::parse(receipt).unwrap_or(Value::Null);
bytes(object(vec![
("age_seconds", num(age_seconds)),
("outcome", s("stale")),
("receipt", r),
("trust", s(trust.as_str())),
]))
}
pub fn not_covered(fault: Option<Fault>) -> Vec<u8> {
let mut m = vec![("outcome", s("not_covered"))];
if let Some(f) = fault {
m.push(("fault", s(f.as_str())));
}
bytes(object(m))
}
pub fn unlicensed() -> Vec<u8> {
bytes(object(vec![("outcome", s("unlicensed"))]))
}
pub fn payment_required(amount: &str, currency: &str, authorise: &str) -> Vec<u8> {
bytes(object(vec![
("outcome", s("payment_required")),
("quote", object(vec![("amount", s(amount)), ("authorise", s(authorise)), ("currency", s(currency))])),
]))
}
pub fn rate_limited(retry_after_seconds: u64) -> Vec<u8> {
bytes(object(vec![("outcome", s("rate_limited")), ("retry_after_seconds", num(retry_after_seconds))]))
}
pub fn bad_request(code: ErrorCode) -> Vec<u8> {
bytes(object(vec![("error", s(code.as_str())), ("outcome", s("bad_request"))]))
}
pub fn error(code: ErrorCode) -> Vec<u8> {
bytes(object(vec![("error", s(code.as_str())), ("outcome", s("error"))]))
}
pub fn pending(p: &Pending) -> Vec<u8> {
p.to_json()
}
pub const BAD_REQUEST_CODES: &[ErrorCode] = &[
ErrorCode::ParseUri,
ErrorCode::CanonName,
ErrorCode::CanonArgName,
ErrorCode::CanonArgDuplicate,
ErrorCode::CanonArgOrder,
ErrorCode::CanonPercent,
ErrorCode::CanonType,
ErrorCode::CanonNumber,
ErrorCode::CanonDate,
ErrorCode::CanonInstant,
ErrorCode::CanonString,
ErrorCode::CanonBlob,
ErrorCode::CanonLimit,
ErrorCode::ArgUnknown,
ErrorCode::ArgMissing,
];
pub fn is_request_code(code: ErrorCode) -> bool {
BAD_REQUEST_CODES.contains(&code)
}
pub fn is_error_code(code: ErrorCode) -> bool {
!matches!(code, ErrorCode::Envelope | ErrorCode::JobUnknown)
}
pub fn error_status(code: ErrorCode) -> u16 {
match code {
ErrorCode::InputUnavailable | ErrorCode::KeyUnavailable | ErrorCode::MeshDoc | ErrorCode::EvalUnavailable => {
503
}
_ => 500,
}
}
pub fn error_reply(code: ErrorCode) -> Reply {
Reply::json(error_status(code), error(code), Cache::NoStore)
}
pub fn bad_request_reply(code: ErrorCode) -> Reply {
Reply::json(400, bad_request(code), Cache::Public(60))
}
pub fn rate_limited_reply(retry_after_seconds: u64) -> Reply {
let mut r = Reply::json(429, rate_limited(retry_after_seconds), Cache::NoStore);
r.retry_after = Some(retry_after_seconds);
r
}