114 lines
2.9 KiB
Rust
114 lines
2.9 KiB
Rust
use std::sync::{Arc, RwLock};
|
|
|
|
use anyhow::Error;
|
|
use cozo::DbInstance;
|
|
use tracing::{debug, error};
|
|
|
|
use crate::comm::{
|
|
messages::{Message, MessageContent},
|
|
CommHandle, Peer,
|
|
};
|
|
|
|
use self::types::{Element, ElementContent, ElementId, Tag};
|
|
|
|
pub mod types;
|
|
|
|
mod api_state;
|
|
mod comm_state;
|
|
mod queries;
|
|
mod schema;
|
|
|
|
pub use api_state::ApiState;
|
|
pub use comm_state::CommState;
|
|
|
|
pub struct State {
|
|
db: DbInstance,
|
|
comm_handle: RwLock<Option<Arc<CommHandle>>>,
|
|
}
|
|
|
|
impl State {
|
|
pub async fn new() -> anyhow::Result<Arc<State>> {
|
|
let db = DbInstance::new("mem", "", Default::default());
|
|
match db {
|
|
Ok(d) => {
|
|
schema::add_schema(&d)?;
|
|
Ok(Arc::new(State {
|
|
db: d,
|
|
comm_handle: RwLock::new(None),
|
|
}))
|
|
}
|
|
Err(e) => Err(Error::msg(format!("{:?}", e))),
|
|
}
|
|
}
|
|
|
|
pub fn set_comm_handle(&self, handle: Arc<CommHandle>) {
|
|
*self
|
|
.comm_handle
|
|
.write()
|
|
.as_deref_mut()
|
|
.expect("Could not set state's CommHandle") = Some(handle);
|
|
}
|
|
|
|
pub fn set_element_content(
|
|
&self,
|
|
element_id: &ElementId,
|
|
content: &ElementContent,
|
|
) -> anyhow::Result<()> {
|
|
let res = queries::elements::set_content(&self.db, element_id, content);
|
|
debug!(
|
|
"Set content of element with id {:?}: {:?}",
|
|
element_id,
|
|
self.get_element(element_id)
|
|
);
|
|
|
|
self.send_to_peers(MessageContent::SetElement {
|
|
id: element_id.clone(),
|
|
content: content.clone(),
|
|
});
|
|
res
|
|
}
|
|
|
|
pub fn remove_element(&self, element_id: &ElementId) -> anyhow::Result<()> {
|
|
let res = queries::elements::remove(&self.db, element_id);
|
|
|
|
self.send_to_peers(MessageContent::RemoveElement {
|
|
id: element_id.clone(),
|
|
});
|
|
res
|
|
}
|
|
|
|
pub fn get_element(&self, id: &ElementId) -> anyhow::Result<Element> {
|
|
queries::elements::get(&self.db, id)
|
|
}
|
|
|
|
pub fn get_elements_by_tag(&self, tag: &Tag) -> Vec<ElementId> {
|
|
queries::elements::get_by_tag(&self.db, tag)
|
|
.map_err(|e| {
|
|
error!("{}", e);
|
|
e
|
|
})
|
|
.unwrap_or(vec![])
|
|
}
|
|
|
|
pub fn set_peer(&self, peer: &Peer) -> anyhow::Result<()> {
|
|
queries::peers::put(&self.db, &peer.id(), &peer.name())
|
|
}
|
|
|
|
pub fn get_peers(&self) -> anyhow::Result<Vec<Peer>> {
|
|
queries::peers::get(&self.db)
|
|
}
|
|
|
|
fn send_to_peers(&self, ct: MessageContent) {
|
|
match self.comm_handle.read() {
|
|
Ok(opt) => {
|
|
if opt.is_some() {
|
|
let arc = opt.as_ref().unwrap().clone();
|
|
tokio::spawn(async move {
|
|
let _ = arc.broadcast(Message::new(ct)).await;
|
|
});
|
|
}
|
|
}
|
|
Err(e) => debug!("{}", e),
|
|
}
|
|
}
|
|
}
|