use crate::state::Held;
use crate::state_unit::StateUnit;
use serde::{Serialize, Serializer};
use tokio::sync::watch;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionEndReason {
Expired,
Refused,
}
impl SessionEndReason {
pub fn as_str(self) -> &'static str {
match self {
SessionEndReason::Expired => "expired",
SessionEndReason::Refused => "refused",
}
}
}
impl Serialize for SessionEndReason {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionEnded {
pub reason: SessionEndReason,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PermissionDenied {
pub detail: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct KbIdentityConflict {
pub expected_did: String,
pub observed_did: String,
}
pub struct SessionSignals {
session_ended: Held<Option<SessionEnded>>,
permission_denied: Held<Option<PermissionDenied>>,
kb_identity_conflict: Held<Option<KbIdentityConflict>>,
}
impl Default for SessionSignals {
fn default() -> SessionSignals {
SessionSignals {
session_ended: Held::new(None),
permission_denied: Held::new(None),
kb_identity_conflict: Held::new(None),
}
}
}
impl SessionSignals {
pub fn new() -> SessionSignals {
SessionSignals::default()
}
pub fn session_ended(&self) -> watch::Receiver<Option<SessionEnded>> {
self.session_ended.read()
}
pub fn permission_denied(&self) -> watch::Receiver<Option<PermissionDenied>> {
self.permission_denied.read()
}
pub fn kb_identity_conflict(&self) -> watch::Receiver<Option<KbIdentityConflict>> {
self.kb_identity_conflict.read()
}
pub fn notify_session_ended(&self, reason: SessionEndReason) {
self.session_ended.raise(Some(SessionEnded { reason }));
}
pub fn notify_permission_denied(&self, detail: Option<&str>) {
self.permission_denied.raise(Some(PermissionDenied {
detail: detail.map(str::to_owned),
}));
}
pub fn notify_kb_identity_conflict(&self, conflict: KbIdentityConflict) {
self.kb_identity_conflict.raise(Some(conflict));
}
pub fn acknowledge_session_ended(&self) {
self.session_ended.raise(None);
}
pub fn acknowledge_permission_denied(&self) {
self.permission_denied.raise(None);
}
pub fn acknowledge_kb_identity_conflict(&self) {
self.kb_identity_conflict.raise(None);
}
}
impl StateUnit for SessionSignals {
fn dispose(&self) {
self.session_ended.end();
self.permission_denied.end();
self.kb_identity_conflict.end();
}
}
impl Drop for SessionSignals {
fn drop(&mut self) {
self.dispose();
}
}