use std::future::Future;
use std::task::Poll;
use plexus_auth_core::grants::{Gate, Reach, Refusal};
use super::context::PlexusContext;
use super::plexus::PlexusError;
use super::streaming::PlexusStream;
use super::types::{PlexusStreamItem, StreamMetadata};
use crate::call::CallContext;
pub(crate) fn redecide(gate: &Gate, reach: &Reach, targets: &[String]) -> Result<(), Refusal> {
if !targets.is_empty() {
for t in targets {
if !reach.allows(t) {
let why = reach.recheck().err().or_else(|| gate.check(reach.caller(), reach.grant()?, Some(t)).err());
return Err(why.unwrap_or(Refusal::Unauthenticated));
}
}
return Ok(());
}
let now = reach.recheck()?;
if now.is_everywhere() {
return Ok(());
}
match reach.held_on().iter().find(|s| !now.held_on().contains(s)) {
None => Ok(()),
Some(lost) => {
let grant = reach.grant().cloned().unwrap_or_else(|| plexus_auth_core::grants::Grant::new(""));
let roles = gate.roles_listing(&grant);
Err(Refusal::MissingGrant { grant, scope: lost.clone(), roles, held_on: now.held_on().to_vec() })
}
}
}
pub(crate) fn redecide_body(gate: &Gate, reach: &Reach, targets: &[String]) -> Result<(), Refusal> {
if !targets.is_empty() {
return redecide(gate, reach, targets);
}
reach.recheck().map(|_| ())
}
fn end_item(ns: &str, e: &PlexusError) -> PlexusStreamItem {
PlexusStreamItem::from_plexus_error(StreamMetadata::new(vec![ns.into()], PlexusContext::hash()), e, false)
}
type Wait = std::pin::Pin<Box<dyn Future<Output = Woke> + Send>>;
enum Woke {
Moved,
Expired,
}
#[derive(Clone, Copy)]
enum Ends {
Unread,
Never,
At(std::time::SystemTime),
}
const CLOCK_EVERY: u8 = 64;
fn expired() -> PlexusError {
PlexusError::Unauthenticated("your sign-in has expired: sign in again".into())
}
pub(crate) fn held(ctx: CallContext, service: super::plexus::DynamicHub, seen: u64, owed: bool, targets: Vec<String>, inner: PlexusStream) -> PlexusStream {
if service.gate().is_none() {
return Box::pin(crate::call::InCall::new(ctx, inner));
}
Box::pin(Held { ctx, service, seen, targets, inner: Some(inner), wait: None, ends: Ends::Unread, items: 0, owed: if owed { Owed::FirstItem } else { Owed::No } })
}
struct Held {
ctx: CallContext,
service: super::plexus::DynamicHub,
seen: u64,
targets: Vec<String>,
inner: Option<PlexusStream>,
wait: Option<Wait>,
ends: Ends,
items: u8,
owed: Owed,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Owed {
No,
FirstItem,
Now,
}
impl Ends {
fn at(&mut self, ctx: &CallContext) -> Option<std::time::SystemTime> {
if let Ends::Unread = self {
let at = ctx.auth().and_then(|a| a.metadata.get(plexus_auth_core::auth::EXPIRES_AT_KEY)).and_then(serde_json::Value::as_i64);
*self = match at {
Some(at) => Ends::At(std::time::UNIX_EPOCH + std::time::Duration::from_secs(at.max(0) as u64)),
None => Ends::Never,
};
}
match self {
Ends::At(t) => Some(*t),
_ => None,
}
}
fn over(&mut self, ctx: &CallContext) -> bool {
self.at(ctx).is_some_and(|t| std::time::SystemTime::now() >= t)
}
}
fn end(inner: &mut Option<PlexusStream>, wait: &mut Option<Wait>, ns: &str, e: PlexusError) -> Poll<Option<PlexusStreamItem>> {
*inner = None;
*wait = None;
Poll::Ready(Some(end_item(ns, &e)))
}
fn wait_for(generation: &plexus_auth_core::grants::GrantsGeneration, ends: Option<std::time::SystemTime>) -> Wait {
let mut moves = generation.subscribe();
Box::pin(async move {
let expiry = async move {
match ends.map(|t| t.duration_since(std::time::SystemTime::now()).unwrap_or_default()) {
Some(left) => crate::rt::sleep(left).await,
None => std::future::pending::<()>().await,
}
};
let moved = async move {
if moves.changed().await.is_err() {
std::future::pending::<()>().await;
}
};
tokio::select! {
biased;
() = moved => Woke::Moved,
() = expiry => Woke::Expired,
}
})
}
pub(crate) async fn routing<F>(ctx: &CallContext, service: &super::plexus::DynamicHub, seen: &mut u64, owed: &mut bool, targets: Option<&[String]>, routed: F) -> Result<PlexusStream, PlexusError>
where
F: Future<Output = Result<PlexusStream, PlexusError>>,
{
crate::call::hook_moves();
let (Some(targets), Some(gate)) = (targets, service.gate()) else { return routed.await };
let generation = gate.generation();
let mut routed = std::pin::pin!(routed);
let mut wait: Option<Wait> = None;
let mut ends = Ends::Unread;
let ended = |e: PlexusError| -> Result<PlexusStream, PlexusError> {
let item = end_item(service.runtime_namespace(), &e);
Ok(Box::pin(futures::stream::iter([item])))
};
std::future::poll_fn(|cx| loop {
let now = generation.current();
if now != *seen {
let before = std::mem::replace(seen, now);
wait = None;
if !ctx.holds_itself() && !ctx.ended_by_peer() && !ctx.own_move(before, now) {
let refused = match ctx.reach() {
Some(reach) => redecide_body(gate, reach, targets).err(),
None => Some(Refusal::Unauthenticated),
};
if let Some(why) = refused {
return Poll::Ready(ended(PlexusError::from(why)));
}
if targets.is_empty() {
*owed = true;
}
}
continue;
}
if let Poll::Ready(r) = routed.as_mut().poll(cx) {
return Poll::Ready(r);
}
if wait.is_none() {
if ends.over(ctx) {
return Poll::Ready(ended(expired()));
}
wait = Some(wait_for(generation, ends.at(ctx)));
}
if generation.current() != *seen {
continue;
}
match wait.as_mut().expect("made above").as_mut().poll(cx) {
Poll::Ready(Woke::Moved) => wait = None,
Poll::Ready(Woke::Expired) => return Poll::Ready(ended(expired())),
Poll::Pending => return Poll::Pending,
}
})
.await
}
impl futures::Stream for Held {
type Item = PlexusStreamItem;
fn poll_next(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Option<PlexusStreamItem>> {
let this = self.get_mut();
let Some(gate) = this.service.gate() else { return Poll::Ready(None) };
let generation = gate.generation();
loop {
let Some(stream) = this.inner.as_mut() else { return Poll::Ready(None) };
match this.owed {
Owed::No => {}
Owed::FirstItem => {
this.owed = Owed::Now;
match crate::call::poll_in(&this.ctx, stream, cx) {
Poll::Ready(Some(item)) => return Poll::Ready(Some(item)),
Poll::Ready(None) => {
this.inner = None;
return Poll::Ready(None);
}
Poll::Pending => continue,
}
}
Owed::Now => {
this.owed = Owed::No;
if !this.ctx.holds_itself() && !this.ctx.ended_by_peer() {
let refused = match this.ctx.reach() {
Some(reach) => redecide(gate, reach, &this.targets).err(),
None => Some(Refusal::Unauthenticated),
};
if let Some(why) = refused {
return end(&mut this.inner, &mut this.wait, this.service.runtime_namespace(), PlexusError::from(why));
}
}
continue;
}
}
let now = generation.current();
if now != this.seen {
let before = std::mem::replace(&mut this.seen, now);
this.wait = None;
if !this.ctx.holds_itself() && !this.ctx.ended_by_peer() && !this.ctx.own_move(before, now) {
let refused = match this.ctx.reach() {
Some(reach) => redecide(gate, reach, &this.targets).err(),
None => Some(Refusal::Unauthenticated),
};
if let Some(why) = refused {
return end(&mut this.inner, &mut this.wait, this.service.runtime_namespace(), PlexusError::from(why));
}
}
continue;
}
if let Poll::Ready(item) = crate::call::poll_in(&this.ctx, stream, cx) {
if item.is_none() {
this.inner = None;
return Poll::Ready(None);
}
this.items = this.items.wrapping_add(1);
if this.items % CLOCK_EVERY == 0 && this.ends.over(&this.ctx) {
return end(&mut this.inner, &mut this.wait, this.service.runtime_namespace(), expired());
}
return Poll::Ready(item);
}
if this.wait.is_none() {
if this.ends.over(&this.ctx) {
return end(&mut this.inner, &mut this.wait, this.service.runtime_namespace(), expired());
}
this.wait = Some(wait_for(generation, this.ends.at(&this.ctx)));
}
if generation.current() != this.seen {
continue;
}
match this.wait.as_mut().expect("made above").as_mut().poll(cx) {
Poll::Ready(Woke::Moved) => this.wait = None,
Poll::Ready(Woke::Expired) => return end(&mut this.inner, &mut this.wait, this.service.runtime_namespace(), expired()),
Poll::Pending => return Poll::Pending,
}
}
}
}