use super::*;
use kernel_apis::context_control::{CONTEXT_NOTE_CUSTOM_TYPE, ContextBranches, project_note};
use session_journal::context::EntryProjector;
pub const CONTEXT_PENDING: &str = "ultron.context.pending";
pub(super) const PROJECTORS: &[(&str, EntryProjector)] = &[(CONTEXT_NOTE_CUSTOM_TYPE, project_note)];
pub(super) struct RootBranches {
session: SharedSession,
running: Mutex<bool>,
}
fn root_only(lane: &str) -> Result<(), String> {
if lane == MAIN_LANE {
Ok(())
} else {
Err(format!("ctx edits the root lane's context only (lane {lane})"))
}
}
pub(super) fn placement(session: &session_journal::Session, tip: Option<String>) -> (Vec<Write>, Option<String>) {
let mut writes = Vec::new();
let mut tip = tip;
for waiting in session.state().scan_values(CONTEXT_PENDING, "") {
let value = &waiting.value;
let custom_type = value["customType"].as_str().unwrap_or_default();
writes.push(Write::custom_entry(
&waiting.key,
tip.as_deref(),
custom_type,
value.get("data").cloned(),
));
writes.push(Write::delete(CONTEXT_PENDING, &waiting.key));
tip = Some(waiting.key.clone());
}
(writes, tip)
}
pub(super) fn pending_count(session: &session_journal::Session) -> usize {
session.state().scan_values(CONTEXT_PENDING, "").len()
}
impl RootBranches {
pub(super) fn new(session: SharedSession) -> Self {
RootBranches {
session,
running: Mutex::new(false),
}
}
pub(super) fn run_started(&self) {
*sync::lock(&self.running) = true;
}
pub(super) fn place(&self, ended: bool) -> Result<(), String> {
let mut running = sync::lock(&self.running);
if ended {
*running = false;
}
let mut session = lock_session(&self.session);
let tip = session.branch_tip(MAIN_LANE).flatten();
let (mut writes, placed) = placement(&session, tip.clone());
if writes.is_empty() {
return Ok(());
}
if let Some(placed) = placed.filter(|placed| Some(placed) != tip.as_ref()) {
writes.push(Write::set(BRANCH_TIP, MAIN_LANE, placed.into()));
}
session.commit(&writes).map(drop)
}
}
impl ContextBranches for RootBranches {
fn entries(&self, lane: &str) -> Result<Vec<Value>, String> {
root_only(lane)?;
lock_session(&self.session).branch_entries(MAIN_LANE)
}
fn append_custom(&self, lane: &str, custom_type: &str, data: &Value) -> Result<String, String> {
root_only(lane)?;
let running = sync::lock(&self.running);
let mut session = lock_session(&self.session);
let id = session_journal::lock_clock(&session.clock()).next_id();
let waiting = json!({"customType": custom_type, "data": data});
if *running {
session.commit(&[Write::set(CONTEXT_PENDING, &id, waiting)])?;
} else {
let tip = session.branch_tip(MAIN_LANE).flatten();
session.commit(&[
Write::custom_entry(&id, tip.as_deref(), custom_type, Some(data.clone())),
Write::set(BRANCH_TIP, MAIN_LANE, id.clone().into()),
])?;
}
Ok(id)
}
fn tip_id(&self, lane: &str) -> Result<Option<String>, String> {
root_only(lane)?;
Ok(lock_session(&self.session).branch_tip(MAIN_LANE).flatten())
}
}