use std::collections::BTreeMap;
use crate::descriptor::cmp_lexical;
use crate::envelope::{
check_job_and_poll_for, env_err, integer_member, quote, EnvelopeExtras, Fault, ForeignDetail, Outcome, Overrides,
Pending, Quote, Request, Resolution, ResolutionKind, Resolved, Shadows, Trust, BAD_REQUEST_CODES,
};
use crate::error::{Error, ErrorCode, Result};
use crate::json::{self, Value};
use crate::keys::Keys;
use crate::lexical::{self, limits};
use crate::model::{scalar_canonical, Arg, Cell, Scalar, Type};
use crate::receipt::Receipt;
use crate::schema;
use crate::slice::Slice;
use crate::Envelope;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum AnswerOutcome {
Ok,
Stale,
NotCovered,
Unlicensed,
PaymentRequired,
RateLimited,
BadRequest,
Error,
Pending,
Scenario,
}
impl AnswerOutcome {
pub const fn as_str(self) -> &'static str {
match self {
AnswerOutcome::Ok => "ok",
AnswerOutcome::Stale => "stale",
AnswerOutcome::NotCovered => "not_covered",
AnswerOutcome::Unlicensed => "unlicensed",
AnswerOutcome::PaymentRequired => "payment_required",
AnswerOutcome::RateLimited => "rate_limited",
AnswerOutcome::BadRequest => "bad_request",
AnswerOutcome::Error => "error",
AnswerOutcome::Pending => "pending",
AnswerOutcome::Scenario => "scenario",
}
}
pub fn from_name(s: &str) -> Option<AnswerOutcome> {
Some(match s {
"ok" => AnswerOutcome::Ok,
"stale" => AnswerOutcome::Stale,
"not_covered" => AnswerOutcome::NotCovered,
"unlicensed" => AnswerOutcome::Unlicensed,
"payment_required" => AnswerOutcome::PaymentRequired,
"rate_limited" => AnswerOutcome::RateLimited,
"bad_request" => AnswerOutcome::BadRequest,
"error" => AnswerOutcome::Error,
"pending" => AnswerOutcome::Pending,
"scenario" => AnswerOutcome::Scenario,
_ => return None,
})
}
pub const fn status(self) -> u16 {
match self {
AnswerOutcome::Ok | AnswerOutcome::Stale => 200,
AnswerOutcome::NotCovered => 404,
AnswerOutcome::Unlicensed => 403,
AnswerOutcome::PaymentRequired => 402,
AnswerOutcome::RateLimited => 429,
AnswerOutcome::BadRequest => 400,
AnswerOutcome::Error => 500,
AnswerOutcome::Pending => 202,
AnswerOutcome::Scenario => 200,
}
}
fn status_ok(self, status: u16) -> bool {
match self {
AnswerOutcome::Error => (500..=599).contains(&status),
other => other.status() == status,
}
}
fn members(self) -> (&'static [&'static str], &'static [&'static str]) {
match self {
AnswerOutcome::Ok => {
(&["receipt", "trust"], &["superseded_by", "reason", "fn_hash", "resolved", "shadows"])
}
AnswerOutcome::Stale => {
(&["receipt", "trust", "age_seconds"], &["superseded_by", "reason", "fn_hash", "resolved", "shadows"])
}
AnswerOutcome::NotCovered => (&[], &["fault", "error", "fn_hash", "resolved", "shadows"]),
AnswerOutcome::Unlicensed => (&[], &["fn_hash", "resolved", "shadows"]),
AnswerOutcome::PaymentRequired => (&["quote"], &["fn_hash", "resolved", "shadows"]),
AnswerOutcome::RateLimited => (&["retry_after_seconds"], &["fn_hash"]),
AnswerOutcome::BadRequest => (&["error"], &["fn_hash"]),
AnswerOutcome::Error => (&["error"], &["cycle", "detail", "fn_hash", "resolved", "shadows"]),
AnswerOutcome::Pending => (&["estimate_seconds", "job", "poll", "request"], &[]),
AnswerOutcome::Scenario => (&["scenario"], &["fn_hash", "resolved"]),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum TrustLabel {
Primary,
Computed,
Verified,
Unverified,
Relayed,
}
impl TrustLabel {
pub const fn as_str(self) -> &'static str {
match self {
TrustLabel::Primary => "primary",
TrustLabel::Computed => "computed",
TrustLabel::Verified => "verified",
TrustLabel::Unverified => "unverified",
TrustLabel::Relayed => "relayed",
}
}
fn from_name(s: &str) -> Option<TrustLabel> {
Some(match s {
"primary" => TrustLabel::Primary,
"computed" => TrustLabel::Computed,
"verified" => TrustLabel::Verified,
"unverified" => TrustLabel::Unverified,
"relayed" => TrustLabel::Relayed,
_ => return None,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct SlicePage {
pub slice: Slice,
pub members: Vec<Answer>,
pub next: Option<String>,
}
impl SlicePage {
pub fn new(slice: Slice, members: Vec<Answer>, next: Option<String>) -> SlicePage {
SlicePage { slice, members, next }
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Answer {
pub outcome: AnswerOutcome,
pub receipt: Option<Receipt>,
pub trust: Option<TrustLabel>,
pub age_seconds: Option<u64>,
pub superseded_by: Option<String>,
pub reason: Option<String>,
pub quote: Option<Quote>,
pub retry_after_seconds: Option<u64>,
pub error: Option<ErrorCode>,
pub fault: Option<Fault>,
pub detail: Option<ForeignDetail>,
pub fn_hash: Option<String>,
pub pending: Option<Pending>,
pub page: Option<SlicePage>,
pub resolved: Option<Resolved>,
pub shadows: Option<Shadows>,
pub scenario: Option<Scenario>,
pub cycle: Option<Cycle>,
status: u16,
}
fn bare(outcome: AnswerOutcome) -> Answer {
Answer {
outcome,
receipt: None,
trust: None,
age_seconds: None,
superseded_by: None,
reason: None,
quote: None,
retry_after_seconds: None,
error: None,
fault: None,
detail: None,
fn_hash: None,
pending: None,
page: None,
resolved: None,
shadows: None,
scenario: None,
cycle: None,
status: outcome.status(),
}
}
fn code_allowed(outcome: AnswerOutcome, code: ErrorCode, job_url: bool) -> bool {
match outcome {
AnswerOutcome::BadRequest => {
BAD_REQUEST_CODES.contains(&code)
|| matches!(
code,
ErrorCode::CanonHex
| ErrorCode::SliceAtCell
| ErrorCode::ShortIdAmbiguous
| ErrorCode::KeyNormalisation
| ErrorCode::KeyEncoding
)
|| (code == ErrorCode::JobUnknown && job_url)
|| matches!(code, ErrorCode::WhatifUnsupported | ErrorCode::SliceMember)
}
AnswerOutcome::NotCovered => matches!(code, ErrorCode::NameUnbound | ErrorCode::NamespaceSuspended),
AnswerOutcome::Error => !matches!(
code,
ErrorCode::Envelope
| ErrorCode::JobUnknown
| ErrorCode::SliceAtCell
| ErrorCode::NameUnbound
| ErrorCode::KeyNormalisation
| ErrorCode::KeyEncoding
| ErrorCode::UnrootedInput
| ErrorCode::NamespaceSuspended
| ErrorCode::ClassMember
| ErrorCode::ClassParent
| ErrorCode::ClassInherit
| ErrorCode::ClassOverride
| ErrorCode::ClassFinal
| ErrorCode::ClassMethod
| ErrorCode::ClassInterface
| ErrorCode::ClassOwner
| ErrorCode::ShortIdAmbiguous
| ErrorCode::Describe
| ErrorCode::WhatifUnsupported
| ErrorCode::WhatifNoSolution
),
_ => false,
}
}
impl Answer {
pub fn ok(receipt: Receipt, trust: TrustLabel) -> Answer {
Answer { receipt: Some(receipt), trust: Some(trust), ..bare(AnswerOutcome::Ok) }
}
pub fn stale(receipt: Receipt, trust: TrustLabel, age_seconds: u64) -> Answer {
Answer {
receipt: Some(receipt),
trust: Some(trust),
age_seconds: Some(age_seconds),
..bare(AnswerOutcome::Stale)
}
}
pub fn not_covered() -> Answer {
bare(AnswerOutcome::NotCovered)
}
pub fn unlicensed() -> Answer {
bare(AnswerOutcome::Unlicensed)
}
pub fn payment_required(quote: Quote) -> Answer {
Answer { quote: Some(quote), ..bare(AnswerOutcome::PaymentRequired) }
}
pub fn rate_limited(retry_after_seconds: u64) -> Answer {
Answer { retry_after_seconds: Some(retry_after_seconds), ..bare(AnswerOutcome::RateLimited) }
}
pub fn bad_request(code: ErrorCode) -> Result<Answer> {
if !code_allowed(AnswerOutcome::BadRequest, code, true) {
return env_err("$.error", format!("bad_request cannot carry {code}"));
}
Ok(Answer { error: Some(code), ..bare(AnswerOutcome::BadRequest) })
}
pub fn error(code: ErrorCode) -> Result<Answer> {
if !code_allowed(AnswerOutcome::Error, code, false) {
return env_err("$.error", format!("error cannot carry {code}"));
}
if code == ErrorCode::ForeignUnavailable {
return env_err("$.detail", "E_FOREIGN_UNAVAILABLE needs a detail: Answer::foreign_unavailable");
}
Ok(Answer { error: Some(code), ..bare(AnswerOutcome::Error) })
}
pub fn foreign_unavailable(detail: ForeignDetail) -> Answer {
Answer {
error: Some(ErrorCode::ForeignUnavailable),
detail: Some(detail),
status: 502,
..bare(AnswerOutcome::Error)
}
}
pub fn pending(p: Pending) -> Answer {
Answer { pending: Some(p), ..bare(AnswerOutcome::Pending) }
}
pub fn page(page: SlicePage) -> Answer {
Answer { page: Some(page), ..bare(AnswerOutcome::Ok) }
}
pub fn scenario(scenario: Scenario) -> Answer {
Answer { scenario: Some(scenario), ..bare(AnswerOutcome::Scenario) }
}
pub fn with_cycle(self, cycle: Cycle) -> Result<Answer> {
if self.outcome != AnswerOutcome::Error || self.error != Some(ErrorCode::EvalUnavailable) {
return env_err("$.cycle", "cycle is carried by error with E_EVAL_UNAVAILABLE only");
}
Ok(Answer { cycle: Some(cycle), ..self })
}
pub fn with_fn_hash(self, fn_hash: &str) -> Result<Answer> {
if self.outcome == AnswerOutcome::Pending || lexical::check_hex(fn_hash, 64, "").is_err() {
return env_err("$.fn_hash", "fn_hash is 64 lowercase hex digits, not on pending");
}
Ok(Answer { fn_hash: Some(fn_hash.into()), ..self })
}
pub fn with_fault(self, fault: Fault) -> Answer {
Answer { fault: Some(fault), ..self }
}
pub fn with_error(self, code: ErrorCode) -> Result<Answer> {
if self.outcome != AnswerOutcome::NotCovered || self.fault.is_some() || !code_allowed(self.outcome, code, false)
{
return env_err("$.error", "not_covered carries E_NAME_UNBOUND or E_NAMESPACE_SUSPENDED, not with a fault");
}
Ok(Answer { error: Some(code), ..self })
}
pub fn with_resolved(self, resolved: Resolved) -> Result<Answer> {
if !outcome_has_resolved(self.outcome) {
return env_err("$.resolved", format!("{} carries no resolved", self.outcome.as_str()));
}
Ok(Answer { resolved: Some(resolved), ..self })
}
pub fn with_shadows(self, shadows: Shadows) -> Result<Answer> {
if !outcome_has_resolved(self.outcome) {
return env_err("$.shadows", format!("{} carries no shadows", self.outcome.as_str()));
}
Ok(Answer { shadows: Some(shadows), ..self })
}
pub fn with_superseded(self, superseded_by: &str, reason: Option<&str>) -> Answer {
Answer { superseded_by: Some(superseded_by.into()), reason: reason.map(String::from), ..self }
}
pub fn with_status(self, status: u16) -> Answer {
Answer { status, ..self }
}
pub fn status(&self) -> u16 {
self.status
}
pub fn to_value(&self) -> Value {
if let Some(p) = &self.pending {
return p.to_value();
}
let mut m: Vec<(String, Value)> = vec![("outcome".into(), Value::String(self.outcome.as_str().into()))];
let s = |x: &str| Value::String(x.into());
let n = |x: u64| json::parse(x.to_string().as_bytes()).unwrap_or(Value::Null);
if let Some(r) = &self.receipt {
m.push(("receipt".into(), receipt_value(r)));
}
if let Some(t) = self.trust {
m.push(("trust".into(), s(t.as_str())));
}
if let Some(a) = self.age_seconds {
m.push(("age_seconds".into(), n(a)));
}
if let Some(x) = &self.superseded_by {
m.push(("superseded_by".into(), s(x)));
}
if let Some(x) = &self.reason {
m.push(("reason".into(), s(x)));
}
if let Some(q) = &self.quote {
m.push((
"quote".into(),
Value::Object(vec![
("amount".into(), s(&q.amount)),
("authorise".into(), s(&q.authorise)),
("currency".into(), s(&q.currency)),
]),
));
}
if let Some(a) = self.retry_after_seconds {
m.push(("retry_after_seconds".into(), n(a)));
}
if let Some(e) = self.error {
m.push(("error".into(), s(e.as_str())));
}
if let Some(f) = self.fault {
m.push(("fault".into(), s(f.as_str())));
}
if let Some(d) = self.detail {
m.push(("detail".into(), s(d.as_str())));
}
if let Some(h) = &self.fn_hash {
m.push(("fn_hash".into(), s(h)));
}
if let Some(r) = &self.resolved {
let mut rm = vec![
("call".to_string(), s(&r.call)),
(
"resolutions".to_string(),
Value::Array(
r.resolutions
.iter()
.map(|x| {
let mut xm = vec![
("from".to_string(), s(&x.from)),
("kind".to_string(), s(x.kind.as_str())),
("to".to_string(), s(&x.to)),
];
if let Some(a) = &x.asof {
xm.push(("asof".into(), s(a)));
}
Value::Object(xm)
})
.collect(),
),
),
];
if let Some(t) = &r.aliases_tx {
rm.push(("aliases_tx".into(), s(t)));
}
m.push(("resolved".into(), Value::Object(rm)));
}
if let Some(sh) = &self.shadows {
m.push((
"shadows".into(),
Value::Object(vec![("class".into(), s(&sh.class)), ("reference".into(), s(&sh.reference))]),
));
}
if let Some(sc) = &self.scenario {
m.push(("scenario".into(), sc.to_value()));
}
if let Some(c) = &self.cycle {
m.push(("cycle".into(), c.to_value()));
}
if let Some(p) = &self.page {
m.push(("slice".into(), p.slice.to_value()));
m.push(("members".into(), Value::Array(p.members.iter().map(Answer::to_value).collect())));
if let Some(x) = &p.next {
m.push(("next".into(), s(x)));
}
}
Value::Object(m)
}
pub fn to_json(&self) -> Vec<u8> {
self.to_value().to_jcs()
}
pub(crate) fn into_envelope(self) -> Result<(Envelope, EnvelopeExtras)> {
if self.cycle.is_some() {
return env_err("$.cycle", "cycle is read by check_answer");
}
let outcome = match self.outcome {
AnswerOutcome::Ok => Outcome::Ok,
AnswerOutcome::Stale => Outcome::Stale,
AnswerOutcome::NotCovered => Outcome::NotCovered,
AnswerOutcome::Unlicensed => Outcome::Unlicensed,
AnswerOutcome::PaymentRequired => Outcome::PaymentRequired,
AnswerOutcome::RateLimited => Outcome::RateLimited,
AnswerOutcome::BadRequest => Outcome::BadRequest,
AnswerOutcome::Error => Outcome::Error,
AnswerOutcome::Pending => return env_err("$.outcome", "unknown outcome \"pending\""),
AnswerOutcome::Scenario => return env_err("$.outcome", "unknown outcome \"scenario\""),
};
let trust = match self.trust {
None => None,
Some(TrustLabel::Primary) => Some(Trust::Primary),
Some(TrustLabel::Verified) => Some(Trust::Verified),
Some(TrustLabel::Unverified) => Some(Trust::Unverified),
Some(_) => return env_err("$.trust", "trust is primary, verified or unverified"),
};
let env = Envelope {
outcome,
receipt: self.receipt,
trust,
age_seconds: self.age_seconds,
superseded_by: self.superseded_by,
reason: self.reason,
quote: self.quote,
retry_after_seconds: self.retry_after_seconds,
error: self.error,
};
Ok((env, EnvelopeExtras { fault: self.fault, fn_hash: self.fn_hash, detail: self.detail }))
}
}
fn receipt_value(r: &Receipt) -> Value {
let mut members = json::parse(r.payload()).ok().and_then(|v| v.as_object().map(<[_]>::to_vec)).unwrap_or_default();
members.push(("sig".into(), Value::String(r.sig().into())));
Value::Object(members)
}
enum Ctx<'a> {
Cell(&'a Request),
Slice(&'a SliceRequest),
None,
}
impl Ctx<'_> {
fn pin(&self) -> Option<&str> {
match self {
Ctx::Cell(r) => r.pin.as_deref(),
Ctx::Slice(s) => s.pin.as_deref(),
Ctx::None => None,
}
}
fn mesh(&self) -> Option<&str> {
match self {
Ctx::Cell(r) => r.mesh.as_deref(),
Ctx::Slice(s) => s.mesh.as_deref(),
Ctx::None => None,
}
}
fn job_url(&self) -> bool {
matches!(self, Ctx::Cell(r) if r.job.is_some())
}
fn whatif(&self) -> bool {
matches!(self, Ctx::Cell(r) if r.overrides.is_some())
}
fn solve(&self) -> Option<&str> {
match self {
Ctx::Cell(r) => r.solve.as_deref(),
_ => None,
}
}
}
fn whatif_code_ok(outcome: AnswerOutcome, code: ErrorCode, ctx: &Ctx<'_>) -> bool {
match (outcome, code) {
(AnswerOutcome::BadRequest, ErrorCode::WhatifUnsupported) => ctx.solve().is_some(),
(AnswerOutcome::BadRequest, ErrorCode::SliceMember) => ctx.whatif(),
_ => true,
}
}
pub fn check_answer(status: u16, body: &[u8], keys: &Keys, request: &Request) -> Result<Answer> {
let v = json::parse(body)?;
check_value(status, &v, keys, &Ctx::Cell(request), "$")
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct SliceRequest {
slice_id: String,
asof: Option<String>,
pin: Option<String>,
mesh: Option<String>,
after: Option<BTreeMap<String, Scalar>>,
}
impl SliceRequest {
pub fn new(slice_id: &str, asof: Option<&str>) -> core::result::Result<SliceRequest, crate::InvalidRequest> {
let r = Request::new(slice_id, asof)?;
Ok(SliceRequest { slice_id: r.cell_id, asof: r.asof, pin: None, mesh: None, after: None })
}
pub fn with_pin(self, fn_hash: &str) -> core::result::Result<SliceRequest, crate::InvalidRequest> {
let r = Request::new(&self.slice_id, None)?.with_pin(fn_hash)?;
Ok(SliceRequest { pin: r.pin, ..self })
}
pub fn with_mesh(self, host: &str) -> core::result::Result<SliceRequest, crate::InvalidRequest> {
let r = Request::new(&self.slice_id, None)?.with_mesh(host)?;
Ok(SliceRequest { mesh: r.mesh, ..self })
}
pub fn with_after(self, after: BTreeMap<String, Scalar>) -> SliceRequest {
SliceRequest { after: Some(after), ..self }
}
pub fn slice_id(&self) -> &str {
&self.slice_id
}
pub fn asof(&self) -> Option<&str> {
self.asof.as_deref()
}
pub fn fn_hash(&self) -> Option<&str> {
self.pin.as_deref()
}
pub fn mesh(&self) -> Option<&str> {
self.mesh.as_deref()
}
pub fn after(&self) -> Option<&BTreeMap<String, Scalar>> {
self.after.as_ref()
}
}
pub fn check_slice_answer(status: u16, body: &[u8], keys: &Keys, request: &SliceRequest) -> Result<Answer> {
let v = json::parse(body)?;
check_value(status, &v, keys, &Ctx::Slice(request), "$")
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Batch {
Items(Vec<Result<Answer>>),
Refused(Box<Answer>),
}
pub fn check_batch(status: u16, body: &[u8], keys: &Keys, requests: &[Request]) -> Result<Batch> {
let v = json::parse(body)?;
if status != 200 {
if !matches!(v, Value::Object(_)) {
return env_err("$", "a refused batch is one envelope");
}
let a = check_value(status, &v, keys, &Ctx::None, "$")?;
if !matches!(
a.outcome,
AnswerOutcome::Unlicensed
| AnswerOutcome::PaymentRequired
| AnswerOutcome::RateLimited
| AnswerOutcome::BadRequest
| AnswerOutcome::Error
) {
return env_err(
"$.outcome",
"a batch is refused with unlicensed, payment_required, rate_limited, bad_request or error",
);
}
return Ok(Batch::Refused(Box::new(a)));
}
let Value::Array(items) = &v else { return env_err("$", "a batch answer is an array") };
if items.len() != requests.len() {
return env_err("$", format!("{} items for {} requests", items.len(), requests.len()));
}
let mut parts = Vec::with_capacity(items.len());
for (i, item) in items.iter().enumerate() {
let p = format!("$[{i}]");
let m = schema::object_or(item, &p, ErrorCode::Envelope, "an item")?;
schema::exact(m, &["envelope", "status"], &[], &p, ErrorCode::Envelope)?;
let st = integer_member(schema::get(m, "status"), &format!("{p}.status"))?;
if !(100..=599).contains(&st) {
return env_err(&format!("{p}.status"), "an item's status is 100-599");
}
parts.push((schema::get(m, "envelope"), st as u16));
}
Ok(Batch::Items(
parts
.into_iter()
.zip(requests)
.enumerate()
.map(|(i, ((env, st), req))| check_value(st, env, keys, &Ctx::Cell(req), &format!("$[{i}].envelope")))
.collect(),
))
}
pub fn batch_body(items: &[(u16, Answer)]) -> Vec<u8> {
let n = |x: u16| json::parse(x.to_string().as_bytes()).unwrap_or(Value::Null);
Value::Array(
items
.iter()
.map(|(st, a)| Value::Object(vec![("envelope".into(), a.to_value()), ("status".into(), n(*st))]))
.collect(),
)
.to_jcs()
}
fn nested(e: Error, prefix: &str) -> Error {
if prefix == "$" {
return e;
}
let inner = e.path().strip_prefix('$').unwrap_or(e.path());
Error::new(e.code(), format!("{prefix}{inner}"), e.detail())
}
fn check_value(status: u16, v: &Value, keys: &Keys, ctx: &Ctx<'_>, at: &str) -> Result<Answer> {
check_inner(status, v, keys, ctx).map_err(|e| nested(e, at))
}
fn url_host(u: &str) -> Option<&str> {
let rest = u.strip_prefix("https://")?;
if u.len() > limits::LICENCE_URL || !rest.bytes().all(|c| (0x21..=0x7E).contains(&c)) {
return None;
}
let (host, _) = rest.split_once('/')?;
lexical::check_dns_name(host, "").ok().map(|()| host)
}
fn check_inner(status: u16, v: &Value, keys: &Keys, ctx: &Ctx<'_>) -> Result<Answer> {
let m = match v {
Value::Object(m) if matches!(schema::opt(m, "outcome"), Some(Value::String(_))) => m,
_ => return env_err("$", "an envelope is an object with a string outcome"),
};
let oname = schema::get(m, "outcome").as_str().unwrap_or("");
let Some(outcome) = AnswerOutcome::from_name(oname) else {
return env_err("$.outcome", format!("unknown outcome {oname:?}"));
};
let slice_ctx = matches!(ctx, Ctx::Slice(_));
if slice_ctx && matches!(outcome, AnswerOutcome::Stale | AnswerOutcome::Pending) {
return env_err("$.outcome", "stale and pending are not answers of the slice endpoint");
}
let whatif = ctx.whatif();
if whatif && matches!(outcome, AnswerOutcome::Ok | AnswerOutcome::Stale | AnswerOutcome::Pending) {
return env_err("$.outcome", format!("{oname} is not an answer to a whatif request"));
}
if outcome == AnswerOutcome::Scenario && !whatif {
return env_err("$.outcome", "scenario is the answer to a request with overrides");
}
if outcome == AnswerOutcome::Pending {
return check_pending(status, m, ctx);
}
let is_page = slice_ctx && outcome == AnswerOutcome::Ok;
let mut a = check_members(m, outcome, ctx, is_page)?;
if !outcome.status_ok(status) {
return env_err("$.outcome", format!("status {status} does not match outcome {oname}"));
}
if a.error == Some(ErrorCode::ForeignUnavailable) && status != 502 {
return env_err("$.outcome", format!("E_FOREIGN_UNAVAILABLE is answered with 502, not {status}"));
}
a.status = status;
pin_echo(&a, ctx.pin(), "$.fn_hash")?;
if is_page {
let Ctx::Slice(req) = ctx else { return env_err("$", "a page answers a slice request") };
return check_page(m, a, keys, req);
}
if outcome == AnswerOutcome::Scenario {
if let Ctx::Cell(req) = ctx {
bind_scenario(&a, req)?;
}
return Ok(a);
}
if let Some(rv) = schema::opt(m, "receipt") {
a.receipt = Some(member_receipt(rv, keys, "$.receipt")?);
}
if let Ctx::Cell(req) = ctx {
bind_cell(&a, req)?;
}
if let Some(r) = &a.receipt {
trust_check(&a, r, ctx.mesh(), "$")?;
}
Ok(a)
}
fn member_receipt(rv: &Value, keys: &Keys, path: &str) -> Result<Receipt> {
crate::verify::signature_valid_value(rv, keys).map_err(|(e, _)| {
let inner = e.path().strip_prefix('$').unwrap_or(e.path());
Error::new(e.code(), format!("{path}{inner}"), e.detail())
})
}
fn outcome_has_resolved(outcome: AnswerOutcome) -> bool {
matches!(
outcome,
AnswerOutcome::Ok
| AnswerOutcome::Stale
| AnswerOutcome::NotCovered
| AnswerOutcome::Unlicensed
| AnswerOutcome::PaymentRequired
| AnswerOutcome::Error
| AnswerOutcome::Scenario
)
}
fn resolved_of(v: &Value) -> Result<Resolved> {
let m = schema::object_or(v, "$.resolved", ErrorCode::Envelope, "resolved")?;
schema::exact(m, &["call", "resolutions"], &["aliases_tx"], "$.resolved", ErrorCode::Envelope)?;
let call = schema::string_or(m, "call", "$.resolved", ErrorCode::Envelope)?;
let Value::Array(items) = schema::get(m, "resolutions") else {
return env_err("$.resolved.resolutions", "resolutions is an array");
};
let mut resolutions = Vec::with_capacity(items.len());
for (i, item) in items.iter().enumerate() {
let p = format!("$.resolved.resolutions[{i}]");
let rm = schema::object_or(item, &p, ErrorCode::Envelope, "a resolution")?;
let (required, optional): (&[&str], &[&str]) = match schema::opt(rm, "kind").and_then(Value::as_str) {
Some("lookup") => (&["from", "kind", "to", "asof"], &[]),
_ => (&["from", "kind", "to"], &[]),
};
schema::exact(rm, required, optional, &p, ErrorCode::Envelope)?;
let from = schema::string_or(rm, "from", &p, ErrorCode::Envelope)?;
let kind_text = schema::string_or(rm, "kind", &p, ErrorCode::Envelope)?;
let to = schema::string_or(rm, "to", &p, ErrorCode::Envelope)?;
let Some(kind) = ResolutionKind::from_name(kind_text) else {
return env_err(&p, format!("kind {kind_text:?} is not a resolution kind"));
};
let resolution = match kind {
ResolutionKind::Lookup => {
let asof = schema::string_or(rm, "asof", &p, ErrorCode::Envelope)?;
Resolution::lookup(from, to, asof)
}
_ => Resolution::new(from, kind, to),
};
resolutions.push(resolution.map_err(|e| e.recode(ErrorCode::Envelope))?);
}
let mut out = Resolved::new(call, resolutions).map_err(|e| e.recode(ErrorCode::Envelope))?;
if let Some(t) = schema::opt(m, "aliases_tx") {
let t = t.as_str().unwrap_or("");
out = out.with_aliases_tx(t).map_err(|e| e.recode(ErrorCode::Envelope))?;
}
Ok(out)
}
fn check_members(m: &[(String, Value)], outcome: AnswerOutcome, ctx: &Ctx<'_>, is_page: bool) -> Result<Answer> {
let (req, opt): (&[&str], &[&str]) =
if is_page { (&["members", "slice"], &["next", "fn_hash"]) } else { outcome.members() };
let mut allowed: Vec<&str> = vec!["outcome"];
allowed.extend_from_slice(req);
schema::exact(m, &allowed, opt, "$", ErrorCode::Envelope)?;
let mut a = bare(outcome);
if let Some(r) = schema::opt(m, "receipt") {
if !matches!(r, Value::Object(_)) {
return env_err("$.receipt", "receipt is a receipt object");
}
}
if let Some(t) = schema::opt(m, "trust") {
a.trust = match t.as_str().and_then(TrustLabel::from_name) {
Some(t) => Some(t),
None => return env_err("$.trust", "trust is primary, computed, verified or unverified"),
};
}
if let Some(x) = schema::opt(m, "age_seconds") {
a.age_seconds = Some(integer_member(x, "$.age_seconds")?);
}
if let Some(x) = schema::opt(m, "retry_after_seconds") {
a.retry_after_seconds = Some(integer_member(x, "$.retry_after_seconds")?);
}
if let Some(s) = schema::opt(m, "superseded_by") {
let s = s.as_str().unwrap_or("");
lexical::check_hex(s, 64, "$.superseded_by").map_err(|e| e.recode(ErrorCode::Envelope))?;
a.superseded_by = Some(s.into());
}
if let Some(r) = schema::opt(m, "reason") {
let Some(r) = r.as_str() else { return env_err("$.reason", "reason must be a string") };
if schema::opt(m, "superseded_by").is_none() {
return env_err("$.reason", "reason is only present with superseded_by");
}
lexical::check_text(r, limits::SUMMARY, false, "$.reason").map_err(|e| e.recode(ErrorCode::Envelope))?;
if r.is_empty() {
return env_err("$.reason", "reason must not be empty");
}
a.reason = Some(r.into());
}
if let Some(q) = schema::opt(m, "quote") {
a.quote = Some(quote(q)?);
}
if let Some(e) = schema::opt(m, "error") {
let code = e.as_str().and_then(ErrorCode::from_code);
match code {
Some(c) if code_allowed(outcome, c, ctx.job_url()) && whatif_code_ok(outcome, c, ctx) => a.error = Some(c),
_ => return env_err("$.error", format!("{e:?} is not a code this outcome can carry")),
}
}
if let Some(sc) = schema::opt(m, "scenario") {
a.scenario = Some(scenario_of(sc)?);
}
if let Some(c) = schema::opt(m, "cycle") {
let cycle = cycle_of(c)?;
a = a.with_cycle(cycle)?;
}
if let Some(r) = schema::opt(m, "resolved") {
a.resolved = Some(resolved_of(r)?);
}
if let Some(sh) = schema::opt(m, "shadows") {
let sm = schema::object_or(sh, "$.shadows", ErrorCode::Envelope, "shadows")?;
schema::exact(sm, &["class", "reference"], &[], "$.shadows", ErrorCode::Envelope)?;
let class = schema::string_or(sm, "class", "$.shadows", ErrorCode::Envelope)?;
let reference = schema::string_or(sm, "reference", "$.shadows", ErrorCode::Envelope)?;
a.shadows = Some(Shadows::new(class, reference).map_err(|e| e.recode(ErrorCode::Envelope))?);
}
if let Some(d) = schema::opt(m, "detail") {
let Some(detail) = d.as_str().and_then(ForeignDetail::from_name) else {
return env_err("$.detail", format!("{d:?} is not a detail of E_FOREIGN_UNAVAILABLE"));
};
a.detail = Some(detail);
}
if (a.error == Some(ErrorCode::ForeignUnavailable)) != a.detail.is_some() {
return env_err("$.detail", "detail is present exactly when error is E_FOREIGN_UNAVAILABLE");
}
if let Some(f) = schema::opt(m, "fault") {
let Some(fault) = f.as_str().and_then(Fault::from_code) else {
return env_err("$.fault", format!("{f:?} is not a formula evaluation fault"));
};
if a.error.is_some() {
return env_err("$.fault", "not_covered carries a fault or an error, not both");
}
if fault == Fault::WhatifNoSolution && ctx.solve().is_none() {
return env_err("$.fault", "E_WHATIF_NO_SOLUTION answers a whatif request with solve");
}
a.fault = Some(fault);
}
if let Some(h) = schema::opt(m, "fn_hash") {
let h = h.as_str().unwrap_or("");
lexical::check_hex(h, 64, "$.fn_hash").map_err(|e| e.recode(ErrorCode::Envelope))?;
a.fn_hash = Some(h.into());
}
if let Some(n) = schema::opt(m, "next") {
let shape = n.as_str().is_some_and(|u| url_host(u).is_some() || lexical::loopback_origin(u).is_some());
if !shape {
return env_err(
"$.next",
"next is https://, a DNS name, then a path, or a loopback URL, at most 512 characters",
);
}
}
Ok(a)
}
fn bind_cell(a: &Answer, req: &Request) -> Result<()> {
let Some(r) = &a.receipt else { return Ok(()) };
if r.cell().id() != req.cell_id {
return env_err("$.receipt.cell", "the receipt is for another cell than the one requested");
}
if let Some(asked) = &req.asof {
if r.asof() > asked.as_str() {
return env_err("$.receipt.asof", "the receipt's asof is after the requested asof");
}
}
Ok(())
}
fn pin_echo(a: &Answer, pin: Option<&str>, path: &str) -> Result<()> {
if let Some(p) = pin {
match &a.fn_hash {
Some(h) if h != p => return env_err(path, "the fn_hash echo is not the pin"),
None if !matches!(a.outcome, AnswerOutcome::RateLimited | AnswerOutcome::BadRequest) => {
return env_err(path, "an answer to a pinned request echoes the pin");
}
_ => {}
}
}
Ok(())
}
fn trust_check(a: &Answer, r: &Receipt, mesh: Option<&str>, at: &str) -> Result<()> {
let p = |m: &str| format!("{at}.{m}");
let own = r.signer_host() == lexical::host_of(&r.cell().ns) && r.inputs().is_empty();
let primary = own && r.source().is_none();
let relayed = own && r.source().is_some();
let t = a.trust.unwrap_or(TrustLabel::Unverified);
if (t == TrustLabel::Primary) != primary {
return env_err(
&p("trust"),
if primary { "a primary receipt is labelled primary" } else { "the receipt is not primary" },
);
}
if (t == TrustLabel::Relayed) != relayed {
return env_err(
&p("trust"),
if relayed { "a relayed receipt is labelled relayed" } else { "the receipt is not relayed" },
);
}
if let Some(host) = mesh {
match t {
TrustLabel::Computed if r.signer_host() != host => {
return env_err(&p("trust"), "computed: the receipt is signed by another host than the one asked");
}
TrustLabel::Verified | TrustLabel::Unverified if r.signer_host() == host => {
return env_err(&p("trust"), "the mesh asked signed this receipt: its trust is computed");
}
_ => {}
}
}
if a.fn_hash.as_deref().is_some_and(|h| h != r.cell().fn_hash) {
return env_err(&p("fn_hash"), "fn_hash differs from the receipt's cell.fn_hash");
}
if a.superseded_by.as_deref() == Some(r.hash()) {
return env_err(&p("superseded_by"), "a receipt cannot supersede itself");
}
Ok(())
}
fn check_pending(status: u16, m: &[(String, Value)], ctx: &Ctx<'_>) -> Result<Answer> {
schema::exact(m, &["estimate_seconds", "job", "outcome", "poll", "request"], &[], "$", ErrorCode::Envelope)?;
let estimate = integer_member(schema::get(m, "estimate_seconds"), "$.estimate_seconds")?;
let Some(job) = schema::get(m, "job").as_str() else { return env_err("$.job", "job must be a string") };
let Some(poll) = schema::get(m, "poll").as_str() else { return env_err("$.poll", "poll must be a string") };
check_job_and_poll_for(job, poll, ctx.mesh())?;
let rm = schema::object_or(schema::get(m, "request"), "$.request", ErrorCode::Envelope, "request")?;
schema::exact(rm, &["cell_id"], &["asof", "fn_hash"], "$.request", ErrorCode::Envelope)?;
let cell_id = schema::string_or(rm, "cell_id", "$.request", ErrorCode::Envelope)?;
let opt = |name: &str| -> Result<Option<&str>> {
match schema::opt(rm, name) {
None => Ok(None),
Some(_) => schema::string_or(rm, name, "$.request", ErrorCode::Envelope).map(Some),
}
};
let invalid = |e: crate::InvalidRequest| Error::new(ErrorCode::Envelope, "$.request", e.to_string());
let mut echoed = Request::new(cell_id, opt("asof")?).map_err(invalid)?;
if let Some(p) = opt("fn_hash")? {
echoed = echoed.with_pin(p).map_err(invalid)?;
}
if status != Pending::STATUS {
return env_err("$.outcome", format!("status {status} does not match outcome pending"));
}
let Ctx::Cell(request) = ctx else { return env_err("$.outcome", "pending answers a cell request") };
if echoed.cell_id != request.cell_id || echoed.asof != request.asof || echoed.pin != request.pin {
return env_err("$.request", "the echoed request is not the request made");
}
if let Some(polled) = &request.job {
if job != polled {
return env_err("$.job", "the envelope is for another job than the one polled");
}
}
if let (Some(host), false) = (&request.mesh, poll.starts_with("http://")) {
if url_host(poll) != Some(host.as_str()) {
return env_err("$.poll", "poll is on another host than the one asked");
}
}
let with_mesh = Request { mesh: request.mesh.clone(), ..echoed };
let p = Pending::new(job, estimate, poll, with_mesh)?;
Ok(Answer { pending: Some(p), ..bare(AnswerOutcome::Pending) })
}
fn key_of(r: &Receipt, names: &[String]) -> Vec<Scalar> {
names.iter().filter_map(|n| r.cell().args.get(n).and_then(Arg::scalar).cloned()).collect()
}
fn cmp_keys(a: &[Scalar], b: &[Scalar]) -> core::cmp::Ordering {
for (x, y) in a.iter().zip(b) {
let o = if x.ty() == y.ty() { cmp_lexical(x.ty(), x.lexical(), y.lexical()) } else { x.ty().cmp(&y.ty()) };
if o != core::cmp::Ordering::Equal {
return o;
}
}
a.len().cmp(&b.len())
}
fn check_page(m: &[(String, Value)], mut a: Answer, keys: &Keys, req: &SliceRequest) -> Result<Answer> {
let Value::Array(items) = schema::get(m, "members") else {
return env_err("$.members", "members is an array of envelopes");
};
let slice = Slice::from_value(schema::get(m, "slice")).map_err(|e| e.recode(ErrorCode::Envelope))?;
let next = schema::opt(m, "next").and_then(Value::as_str).map(String::from);
if slice.id() != req.slice_id {
return env_err("$.slice", "the page is of another slice than the one requested");
}
if a.fn_hash.as_deref().is_some_and(|h| h != slice.fn_hash()) {
return env_err("$.fn_hash", "fn_hash differs from the slice's");
}
if let Some(n) = &next {
if n.starts_with("http://") {
if !req.mesh.as_deref().is_some_and(lexical::is_unrooted) {
return env_err("$.next", "a loopback next is only for an unrooted mesh the request names");
}
} else if let Some(host) = &req.mesh {
if url_host(n) != Some(host.as_str()) {
return env_err("$.next", "next is on another host than the one asked");
}
}
}
let names = slice.key_names();
let mut last: Option<Vec<Scalar>> = match &req.after {
None => None,
Some(after) => {
let key: Vec<Scalar> = names.iter().filter_map(|n| after.get(n).cloned()).collect();
if key.len() != names.len() {
return env_err("$", "the cursor lacks an open argument of the slice");
}
Some(key)
}
};
let mut out = Vec::with_capacity(items.len());
for (i, item) in items.iter().enumerate() {
let p = format!("$.members[{i}]");
let mm = match item {
Value::Object(mm) => mm,
_ => return env_err(&p, "a member is an envelope"),
};
let o = match schema::get(mm, "outcome").as_str().and_then(AnswerOutcome::from_name) {
Some(o @ (AnswerOutcome::Ok | AnswerOutcome::Stale)) => o,
_ => return env_err(&p, "a member is an ok or stale envelope"),
};
let mut ma = check_members(mm, o, &Ctx::None, false).map_err(|e| nested(e, &p))?;
let r = member_receipt(schema::get(mm, "receipt"), keys, &format!("{p}.receipt"))?;
if !slice.contains(&r) {
return env_err(&p, "the member's cell is not a member of the slice");
}
if let Some(asked) = &req.asof {
if r.asof() > asked.as_str() {
return env_err(&format!("{p}.receipt.asof"), "the member's asof is after the requested asof");
}
}
trust_check(&ma, &r, req.mesh.as_deref(), &p)?;
let key = key_of(&r, &names);
if let Some(prev) = &last {
if key.len() != prev.len() || key.iter().zip(prev).any(|(x, y)| x.ty() != y.ty()) {
return env_err(&p, "the member's key has other types than the previous key (or the cursor)");
}
if cmp_keys(&key, prev) != core::cmp::Ordering::Greater {
return env_err(&p, "members are in strictly ascending key order, after the cursor");
}
}
last = Some(key);
ma.receipt = Some(r);
out.push(ma);
}
a.page = Some(SlicePage { slice, members: out, next });
Ok(a)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum CycleFix {
Asof,
Lag,
Step,
Solver,
}
impl CycleFix {
pub const ALL: &'static [CycleFix] = &[CycleFix::Asof, CycleFix::Lag, CycleFix::Step, CycleFix::Solver];
pub const fn as_str(self) -> &'static str {
match self {
CycleFix::Asof => "asof",
CycleFix::Lag => "lag",
CycleFix::Step => "step",
CycleFix::Solver => "solver",
}
}
pub fn from_name(s: &str) -> Option<CycleFix> {
CycleFix::ALL.iter().copied().find(|f| f.as_str() == s)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct Cycle {
path: Vec<String>,
fixes: Vec<CycleFix>,
}
impl Cycle {
pub fn new(path: Vec<String>, fixes: Vec<CycleFix>) -> Result<Cycle> {
if path.len() < 2 {
return env_err("$.cycle.path", "a cycle's path has at least two calls");
}
if path.first() != path.last() {
return env_err("$.cycle.path", "a cycle's path starts and ends with the same call");
}
if path.iter().any(String::is_empty) {
return env_err("$.cycle.path", "a call is a non-empty string");
}
if fixes.is_empty() {
return env_err("$.cycle.fixes", "a cycle names at least one fix");
}
if fixes.windows(2).any(|w| w[0] >= w[1]) {
return env_err("$.cycle.fixes", "fixes are distinct and in the order asof, lag, step, solver");
}
Ok(Cycle { path, fixes })
}
pub fn path(&self) -> &[String] {
&self.path
}
pub fn fixes(&self) -> &[CycleFix] {
&self.fixes
}
fn to_value(&self) -> Value {
let strings = |xs: Vec<&str>| Value::Array(xs.into_iter().map(|x| Value::String(x.into())).collect());
Value::Object(vec![
("path".into(), strings(self.path.iter().map(String::as_str).collect())),
("fixes".into(), strings(self.fixes.iter().map(|f| f.as_str()).collect())),
])
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Solved {
vary: Cell,
value: Scalar,
}
impl Solved {
pub fn vary(&self) -> &Cell {
&self.vary
}
pub fn value(&self) -> &Scalar {
&self.value
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Scenario {
cell: Cell,
value: Scalar,
asof: String,
overrides: Overrides,
solved: Option<Solved>,
}
impl Scenario {
pub fn new(cell: Cell, value: Scalar, asof: &str, overrides: &Value) -> Result<Scenario> {
lexical::check_instant(asof, "$.scenario.asof").map_err(|e| e.recode(ErrorCode::Envelope))?;
check_overrides(overrides)?;
Ok(Scenario { cell, value, asof: asof.into(), overrides: Overrides(overrides.clone()), solved: None })
}
pub fn with_solved(self, vary: Cell, value: Scalar) -> Result<Scenario> {
if vary.is_slice() {
return env_err("$.scenario.solved.vary", "the varied cell is one cell, not a slice");
}
if value.ty() != Type::Number {
return env_err("$.scenario.solved.value", "the value found is a number");
}
Ok(Scenario { solved: Some(Solved { vary, value }), ..self })
}
pub fn cell(&self) -> &Cell {
&self.cell
}
pub fn value(&self) -> &Scalar {
&self.value
}
pub fn ty(&self) -> Type {
self.value.ty()
}
pub fn asof(&self) -> &str {
&self.asof
}
pub fn overrides(&self) -> &Value {
&self.overrides.0
}
pub fn solved(&self) -> Option<&Solved> {
self.solved.as_ref()
}
fn to_value(&self) -> Value {
let raw = match &self.value {
Scalar::Boolean(b) => Value::Bool(*b),
other => Value::String(other.lexical().to_string()),
};
let mut m = vec![
("asof".to_string(), Value::String(self.asof.clone())),
("cell".to_string(), self.cell.to_value()),
("overrides".to_string(), self.overrides.0.clone()),
("type".to_string(), Value::String(self.value.ty().as_str().into())),
("value".to_string(), raw),
];
if let Some(x) = &self.solved {
m.push((
"solved".into(),
Value::Object(vec![("vary".into(), x.vary.to_value()), ("value".into(), x.value.to_value())]),
));
}
Value::Object(m)
}
}
fn cell_of(v: &Value, path: &str) -> Result<Cell> {
let c = Cell::from_value(v).map_err(|e| e.recode(ErrorCode::Envelope))?;
if c.is_slice() {
return env_err(path, "a cell, not a slice");
}
Ok(c)
}
fn typed_value(ty: Type, v: &Value, path: &str) -> Result<Scalar> {
match (ty, v) {
(Type::Boolean, Value::Bool(b)) => Ok(Scalar::Boolean(*b)),
(Type::Boolean, _) => env_err(path, "a boolean value is true or false"),
(t, Value::String(text)) => Scalar::from_lexical(t, text).map_err(|e| e.recode(ErrorCode::Envelope)),
_ => env_err(path, "a value is a string in its type's lexical form"),
}
}
fn ascending(prev: &mut Option<String>, id: String, path: &str) -> Result<()> {
if prev.as_deref().is_some_and(|q| q >= id.as_str()) {
return env_err(path, "entries are distinct and sorted by cell id");
}
*prev = Some(id);
Ok(())
}
fn override_id(item: &Value, p: &str) -> Result<String> {
let m = schema::object_or(item, p, ErrorCode::Envelope, "an override")?;
if schema::opt(m, "slice").is_none() {
schema::exact(m, &["cell", "value"], &[], p, ErrorCode::Envelope)?;
let cell = cell_of(schema::get(m, "cell"), &format!("{p}.cell"))?;
scalar_canonical(schema::get(m, "value"), &format!("{p}.value")).map_err(|e| e.recode(ErrorCode::Envelope))?;
return Ok(cell.id());
}
schema::exact(m, &["add", "remove", "slice"], &[], p, ErrorCode::Envelope)?;
let slice = Slice::from_value(schema::get(m, "slice")).map_err(|e| e.recode(ErrorCode::Envelope))?;
let Value::Array(added) = schema::get(m, "add") else { return env_err(p, "add is an array of members") };
let mut prev = None;
for (i, a) in added.iter().enumerate() {
let ap = format!("{p}.add[{i}]");
let am = schema::object_or(a, &ap, ErrorCode::Envelope, "an added member")?;
schema::exact(am, &["cell", "value"], &[], &ap, ErrorCode::Envelope)?;
let cell = cell_of(schema::get(am, "cell"), &format!("{ap}.cell"))?;
scalar_canonical(schema::get(am, "value"), &format!("{ap}.value"))
.map_err(|e| e.recode(ErrorCode::Envelope))?;
ascending(&mut prev, cell.id(), &ap)?;
}
let Value::Array(removed) = schema::get(m, "remove") else { return env_err(p, "remove is an array of cells") };
let mut prev = None;
for (i, r) in removed.iter().enumerate() {
let rp = format!("{p}.remove[{i}]");
let cell = cell_of(r, &rp)?;
ascending(&mut prev, cell.id(), &rp)?;
}
Ok(slice.id().to_string())
}
pub(crate) fn check_overrides(v: &Value) -> Result<()> {
let Value::Array(items) = v else { return env_err("$.overrides", "overrides is an array") };
if items.len() > 64 {
return env_err("$.overrides", "at most 64 overrides");
}
let mut prev = None;
for (i, item) in items.iter().enumerate() {
let p = format!("$.overrides[{i}]");
let id = override_id(item, &p)?;
ascending(&mut prev, id, &p)?;
}
Ok(())
}
fn scenario_of(v: &Value) -> Result<Scenario> {
let m = schema::object_or(v, "$.scenario", ErrorCode::Envelope, "scenario")?;
schema::exact(m, &["asof", "cell", "overrides", "type", "value"], &["solved"], "$.scenario", ErrorCode::Envelope)?;
let cell = cell_of(schema::get(m, "cell"), "$.scenario.cell")?;
let ty_name = schema::string_or(m, "type", "$.scenario", ErrorCode::Envelope)?;
let Some(ty) = Type::from_name(ty_name) else {
return env_err("$.scenario.type", format!("{ty_name:?} is not a type"));
};
let value = typed_value(ty, schema::get(m, "value"), "$.scenario.value")?;
let asof = schema::string_or(m, "asof", "$.scenario", ErrorCode::Envelope)?;
let mut sc = Scenario::new(cell, value, asof, schema::get(m, "overrides"))?;
if let Some(sv) = schema::opt(m, "solved") {
let sm = schema::object_or(sv, "$.scenario.solved", ErrorCode::Envelope, "solved")?;
schema::exact(sm, &["vary", "value"], &[], "$.scenario.solved", ErrorCode::Envelope)?;
let vary = cell_of(schema::get(sm, "vary"), "$.scenario.solved.vary")?;
let value = scalar_canonical(schema::get(sm, "value"), "$.scenario.solved.value")
.map_err(|e| e.recode(ErrorCode::Envelope))?;
sc = sc.with_solved(vary, value)?;
}
Ok(sc)
}
fn cycle_of(v: &Value) -> Result<Cycle> {
let m = schema::object_or(v, "$.cycle", ErrorCode::Envelope, "cycle")?;
schema::exact(m, &["fixes", "path"], &[], "$.cycle", ErrorCode::Envelope)?;
let Value::Array(calls) = schema::get(m, "path") else { return env_err("$.cycle.path", "path is an array") };
let mut path = Vec::with_capacity(calls.len());
for (i, c) in calls.iter().enumerate() {
let Some(t) = c.as_str() else { return env_err(&format!("$.cycle.path[{i}]"), "a call is a string") };
path.push(t.to_string());
}
let Value::Array(names) = schema::get(m, "fixes") else { return env_err("$.cycle.fixes", "fixes is an array") };
let mut fixes = Vec::with_capacity(names.len());
for (i, f) in names.iter().enumerate() {
match f.as_str().and_then(CycleFix::from_name) {
Some(fix) => fixes.push(fix),
None => return env_err(&format!("$.cycle.fixes[{i}]"), "a fix is asof, lag, step or solver"),
}
}
Cycle::new(path, fixes)
}
fn bind_scenario(a: &Answer, req: &Request) -> Result<()> {
let Some(s) = &a.scenario else { return Ok(()) };
if s.cell.id() != req.cell_id {
return env_err("$.scenario.cell", "the scenario is for another cell than the one requested");
}
if req.asof.as_deref().is_some_and(|asked| asked != s.asof) {
return env_err("$.scenario.asof", "the scenario's asof is not the requested asof");
}
let asked = req.overrides.as_ref().map(|o| o.0.to_jcs()).unwrap_or_default();
if s.overrides.0.to_jcs() != asked {
return env_err("$.scenario.overrides", "the scenario's overrides are not the request's");
}
match (&s.solved, req.solve.as_deref()) {
(Some(x), Some(v)) if x.vary.id() == v => Ok(()),
(None, None) => Ok(()),
_ => env_err("$.scenario.solved", "solved is present exactly when solve was sent, for the vary cell"),
}
}