use super::factory::{SessionFactory, SessionFactoryOptions};
use super::knowledge_base::KbSessionStatus;
use super::open_resource::{OpenResource, TabCheck, apply_tab_checks, sort_open_resources};
use super::semiont_session::SemiontSession;
use super::signals::{KbIdentityConflict, SessionSignals};
use super::stored::{
ACTIVE_KEY, LAST_VIEWED_RESOURCE_BY_KB_KEY, OPEN_RESOURCES_BY_KB_KEY, StoredSession,
clear_stored_session, is_token_expired, load_knowledge_bases, save_knowledge_bases,
store_session, stored_session,
};
use crate::errors::{BusRequestErrorCode, SemiontError, SessionError, TransportErrorCode};
use crate::event_bus::EventBus;
use crate::locked;
use crate::resources::primary_media_type;
use crate::state::{Held, Tasks};
use crate::storage::{SessionStorage, StorageSubscription};
use crate::timing::CHECKS_AT_ONCE_COUNT;
use crate::transport::{Events, STREAM_BACKLOG};
use crate::types::{
KbDescription, KbEndpoint, KbRead, KnowledgeBase, NewKnowledgeBase, ResourceId,
};
use std::collections::{HashMap, VecDeque};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{SystemTime, UNIX_EPOCH};
use tokio::sync::{broadcast, watch};
use tokio::task::JoinSet;
pub struct SemiontBrowserConfig {
pub storage: Arc<dyn SessionStorage>,
pub session_factory: Arc<dyn SessionFactory>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SignedIn {
pub endpoint: KbEndpoint,
pub description: KbDescription,
pub session: StoredSession,
pub kb_id: Option<String>,
pub expected_did: Option<String>,
pub expected_name: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Expected {
pub did: String,
pub name: Option<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SignInOutcome {
pub kb: KnowledgeBase,
pub expected: Option<Expected>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum KbReadVerdict {
Recorded,
Conflict {
observed_did: String,
observed_name: String,
},
NoVerdict,
}
#[derive(Default)]
struct Kept {
open_by_kb: HashMap<String, Vec<OpenResource>>,
last_viewed_by_kb: HashMap<String, ResourceId>,
activations: usize,
}
struct Inner {
storage: Arc<dyn SessionStorage>,
factory: Arc<dyn SessionFactory>,
kbs: Held<Vec<KnowledgeBase>>,
active_kb_id: Held<Option<String>>,
active_session: Held<Option<Arc<SemiontSession>>>,
active_signals: Held<Option<Arc<SessionSignals>>>,
session_activating: Held<bool>,
open_resources: Held<Vec<OpenResource>>,
last_viewed_resource: Held<Option<ResourceId>>,
identity_token: Held<Option<String>>,
errors: Mutex<Option<broadcast::Sender<SessionError>>>,
bus: EventBus,
kept: Mutex<Kept>,
turn: tokio::sync::Mutex<()>,
tasks: Tasks,
task_failure: Mutex<Option<Box<dyn std::error::Error + Send + Sync>>>,
storage_changes: Mutex<Option<StorageSubscription>>,
closed: AtomicBool,
}
pub struct SemiontBrowser {
inner: Arc<Inner>,
}
fn by_kb<T: serde::de::DeserializeOwned>(stored: Option<&str>) -> HashMap<String, T> {
stored
.and_then(|stored| serde_json::from_str(stored).ok())
.unwrap_or_default()
}
fn milliseconds(at: SystemTime) -> u64 {
at.duration_since(UNIX_EPOCH)
.map_or(0, |since| since.as_millis() as u64)
}
impl SemiontBrowser {
pub fn new(
config: SemiontBrowserConfig,
) -> Result<SemiontBrowser, Box<dyn std::error::Error + Send + Sync>> {
let storage = config.storage;
let kbs = load_knowledge_bases(storage.as_ref());
let active = storage
.get(ACTIVE_KEY)
.filter(|stored| kbs.iter().any(|kb| kb.id == *stored))
.or_else(|| kbs.first().map(|kb| kb.id.clone()));
let inner = Arc::new(Inner {
kept: Mutex::new(Kept {
open_by_kb: by_kb(storage.get(OPEN_RESOURCES_BY_KB_KEY).as_deref()),
last_viewed_by_kb: by_kb(storage.get(LAST_VIEWED_RESOURCE_BY_KB_KEY).as_deref()),
..Kept::default()
}),
storage,
factory: config.session_factory,
kbs: Held::new(Vec::new()),
active_kb_id: Held::new(None),
active_session: Held::new(None),
active_signals: Held::new(None),
session_activating: Held::new(false),
open_resources: Held::new(Vec::new()),
last_viewed_resource: Held::new(None),
identity_token: Held::new(None),
errors: Mutex::new(Some(broadcast::channel(STREAM_BACKLOG).0)),
bus: EventBus::new(),
turn: tokio::sync::Mutex::new(()),
tasks: Tasks::new(),
task_failure: Mutex::new(None),
storage_changes: Mutex::new(None),
closed: AtomicBool::new(false),
});
inner.put_kbs(kbs)?;
inner.put_active_id(active.clone())?;
let heard = Arc::downgrade(&inner);
*locked(&inner.storage_changes) = inner.storage.subscribe(Arc::new(move |key, value| {
if let Some(inner) = heard.upgrade() {
inner.written_elsewhere(key, value);
}
}));
if let Some(active) = active {
let starting = inner.clone();
inner.spawn(async move { starting.set_active_kb(Some(active)).await });
}
Ok(SemiontBrowser { inner })
}
pub fn kbs(&self) -> watch::Receiver<Vec<KnowledgeBase>> {
self.inner.kbs.read()
}
pub fn active_kb_id(&self) -> watch::Receiver<Option<String>> {
self.inner.active_kb_id.read()
}
pub fn active_session(&self) -> watch::Receiver<Option<Arc<SemiontSession>>> {
self.inner.active_session.read()
}
pub fn active_signals(&self) -> watch::Receiver<Option<Arc<SessionSignals>>> {
self.inner.active_signals.read()
}
pub fn session_activating(&self) -> watch::Receiver<bool> {
self.inner.session_activating.read()
}
pub fn open_resources(&self) -> watch::Receiver<Vec<OpenResource>> {
self.inner.open_resources.read()
}
pub fn last_viewed_resource(&self) -> watch::Receiver<Option<ResourceId>> {
self.inner.last_viewed_resource.read()
}
pub fn errors(&self) -> Events<SessionError> {
match locked(&self.inner.errors).as_ref() {
Some(errors) => Events::new(errors.subscribe()),
None => Events::new(broadcast::channel(1).1),
}
}
pub fn identity_token(&self) -> watch::Receiver<Option<String>> {
self.inner.identity_token.read()
}
pub fn set_identity_token(&self, token: Option<&str>) {
self.inner.identity_token.set(token.map(str::to_owned));
}
pub fn storage(&self) -> &Arc<dyn SessionStorage> {
&self.inner.storage
}
pub fn bus(&self) -> &EventBus {
&self.inner.bus
}
pub async fn add_kb(
&self,
input: NewKnowledgeBase,
session: &StoredSession,
) -> Result<KnowledgeBase, Box<dyn std::error::Error + Send + Sync>> {
self.inner.add_kb(input, session).await
}
pub async fn remove_kb(
&self,
id: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let inner = &self.inner;
clear_stored_session(inner.storage.as_ref(), id)?;
inner.forget_kept_of(id)?;
let rest: Vec<KnowledgeBase> = inner
.kbs
.now()
.into_iter()
.filter(|kb| kb.id != id)
.collect();
let next = rest.first().map(|kb| kb.id.clone());
inner.put_kbs(rest)?;
if inner.active_kb_id.now().as_deref() == Some(id) {
inner.set_active_kb(next).await?;
}
Ok(())
}
pub fn update_kb(
&self,
id: &str,
label: Option<&str>,
last_read: Option<KbRead>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.update_kb(id, label, last_read)
}
pub fn kb_session_status(&self, kb_id: &str) -> KbSessionStatus {
match stored_session(self.inner.storage.as_ref(), kb_id) {
None => KbSessionStatus::SignedOut,
Some(stored) if is_token_expired(&stored.access, SystemTime::now()) => {
KbSessionStatus::Expired
}
Some(_) => KbSessionStatus::Authenticated,
}
}
pub async fn set_active_kb(
&self,
id: Option<&str>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.set_active_kb(id.map(str::to_owned)).await
}
pub async fn sign_in(
&self,
id: &str,
session: &StoredSession,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.sign_in(id, session).await
}
pub async fn signed_in(
&self,
signed_in: SignedIn,
) -> Result<SignInOutcome, Box<dyn std::error::Error + Send + Sync>> {
let inner = &self.inner;
let did = crate::identity::kb_did(&signed_in.description.domain);
let label = signed_in.description.name.clone();
let last_read = KbRead::of(&signed_in.description, SystemTime::now());
let kbs = inner.kbs.now();
let at_address: Vec<&KnowledgeBase> = kbs
.iter()
.filter(|kb| same_place(&kb.endpoint, &signed_in.endpoint))
.collect();
let believed = match &signed_in.kb_id {
Some(id) => kbs.iter().find(|kb| kb.id == *id),
None if at_address.len() == 1 => Some(at_address[0]),
None => None,
};
let expected = match (signed_in.expected_did, believed) {
(Some(did), _) => Some(Expected {
did,
name: signed_in.expected_name.filter(|name| !name.is_empty()),
}),
(None, Some(believed)) => Some(Expected {
did: believed.did.clone(),
name: Some(believed.label.clone()).filter(|label| !label.is_empty()),
}),
(None, None) => None,
};
let kb = match at_address.iter().find(|kb| kb.did == did) {
Some(answered) => {
let id = answered.id.clone();
let kb = KnowledgeBase {
label: label.clone(),
last_read: Some(last_read.clone()),
..(*answered).clone()
};
inner.update_kb(&id, Some(&label), Some(last_read))?;
inner.sign_in(&id, &signed_in.session).await?;
kb
}
None => {
inner
.add_kb(
NewKnowledgeBase {
label,
did,
endpoint: signed_in.endpoint,
last_read: Some(last_read),
},
&signed_in.session,
)
.await?
}
};
Ok(SignInOutcome { kb, expected })
}
pub async fn sign_out(&self, id: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let inner = &self.inner;
if inner.closed() {
return Ok(());
}
let stored = stored_session(inner.storage.as_ref(), id);
clear_stored_session(inner.storage.as_ref(), id)?;
if let Some(stored) = stored {
let revoking = inner.factory.revoke(stored);
inner.spawn(async move {
revoking.await;
Ok(())
});
}
inner.kbs.raise(inner.kbs.now());
if inner.active_kb_id.now().as_deref() == Some(id)
&& let Some(ended) = inner.take_session()
{
ended.close().await;
}
Ok(())
}
pub fn add_open_resource(
&self,
id: &ResourceId,
name: &str,
media_type: Option<&str>,
storage_uri: Option<&str>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.mutate_open_resources(|mut open| {
match open.iter_mut().find(|resource| &resource.id == id) {
Some(resource) => {
resource.name = name.to_owned();
if let Some(media_type) = media_type {
resource.media_type = Some(media_type.to_owned());
}
if let Some(storage_uri) = storage_uri {
resource.storage_uri = Some(storage_uri.to_owned());
}
}
None => open.push(OpenResource {
id: id.clone(),
name: name.to_owned(),
opened_at: milliseconds(SystemTime::now()),
order: open
.iter()
.map(|resource| resource.order + 1)
.max()
.unwrap_or(0),
media_type: media_type.map(str::to_owned),
storage_uri: storage_uri.map(str::to_owned),
}),
}
open
})
}
pub fn remove_open_resource(
&self,
id: &ResourceId,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.mutate_open_resources(|mut open| {
open.retain(|resource| &resource.id != id);
open
})
}
pub fn update_open_resource_name(
&self,
id: &ResourceId,
name: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.mutate_open_resources(|mut open| {
for resource in open.iter_mut().filter(|resource| &resource.id == id) {
resource.name = name.to_owned();
}
open
})
}
pub fn reorder_open_resources(
&self,
from: usize,
to: usize,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.mutate_open_resources(|open| {
if from >= open.len() || to >= open.len() {
return open;
}
let mut ordered = sort_open_resources(open);
let moved = ordered.remove(from);
ordered.insert(to, moved);
for (place, resource) in ordered.iter_mut().enumerate() {
resource.order = place as u64;
}
ordered
})
}
pub fn set_last_viewed_resource(
&self,
resource_id: &ResourceId,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.inner.set_last_viewed_resource(resource_id)
}
pub async fn read_active_kb(
&self,
) -> Result<KbReadVerdict, Box<dyn std::error::Error + Send + Sync>> {
let inner = &self.inner;
match (inner.active_session.now(), inner.active_kb_id.now()) {
(Some(session), Some(kb_id)) => inner.read_kb(&session, &kb_id).await,
_ => Ok(KbReadVerdict::NoVerdict),
}
}
pub async fn close(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let inner = &self.inner;
if inner.closed.swap(true, Ordering::SeqCst) {
return Ok(());
}
if let Some(ended) = inner.take_session() {
ended.close().await;
}
let own = inner.tasks.stop_and_wait().await;
inner.end();
if let Some(own) = own {
own.abort();
}
locked(&inner.task_failure).take().map_or(Ok(()), Err)
}
}
impl Drop for SemiontBrowser {
fn drop(&mut self) {
self.inner.closed.store(true, Ordering::SeqCst);
self.inner.end();
}
}
fn same_place(one: &KbEndpoint, other: &KbEndpoint) -> bool {
match (one, other) {
(KbEndpoint::HttpEndpoint(one), KbEndpoint::HttpEndpoint(other)) => one.same_address(other),
(KbEndpoint::LocalEndpoint(one), KbEndpoint::LocalEndpoint(other)) => {
one.kb_id == other.kb_id
}
_ => false,
}
}
struct Ended {
session: Arc<SemiontSession>,
signals: Option<Arc<SessionSignals>>,
}
impl Ended {
async fn close(self) {
crate::state_unit::StateUnit::dispose(self.session.as_ref());
self.session.client().close().await;
if let Some(signals) = self.signals {
crate::state_unit::StateUnit::dispose(signals.as_ref());
}
}
}
impl Inner {
fn closed(&self) -> bool {
self.closed.load(Ordering::SeqCst)
}
fn end(&self) {
self.tasks.stop();
*locked(&self.storage_changes) = None;
*locked(&self.errors) = None;
self.kbs.end();
self.active_kb_id.end();
self.active_session.end();
self.active_signals.end();
self.session_activating.end();
self.open_resources.end();
self.last_viewed_resource.end();
self.identity_token.end();
self.bus.destroy();
}
fn failed(&self, error: SessionError) {
if let Some(errors) = locked(&self.errors).as_ref() {
let _ = errors.send(error);
}
}
fn spawn(
self: &Arc<Self>,
work: impl Future<Output = Result<(), Box<dyn std::error::Error + Send + Sync>>>
+ Send
+ 'static,
) {
let failing = Arc::downgrade(self);
self.tasks.spawn(async move {
if let Err(failure) = work.await
&& let Some(inner) = failing.upgrade()
{
let mut first = locked(&inner.task_failure);
if first.is_none() {
*first = Some(failure);
}
}
});
}
fn put_kbs(
&self,
kbs: Vec<KnowledgeBase>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
if self.closed() {
return Ok(());
}
save_knowledge_bases(self.storage.as_ref(), &kbs)?;
self.kbs.raise(kbs);
Ok(())
}
fn put_active_id(
&self,
id: Option<String>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
if self.closed() {
return Ok(());
}
match &id {
Some(id) => self.storage.set(ACTIVE_KEY, id),
None => self.storage.delete(ACTIVE_KEY),
}?;
self.active_kb_id.set(id);
Ok(())
}
fn update_kb(
&self,
id: &str,
label: Option<&str>,
last_read: Option<KbRead>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let mut kbs = self.kbs.now();
for kb in kbs.iter_mut().filter(|kb| kb.id == id) {
if let Some(label) = label {
kb.label = label.to_owned();
}
if let Some(last_read) = &last_read {
kb.last_read = Some(last_read.clone());
}
}
self.put_kbs(kbs)
}
async fn add_kb(
self: &Arc<Self>,
input: NewKnowledgeBase,
session: &StoredSession,
) -> Result<KnowledgeBase, Box<dyn std::error::Error + Send + Sync>> {
let kb = KnowledgeBase {
id: uuid::Uuid::new_v4().to_string(),
label: input.label,
did: input.did,
endpoint: input.endpoint,
last_read: input.last_read,
};
store_session(self.storage.as_ref(), &kb.id, session)?;
let mut kbs = self.kbs.now();
kbs.push(kb.clone());
self.put_kbs(kbs)?;
self.set_active_kb(Some(kb.id.clone())).await?;
Ok(kb)
}
async fn sign_in(
self: &Arc<Self>,
id: &str,
session: &StoredSession,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
if self.closed() {
return Ok(());
}
store_session(self.storage.as_ref(), id, session)?;
if self.active_kb_id.now().as_deref() == Some(id)
&& let Some(ended) = self.take_session()
{
ended.close().await;
}
self.set_active_kb(Some(id.to_owned())).await
}
fn take_session(&self) -> Option<Ended> {
let session = self.active_session.now()?;
let signals = self.active_signals.now();
self.active_session.raise(None);
self.active_signals.raise(None);
self.project();
Some(Ended { session, signals })
}
fn put_session(self: &Arc<Self>, session: Arc<SemiontSession>, signals: Arc<SessionSignals>) {
self.active_signals.raise(Some(signals));
self.active_session.raise(Some(session.clone()));
self.project();
let checking = self.clone();
self.spawn(async move { checking.validate_open_resources(session).await });
}
async fn set_active_kb(
self: &Arc<Self>,
id: Option<String>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
if self.closed() {
return Ok(());
}
let previous = self.active_kb_id.now();
if id == previous && self.active_session.now().is_some() {
return Ok(());
}
if previous != id {
self.put_active_id(id.clone())?;
}
let ended = self.take_session();
self.activating(1);
{
let _turn = self.turn.lock().await;
if let Some(ended) = ended {
ended.close().await;
}
if !self.closed() && self.active_kb_id.now() == id {
if let Some(left) = self.take_session() {
left.close().await;
}
if let Some(id) = &id {
self.activate(id).await;
}
}
}
self.activating(-1);
Ok(())
}
fn activating(&self, change: isize) {
let mut kept = locked(&self.kept);
kept.activations = kept.activations.saturating_add_signed(change);
self.session_activating.set(kept.activations > 0);
}
async fn activate(self: &Arc<Self>, id: &str) {
let Some(kb) = self.kbs.now().into_iter().find(|kb| kb.id == id) else {
return;
};
let signals = Arc::new(SessionSignals::new());
let reporting = Arc::downgrade(self);
let built = self.factory.session(SessionFactoryOptions {
kb,
storage: self.storage.clone(),
signals: signals.clone(),
on_error: Arc::new(move |error| {
if let Some(inner) = reporting.upgrade() {
inner.failed(error);
}
}),
});
let session = match built {
Ok(session) => Arc::new(session),
Err(refused) => {
self.failed(refused);
return;
}
};
let routing = route(session.clone(), signals.clone());
self.spawn(async move {
routing.await;
Ok(())
});
session.ready().await;
if self.closed() || self.active_kb_id.now().as_deref() != Some(id) {
Ended {
session,
signals: Some(signals),
}
.close()
.await;
return;
}
self.put_session(session, signals);
}
fn project(&self) {
let live = self
.active_kb_id
.now()
.filter(|_| self.active_session.now().is_some());
let (open, viewed) = {
let kept = locked(&self.kept);
match &live {
Some(kb_id) => (
sort_open_resources(kept.open_by_kb.get(kb_id).cloned().unwrap_or_default()),
kept.last_viewed_by_kb.get(kb_id).cloned(),
),
None => (Vec::new(), None),
}
};
self.open_resources.set(open);
self.last_viewed_resource.set(viewed);
}
fn live_kb_id(&self) -> Option<String> {
self.active_kb_id
.now()
.filter(|_| self.active_session.now().is_some())
}
fn mutate_open_resources(
&self,
mutate: impl Fn(Vec<OpenResource>) -> Vec<OpenResource>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let Some(kb_id) = self.live_kb_id() else {
return Ok(());
};
let mut committed = None;
self.storage
.update(OPEN_RESOURCES_BY_KB_KEY, &mut |stored| {
let mut open: HashMap<String, Vec<OpenResource>> = by_kb(stored);
let list = open.remove(&kb_id).unwrap_or_default();
open.insert(kb_id.clone(), mutate(list));
let written = serde_json::to_string(&open).unwrap_or_default();
committed = Some(open);
Some(written)
})?;
if let Some(open) = committed {
locked(&self.kept).open_by_kb = open;
}
self.project();
Ok(())
}
fn set_last_viewed_resource(
&self,
resource_id: &ResourceId,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let Some(kb_id) = self.live_kb_id() else {
return Ok(());
};
self.mutate_last_viewed(|viewed| {
viewed.insert(kb_id.clone(), resource_id.clone());
})
}
fn mutate_last_viewed(
&self,
mutate: impl Fn(&mut HashMap<String, ResourceId>),
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let mut committed = None;
self.storage
.update(LAST_VIEWED_RESOURCE_BY_KB_KEY, &mut |stored| {
let mut viewed: HashMap<String, ResourceId> = by_kb(stored);
mutate(&mut viewed);
let written = serde_json::to_string(&viewed).unwrap_or_default();
committed = Some(viewed);
Some(written)
})?;
if let Some(viewed) = committed {
locked(&self.kept).last_viewed_by_kb = viewed;
}
self.project();
Ok(())
}
fn forget_kept_of(&self, kb_id: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let mut open = None;
self.storage
.update(OPEN_RESOURCES_BY_KB_KEY, &mut |stored| {
let mut by: HashMap<String, Vec<OpenResource>> = by_kb(stored);
by.remove(kb_id);
let written = serde_json::to_string(&by).unwrap_or_default();
open = Some(by);
Some(written)
})?;
if let Some(open) = open {
locked(&self.kept).open_by_kb = open;
}
self.mutate_last_viewed(|viewed| {
viewed.remove(kb_id);
})
}
fn written_elsewhere(&self, key: &str, value: Option<&str>) {
if self.closed() {
return;
}
let Some(value) = value else { return };
match key {
OPEN_RESOURCES_BY_KB_KEY => {
if let Ok(open) = serde_json::from_str(value) {
locked(&self.kept).open_by_kb = open;
}
}
LAST_VIEWED_RESOURCE_BY_KB_KEY => {
if let Ok(viewed) = serde_json::from_str(value) {
locked(&self.kept).last_viewed_by_kb = viewed;
}
}
_ => return,
}
self.project();
}
async fn validate_open_resources(
self: &Arc<Self>,
session: Arc<SemiontSession>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let kb_id = session.kb().id.clone();
let is_live = |inner: &Inner| {
!inner.closed()
&& inner
.active_session
.now()
.is_some_and(|live| live.id() == session.id())
};
if let KbReadVerdict::Conflict { observed_did, .. } = self.read_kb(&session, &kb_id).await?
{
if is_live(self) {
return self.void_for_conflict(&kb_id, observed_did);
}
return Ok(());
}
let ids: VecDeque<ResourceId> =
by_kb::<Vec<OpenResource>>(self.storage.get(OPEN_RESOURCES_BY_KB_KEY).as_deref())
.remove(&kb_id)
.unwrap_or_default()
.into_iter()
.map(|resource| resource.id)
.collect();
if ids.is_empty() {
return Ok(());
}
let waiting = Arc::new(Mutex::new(ids));
let mut lanes = JoinSet::new();
for _ in 0..CHECKS_AT_ONCE_COUNT {
let (waiting, session) = (waiting.clone(), session.clone());
lanes.spawn(async move {
let mut checked = Vec::new();
loop {
let Some(id) = locked(&waiting).pop_front() else {
return checked;
};
let check = check_open_resource(&session, &id).await;
checked.push((id, check));
}
});
}
let mut checks = HashMap::new();
while let Some(lane) = lanes.join_next().await {
checks.extend(lane.unwrap_or_default());
}
if !is_live(self) {
return Ok(());
}
self.mutate_open_resources(|open| apply_tab_checks(open, &checks))
}
async fn read_kb(
&self,
session: &SemiontSession,
kb_id: &str,
) -> Result<KbReadVerdict, Box<dyn std::error::Error + Send + Sync>> {
let Some(expected_did) = self
.kbs
.now()
.into_iter()
.find(|kb| kb.id == kb_id)
.map(|kb| kb.did)
else {
return Ok(KbReadVerdict::NoVerdict);
};
let Ok(description) = session.client().browse.kb().await else {
return Ok(KbReadVerdict::NoVerdict);
};
let observed_did = crate::identity::kb_did(&description.domain);
if observed_did != expected_did {
return Ok(KbReadVerdict::Conflict {
observed_did,
observed_name: description.name,
});
}
if self.closed() {
return Ok(KbReadVerdict::NoVerdict);
}
self.update_kb(
kb_id,
Some(&description.name),
Some(KbRead::of(&description, SystemTime::now())),
)?;
Ok(KbReadVerdict::Recorded)
}
fn void_for_conflict(
&self,
kb_id: &str,
observed_did: String,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let Some(expected_did) = self
.kbs
.now()
.into_iter()
.find(|kb| kb.id == kb_id)
.map(|kb| kb.did)
else {
return Ok(());
};
self.mutate_open_resources(|_| Vec::new())?;
self.mutate_last_viewed(|viewed| {
viewed.remove(kb_id);
})?;
if let Some(signals) = self.active_signals.now() {
signals.notify_kb_identity_conflict(KbIdentityConflict {
expected_did,
observed_did,
});
}
Ok(())
}
}
async fn check_open_resource(session: &SemiontSession, id: &ResourceId) -> TabCheck {
match session.client().browse.resource(id).fresh().await {
Ok(descriptor) => TabCheck::Ready {
media_type: primary_media_type(&descriptor).map(str::to_owned),
name: descriptor.name,
},
Err(failure)
if matches!(
failure.downcast_ref::<SemiontError>(),
Some(SemiontError::Bus(answer)) if answer.code == BusRequestErrorCode::NotFound
) =>
{
TabCheck::Gone
}
Err(_) => TabCheck::Unknown,
}
}
async fn route(session: Arc<SemiontSession>, signals: Arc<SessionSignals>) {
let mut failures = session.errors();
let mut renewing = JoinSet::new();
while let Some(failure) = failures.next().await {
let Ok(failure) = failure else { continue };
while renewing.try_join_next().is_some() {}
match failure.code {
TransportErrorCode::Unauthorized => {
let session = session.clone();
let refused = session.token().borrow().clone();
renewing.spawn(async move {
session.refresh(refused.as_deref()).await;
});
}
TransportErrorCode::Forbidden => {
signals.notify_permission_denied(Some(&failure.message));
}
_ => {}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::identity::kb_did;
use crate::testing::{ScriptedSessions, SharedStorage};
use crate::types::{HttpEndpoint, HttpEndpointProtocol};
use serde_json::{Value, json};
use std::collections::HashSet;
use std::time::Duration;
const A: &str = "kb-a";
const B: &str = "kb-b";
struct Says {
description: Value,
gone: HashSet<String>,
}
struct Gateways {
sessions: ScriptedSessions,
said: Arc<Mutex<HashMap<String, Says>>>,
answered: Arc<Mutex<Vec<(String, String)>>>,
}
fn asked_about(payload: &serde_json::Map<String, Value>) -> String {
payload
.get("resourceId")
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned()
}
impl Gateways {
fn new() -> Gateways {
let said: Arc<Mutex<HashMap<String, Says>>> = Arc::default();
let answered: Arc<Mutex<Vec<(String, String)>>> = Arc::default();
let (answering, refusing, recording) = (said.clone(), said.clone(), answered.clone());
let sessions = ScriptedSessions::answering(
move |kb_id, operation, payload| {
locked(&recording).push((kb_id.to_owned(), operation.to_owned()));
match operation {
"browse:kb-requested" => locked(&answering)
.get(kb_id)
.map(|says| Some(says.description.clone()))
.ok_or_else(|| "the knowledge base does not answer".to_owned()),
"browse:resource-requested" => {
let id = asked_about(payload);
Ok(Some(json!({
"resource": {
"@context": "https://schema.org", "@id": id,
"name": format!("name-{id}"), "representations": [],
},
"lastSequence": 1,
})))
}
other => Err(format!("{other} is not answered here")),
}
},
None,
);
sessions.refuse_when(move |kb_id, operation, payload| {
let gone = locked(&refusing)
.get(kb_id)
.is_some_and(|says| says.gone.contains(&asked_about(payload)));
(operation == "browse:resource-requested" && gone)
.then(|| json!({ "code": "not-found", "message": "no such resource" }))
});
Gateways {
sessions,
said,
answered,
}
}
fn says(&self, kb_id: &str, description: Value, gone: &[&str]) {
let gone = gone.iter().map(|id| (*id).to_owned()).collect();
locked(&self.said).insert(kb_id.to_owned(), Says { description, gone });
}
}
fn entry(id: &str, domain: &str, port: u16) -> KnowledgeBase {
let endpoint = HttpEndpoint::new("localhost", port, HttpEndpointProtocol::Http);
KnowledgeBase {
id: id.to_owned(),
label: id.to_owned(),
did: kb_did(domain),
endpoint: KbEndpoint::HttpEndpoint(endpoint),
last_read: None,
}
}
async fn replaced(
gateways: &Gateways,
kbs: [KnowledgeBase; 2],
) -> (SemiontBrowser, Arc<SemiontSession>) {
let storage = Arc::new(SharedStorage::new());
save_knowledge_bases(storage.as_ref(), &kbs).expect("stored");
storage.set(ACTIVE_KEY, B).expect("stored");
let opened = json!([{ "id": "r1", "name": "R1", "openedAt": 1, "order": 0 }]);
storage
.set(
OPEN_RESOURCES_BY_KB_KEY,
&json!({ A: opened, B: opened }).to_string(),
)
.expect("stored");
storage
.set(
LAST_VIEWED_RESOURCE_BY_KB_KEY,
&json!({ A: "r1", B: "r1" }).to_string(),
)
.expect("stored");
let browser = SemiontBrowser::new(SemiontBrowserConfig {
storage: storage.clone(),
session_factory: Arc::new(gateways.sessions.clone()),
})
.expect("a browser");
let mut live = browser.active_session();
tokio::time::timeout(Duration::from_secs(60), live.wait_for(Option::is_some))
.await
.expect("a session comes up")
.expect("the browser lives");
tokio::time::sleep(Duration::from_millis(1)).await;
let [of_a, _] = kbs;
let stale = gateways
.sessions
.session(SessionFactoryOptions {
kb: of_a,
storage,
signals: Arc::new(SessionSignals::new()),
on_error: Arc::new(|_| {}),
})
.expect("a session");
stale.ready().await;
(browser, Arc::new(stale))
}
fn shown(browser: &SemiontBrowser) -> (Vec<String>, Option<String>) {
(
browser
.open_resources()
.borrow()
.iter()
.map(|resource| resource.id.to_string())
.collect(),
browser
.last_viewed_resource()
.borrow()
.as_deref()
.map(str::to_owned),
)
}
#[tokio::test(start_paused = true)]
async fn the_checks_of_a_replaced_session_are_of_its_own_knowledge_base_and_change_nothing_shown()
{
let gateways = Gateways::new();
let at = |name: &str, branch: &str| json!({ "name": name, "domain": "example.org", "gitBranch": branch });
gateways.says(A, at("At A", "branch-a"), &["r1"]);
gateways.says(B, at("At B", "branch-b"), &[]);
let kbs = [entry(A, "example.org", 4000), entry(B, "example.org", 4001)];
let (browser, stale) = replaced(&gateways, kbs).await;
browser
.inner
.validate_open_resources(stale)
.await
.expect("the checks are kept");
let said = |id: &str| {
let kbs = browser.kbs().borrow().clone();
let kb = kbs.into_iter().find(|kb| kb.id == id).expect("an entry");
(kb.label, kb.last_read.and_then(|read| read.git_branch))
};
assert_eq!(said(A), ("At A".to_owned(), Some("branch-a".to_owned())));
assert_eq!(said(B), ("At B".to_owned(), Some("branch-b".to_owned())));
assert_eq!(
shown(&browser),
(vec!["r1".to_owned()], Some("r1".to_owned()))
);
}
#[tokio::test(start_paused = true)]
async fn a_conflict_a_replaced_session_finds_voids_nothing_and_is_not_raised() {
let gateways = Gateways::new();
gateways.says(
A,
json!({ "name": "Another", "domain": "elsewhere.example" }),
&[],
);
gateways.says(B, json!({ "name": "At B", "domain": "b.example" }), &[]);
let kbs = [entry(A, "a.example", 4000), entry(B, "b.example", 4001)];
let (browser, stale) = replaced(&gateways, kbs).await;
browser
.inner
.validate_open_resources(stale)
.await
.expect("the checks are kept");
let of_a: Vec<String> = locked(&gateways.answered)
.iter()
.filter(|(kb_id, _)| kb_id == A)
.map(|(_, operation)| operation.clone())
.collect();
assert_eq!(of_a, ["browse:kb-requested"]);
assert_eq!(
shown(&browser),
(vec!["r1".to_owned()], Some("r1".to_owned()))
);
let signals = browser.active_signals().borrow().clone().expect("signals");
assert_eq!(*signals.kb_identity_conflict().borrow(), None);
let viewed: HashMap<String, String> = by_kb(
browser
.storage()
.get(LAST_VIEWED_RESOURCE_BY_KB_KEY)
.as_deref(),
);
assert_eq!(viewed.get(A).map(String::as_str), Some("r1"));
}
}
#[cfg(test)]
mod registry_cases {
use super::*;
use serde_json::Value;
const REGISTRY_CASES: &str = include_str!("../../specs/session/registry-cases.json");
#[test]
fn one_place_is_as_the_shared_table_states() {
let table: Value = serde_json::from_str(REGISTRY_CASES).expect("the table is JSON");
let cases = table["cases"].as_array().expect("the table has cases");
assert!(!cases.is_empty());
for case in cases {
let why = case["why"].as_str().expect("a case says why");
let one: KbEndpoint = serde_json::from_value(case["one"].clone()).expect("an endpoint");
let other: KbEndpoint =
serde_json::from_value(case["other"].clone()).expect("an endpoint");
let same = case["samePlace"].as_bool().expect("a case says samePlace");
assert_eq!(same_place(&one, &other), same, "{why}");
assert_eq!(same_place(&other, &one), same, "{why}, the other way round");
}
}
#[test]
fn open_resources_are_shown_in_the_order_the_shared_table_states() {
let table: Value = serde_json::from_str(REGISTRY_CASES).expect("the table is JSON");
let cases = table["openResourceOrder"]
.as_array()
.expect("the table has an order of open resources");
assert!(!cases.is_empty());
for case in cases {
let why = case["why"].as_str().expect("a case says why");
let open: Vec<OpenResource> = match serde_json::from_value(case["open"].clone()) {
Ok(open) => open,
Err(error) => {
panic!(
"{why}: the open resources do not read as a registry keeps them: {error}"
)
}
};
let shown: Vec<&str> = case["shown"]
.as_array()
.expect("a case says what is shown")
.iter()
.map(|id| id.as_str().expect("an id"))
.collect();
let sorted = sort_open_resources(open);
let ids: Vec<&str> = sorted.iter().map(|resource| resource.id.as_str()).collect();
assert_eq!(ids, shown, "{why}");
}
}
}