mtxchat replace File & PathBuf with native Pddb

This commit is contained in:
nworbnhoj 2023-09-09 05:51:21 +10:00
parent fbd49aea21
commit 7a13439d5c

View file

@ -7,11 +7,9 @@ pub use api::*;
use chat::{Chat, ChatOp}; use chat::{Chat, ChatOp};
use locales::t; use locales::t;
use modals::Modals; use modals::Modals;
use pddb::Pddb;
use std::fmt::Write as _; use std::fmt::Write as _;
use std::fs::File;
use std::io::{Error, ErrorKind, Read, Write as StdWrite}; use std::io::{Error, ErrorKind, Read, Write as StdWrite};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH}; use std::time::{SystemTime, UNIX_EPOCH};
use trng::*; use trng::*;
use xous_ipc::Buffer; use xous_ipc::Buffer;
@ -66,6 +64,7 @@ pub const HOSTED_MODE: bool = false;
pub struct MtxChat<'a> { pub struct MtxChat<'a> {
chat: &'a Chat, chat: &'a Chat,
trng: Trng, trng: Trng,
pddb: Pddb,
netmgr: net::NetManager, netmgr: net::NetManager,
user_id: String, user_id: String,
user_name: String, user_name: String,
@ -85,9 +84,12 @@ impl<'a> MtxChat<'a> {
let xns = xous_names::XousNames::new().unwrap(); let xns = xous_names::XousNames::new().unwrap();
let modals = Modals::new(&xns).expect("can't connect to Modals server"); let modals = Modals::new(&xns).expect("can't connect to Modals server");
let trng = Trng::new(&xns).unwrap(); let trng = Trng::new(&xns).unwrap();
let common = MtxChat { let pddb = pddb::Pddb::new();
pddb.try_mount();
MtxChat {
chat: chat, chat: chat,
trng: trng, trng: trng,
pddb: pddb,
netmgr: net::NetManager::new(), netmgr: net::NetManager::new(),
user_id: EMPTY.to_string(), user_id: EMPTY.to_string(),
user_name: EMPTY.to_string(), user_name: EMPTY.to_string(),
@ -101,16 +103,7 @@ impl<'a> MtxChat<'a> {
since: EMPTY.to_string(), since: EMPTY.to_string(),
listening: false, listening: false,
modals: modals, modals: modals,
};
// create the mtxchat dict if it does not exist
let pddb = pddb::Pddb::new();
pddb.try_mount();
match pddb.get(MTXCHAT_STATE, USER_DOMAIN_KEY, None, true, false, None, None::<fn()>) {
Ok(_) => {}
Err(e) => log::warn!("failed to create dict: {:?}", e),
} }
common
} }
pub fn set(&mut self, key: &str, value: &str) -> Result<(), Error> { pub fn set(&mut self, key: &str, value: &str) -> Result<(), Error> {
@ -121,10 +114,21 @@ impl<'a> MtxChat<'a> {
)) ))
} else { } else {
log::info!("set '{}' = '{}'", key, value); log::info!("set '{}' = '{}'", key, value);
let mut keypath = PathBuf::new(); match self
keypath.push(MTXCHAT_STATE); .pddb
keypath.push(key); .get(MTXCHAT_STATE, key, None, true, true, None, None::<fn()>)
File::create(keypath)?.write_all(value.as_bytes())?; {
Ok(mut pddb_key) => match pddb_key.write(&value.as_bytes()) {
Ok(len) => {
self.pddb.sync().ok();
log::trace!("Wrote {} bytes to {}:{}", len, MTXCHAT_STATE, key);
}
Err(e) => {
log::warn!("Error writing {}:{} {:?}", MTXCHAT_STATE, key, e);
}
},
Err(e) => log::warn!("failed to set pddb {}:{} {:?}", MTXCHAT_STATE, key, e),
};
match key { match key {
// update cached values // update cached values
FILTER_KEY => self.filter = value.to_string(), FILTER_KEY => self.filter = value.to_string(),
@ -161,19 +165,12 @@ impl<'a> MtxChat<'a> {
)) ))
} else { } else {
log::info!("unset '{}'", key); log::info!("unset '{}'", key);
let mut keypath = PathBuf::new(); match self.pddb.delete_key(MTXCHAT_STATE, key, None) {
keypath.push(MTXCHAT_STATE); Ok(_) => log::info!("pddb key deleted: {key}"),
if std::fs::metadata(&keypath).is_ok() { // keypath exists Err(e) => match e.kind() {
// log::info!("dict '{}' exists", MTXCHAT_STATE); ErrorKind::NotFound => (), // ignore, nothing to do
} else { _ => log::warn!("failed to delete pddb key: {key}: {:?}", e),
log::info!("dict '{}' does NOT exist.. creating it", MTXCHAT_STATE); },
std::fs::create_dir_all(&keypath)?;
}
keypath.push(key);
if std::fs::metadata(&keypath).is_ok() {
// keypath exists
log::info!("dict:key = '{}:{}' exists.. deleting it", MTXCHAT_STATE, key);
std::fs::remove_file(keypath)?;
} }
match key { match key {
// update cached values // update cached values
@ -202,21 +199,30 @@ impl<'a> MtxChat<'a> {
} }
pub fn get(&self, key: &str) -> Result<Option<String>, Error> { pub fn get(&self, key: &str) -> Result<Option<String>, Error> {
// if key.eq(CURRENT_VERSION_KEY) { let value = match self
// Ok(Some(self.version.clone())) .pddb
// } else { .get(MTXCHAT_STATE, key, None, true, false, None, None::<fn()>)
let mut keypath = PathBuf::new(); {
keypath.push(MTXCHAT_STATE); Ok(mut pddb_key) => {
keypath.push(key); let mut buffer = [0; 256];
if let Ok(mut file) = File::open(keypath) { match pddb_key.read(&mut buffer) {
let mut value = String::new(); Ok(len) => match String::from_utf8(buffer[..len].to_vec()) {
file.read_to_string(&mut value)?; Ok(s) => Some(s),
log::info!("get '{}' = '{}'", key, value); Err(e) => {
Ok(Some(value)) log::warn!("failed to String: {:?}", e);
} else { None
Ok(None) }
} },
// } Err(e) => {
log::warn!("failed pddb_key read: {:?}", e);
None
}
}
}
Err(_) => None,
};
log::info!("get '{}' = '{:?}'", key, value);
Ok(value)
} }
pub fn get_or(&mut self, key: &str, default: &str) -> String { pub fn get_or(&mut self, key: &str, default: &str) -> String {