use std::sync::Arc;
use lgwks_std::id::Uuid;
use super::super::ensure;
use super::audit::Visibility;
use super::limits::{tenant_count, within};
use super::{
AuditAction, Broker, BrokerError, BrokerState, Caller, Decision, Inspector, Limit, Permission,
Reach, RegisteredHandle, StoredTap, Subject, Subscription, SubscriptionId, TapEvent, TapId,
TapListener,
};
pub(super) fn caller_of(state: &BrokerState, handle: &RegisteredHandle) -> Caller {
match state.widgets.get(&handle.nonce()) {
Some(held) => Caller::of(&held.session),
None => Caller::from_widget(handle),
}
}
impl Broker {
fn authorize(
&self,
caller: &RegisteredHandle,
reach: Reach,
) -> (Caller, Result<Visibility, BrokerError>) {
let resolved = self
.lock()
.widgets
.get(&caller.nonce())
.map(|held| held.session.clone());
let Some(session) = resolved else {
return (Caller::from_widget(caller), Err(BrokerError::InvalidHandle));
};
let who = Caller::of(&session);
let access = match reach {
Reach::Own => Ok(()),
Reach::AllTenants => self.require(&session, Permission::CrossTenantInspect),
};
(who.clone(), access.map(|()| Visibility::new(who, reach)))
}
pub(super) fn audit_denial(&self, caller: Caller, action: AuditAction, error: &BrokerError) {
self.publish(caller, action, Reach::Own, Decision::Denied(error.clone()));
}
pub(crate) fn deny_handle(
&self,
handle: &RegisteredHandle,
action: AuditAction,
error: &BrokerError,
) {
let who = caller_of(&self.lock(), handle);
self.audit_denial(who, action, error);
}
pub fn registered_subscriptions(
&self,
caller: &RegisteredHandle,
reach: Reach,
) -> Result<Vec<Subscription>, BrokerError> {
let (who, access) = self.authorize(caller, reach);
let outcome = access.map(|view| {
self.lock()
.subscriptions
.iter()
.filter(|entry| {
view.admits(entry.1.handle.session_id(), entry.1.handle.tenant_id())
})
.map(|(id, sub)| Subscription {
id: SubscriptionId(*id),
descriptor_id: sub.handle.descriptor_id().to_owned(),
session_id: sub.handle.session_id().to_owned(),
tenant_id: sub.handle.tenant_id().to_owned(),
pattern: sub.pattern.clone(),
})
.collect()
});
let action = AuditAction::Inspect(Inspector::Subscriptions);
self.decide(who, action, reach, outcome)
}
pub fn tap(
&self,
caller: &RegisteredHandle,
reach: Reach,
listener: TapListener,
) -> Result<TapId, BrokerError> {
let (who, access) = self.authorize(caller, reach);
let outcome = access.and_then(|view| self.admit_tap(caller.nonce(), view, listener));
self.decide(who, AuditAction::Inspect(Inspector::Taps), reach, outcome)
}
fn admit_tap(
&self,
owner: Uuid,
view: Visibility,
listener: TapListener,
) -> Result<TapId, BrokerError> {
let id = (self.new_id)();
let tenant = view.caller().scope().tenant_id().to_owned();
let scoped: TapListener = Arc::new(move |event: TapEvent| {
let seen = event.envelope().session_invariant();
if view.admits(seen.session_id(), seen.tenant_id()) {
listener(event);
}
});
let mut state = self.lock();
ensure(state.widgets.contains_key(&owner), || {
BrokerError::InvalidHandle
})?;
within(state.taps.len(), Limit::Taps)?;
let owners = state.taps.values().map(|held| held.tenant.as_str());
within(tenant_count(owners, &tenant), Limit::TapsPerTenant)?;
state.taps.insert(
id,
StoredTap {
owner,
tenant,
listener: scoped,
},
);
Ok(TapId(id))
}
pub fn untap(&self, handle: &RegisteredHandle, id: &TapId) -> Result<(), BrokerError> {
let mut state = self.lock();
let who = caller_of(&state, handle);
let owned = state
.taps
.get(&id.0)
.is_some_and(|held| held.owner == handle.nonce());
let outcome = if owned {
state.taps.remove(&id.0);
Ok(())
} else {
Err(BrokerError::InvalidHandle)
};
drop(state);
self.decide(who, AuditAction::Revoke(Subject::Tap), Reach::Own, outcome)
}
}