use kernel::store::DocumentStore;
use kernel_apis::artifacts::KeyedDocuments;
use serde_json::Value;
use session_journal::{Session, Write};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
#[derive(Clone)]
pub struct SessionValues {
session: Arc<Mutex<Session>>,
handed_over: Option<Arc<AtomicBool>>,
}
impl SessionValues {
pub fn new(session: Session) -> Self {
SessionValues {
session: Arc::new(Mutex::new(session)),
handed_over: None,
}
}
pub fn shared(session: Arc<Mutex<Session>>) -> Self {
SessionValues {
session,
handed_over: Some(Arc::new(AtomicBool::new(false))),
}
}
pub fn hand_over(&self) {
if let Some(flag) = &self.handed_over {
flag.store(true, Ordering::SeqCst);
}
}
pub fn handed_over(&self) -> bool {
self.handed_over
.as_ref()
.is_some_and(|flag| flag.load(Ordering::SeqCst))
}
pub fn session(&self) -> &Arc<Mutex<Session>> {
&self.session
}
pub fn get(&self, namespace: &str, key: &str) -> Option<Value> {
jsrt::sync::lock(&self.session).value(namespace, key).cloned()
}
pub fn set(&self, namespace: &str, key: &str, value: &Value) -> Result<(), String> {
if self.handed_over() {
return Ok(());
}
jsrt::sync::lock(&self.session)
.commit(&[Write::set(namespace, key, value.clone())])
.map(drop)
}
pub fn document(&self, namespace: &str, key: &str) -> SessionDocument {
SessionDocument {
values: self.clone(),
namespace: namespace.into(),
key: key.into(),
}
}
pub fn keyed(&self, namespace: &str) -> SessionKeyed {
SessionKeyed {
values: self.clone(),
namespace: namespace.into(),
}
}
}
#[derive(Clone)]
pub struct SessionDocument {
values: SessionValues,
namespace: String,
key: String,
}
impl DocumentStore for SessionDocument {
fn read(&self) -> Result<Option<Value>, String> {
Ok(self.values.get(&self.namespace, &self.key))
}
fn write(&self, document: &Value) -> Result<(), String> {
self.values.set(&self.namespace, &self.key, document)
}
}
#[derive(Clone)]
pub struct SessionKeyed {
values: SessionValues,
namespace: String,
}
impl KeyedDocuments for SessionKeyed {
fn get(&self, key: &str) -> Result<Option<Value>, String> {
Ok(self.values.get(&self.namespace, key))
}
fn set(&self, key: &str, value: &Value) -> Result<(), String> {
self.values.set(&self.namespace, key, value)
}
fn list(&self, prefix: &str) -> Result<Vec<(String, Value)>, String> {
Ok(jsrt::sync::lock(&self.values.session)
.state()
.scan_values(&self.namespace, prefix)
.into_iter()
.map(|stored| (stored.key.clone(), stored.value.clone()))
.collect())
}
}