optimize the ui cache routines

rely more on the cache retaining consistency with the disk
versus always reloading from the disk to speed up performance.

might be useful to make a routine that can also check coherency
periodically, because with the new format the cache could
co-exist along side the database for a very long time without
any checking.
This commit is contained in:
bunnie 2023-06-06 19:17:24 +08:00
parent 4c180810a5
commit 567d9db2cd
4 changed files with 136 additions and 83 deletions

View file

@ -13,9 +13,9 @@ use std::cell::RefCell;
use vault::{ use vault::{
deserialize_app_info, serialize_app_info, basis_change, deserialize_app_info, serialize_app_info, basis_change,
VAULT_PASSWORD_DICT, VAULT_TOTP_DICT, VAULT_ALLOC_HINT, utc_now, VAULT_PASSWORD_DICT, VAULT_TOTP_DICT, VAULT_ALLOC_HINT, utc_now,
atime_to_str atime_to_str, AppInfo, ctap::data_formats::PublicKeyCredentialSource
}; };
use crate::{ListItem, ListKey}; use crate::{ListItem, ListKey, storage::TotpRecord};
use crate::{ItemLists, VaultMode, SelectedEntry}; use crate::{ItemLists, VaultMode, SelectedEntry};
use crate::storage::{self, PasswordRecord, StorageContent}; use crate::storage::{self, PasswordRecord, StorageContent};
use crate::totp::TotpAlgorithm; use crate::totp::TotpAlgorithm;
@ -46,6 +46,7 @@ pub enum ActionOp {
/// Internal ops /// Internal ops
UpdateMode, UpdateMode,
UpdateOneItem, UpdateOneItem,
ReloadDb,
Quit, Quit,
#[cfg(feature="vault-testing")] #[cfg(feature="vault-testing")]
/// Testing /// Testing
@ -145,6 +146,8 @@ impl<'a> ActionManager<'a> {
) )
).ok(); ).ok();
} }
/// This routine is now required to update the itemlist data as well as the PDDB to save on
/// a full retrieve of the db.
pub(crate) fn menu_addnew(&mut self) { pub(crate) fn menu_addnew(&mut self) {
match self.mode_cache { match self.mode_cache {
VaultMode::Password => { VaultMode::Password => {
@ -305,9 +308,13 @@ impl<'a> ActionManager<'a> {
self.report_err(t!("vault.error.internal_error", xous::LANG), Some(error)); self.report_err(t!("vault.error.internal_error", xous::LANG), Some(error));
}, },
}; };
// update the ux cache
let li = make_pw_item_from_record(&storage::hex(record.hash()), record);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
} }
VaultMode::Fido => { VaultMode::Fido => {
self.report_err(t!("vault.error.add_fido2", xous::LANG), None::<std::io::Error>); self.report_err(t!("vault.error.add_fido2", xous::LANG), None::<std::io::Error>);
// no DB entry update because it's an error to even get here
} }
VaultMode::Totp => { VaultMode::Totp => {
let description = match self.modals let description = match self.modals
@ -407,6 +414,8 @@ impl<'a> ActionManager<'a> {
self.report_err(t!("vault.error.internal_error", xous::LANG), Some(error)); self.report_err(t!("vault.error.internal_error", xous::LANG), Some(error));
}, },
}; };
let li = make_totp_item_from_record(&storage::hex(totp.hash()), totp);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
} }
} }
} }
@ -489,7 +498,10 @@ impl<'a> ActionManager<'a> {
} }
} }
/// Update UX cached data for just one entry /// Update UX cached data for just one entry by reading it back from the disk.
/// This is mainly used by the autotype routine to ensure that the single entry that
/// was autotyped has an updated atime in the UX; otherwise routines should update
/// the cache directly.
pub(crate) fn update_db_entry(&mut self, entry: SelectedEntry) { pub(crate) fn update_db_entry(&mut self, entry: SelectedEntry) {
match entry.mode { match entry.mode {
VaultMode::Password => { VaultMode::Password => {
@ -503,28 +515,10 @@ impl<'a> ActionManager<'a> {
return; return;
} }
}; };
// create the list item from the updated entry let li = make_pw_item_from_record(guid, pw);
let mut desc = String::with_capacity(256);
make_pw_name(&pw.description, &pw.username, &mut desc);
let mut extra = String::with_capacity(256);
let human_time = atime_to_str(pw.atime);
extra.push_str(&human_time);
extra.push_str("; ");
extra.push_str(t!("vault.u2f.appinfo.authcount", xous::LANG));
extra.push_str(&pw.count.to_string());
let li = ListItem::new(
desc.to_string(), // these allocs will be slow, but we do it only once on boot
extra.to_string(),
true,
guid.to_string(),
pw.atime,
pw.count,
);
log::debug!("updating {} to list item {}", li.extra, li.key()); log::debug!("updating {} to list item {}", li.extra, li.key());
assert!( let exists = self.item_lists.lock().unwrap().insert_unique(entry.mode, li).is_some();
self.item_lists.lock().unwrap().insert_unique(entry.mode, li).is_some(), assert!(exists, "Somehow, the autotyped record isn't in the UX list for updating!");
"Somehow, the autotyped record isn't in the UX list for updating!")
;
}, },
_ => { _ => {
// no cached data, no action // no cached data, no action
@ -599,6 +593,9 @@ impl<'a> ActionManager<'a> {
let ser = serialize_app_info(&update); let ser = serialize_app_info(&update);
record.write(&ser).unwrap_or_else(|e| { record.write(&ser).unwrap_or_else(|e| {
self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); 0}); self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); 0});
// update the item cache so it appears on the screen
let li = make_u2f_item_from_record(entry.key_guid.as_str().unwrap(), update);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
} }
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)), Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
} }
@ -657,8 +654,14 @@ impl<'a> ActionManager<'a> {
if let Ok(d) = u32::from_str_radix(edit_data.content()[5].content.as_str().unwrap(), 10) { if let Ok(d) = u32::from_str_radix(edit_data.content()[5].content.as_str().unwrap(), 10) {
pw.digits = d; pw.digits = d;
} }
// update the disk
storage.update(&choice, key_guid, &mut pw) let ret = storage.update(&choice, key_guid, &mut pw);
if ret.is_ok() {
// update the item cache
let li = make_totp_item_from_record(key_guid, pw);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
}
ret
}, },
storage::ContentKind::Password => { storage::ContentKind::Password => {
let mut pw: storage::PasswordRecord = match storage.get_record(&choice, key_guid) { let mut pw: storage::PasswordRecord = match storage.get_record(&choice, key_guid) {
@ -812,7 +815,14 @@ impl<'a> ActionManager<'a> {
// note the edit access, this counts as an access since the password was revealed // note the edit access, this counts as an access since the password was revealed
pw.count += 1; pw.count += 1;
pw.atime = utc_now().timestamp() as u64; pw.atime = utc_now().timestamp() as u64;
storage.update(&choice, key_guid, &mut pw) // update disk
let ret = storage.update(&choice, key_guid, &mut pw);
if ret.is_ok() {
// update item cache
let li = make_pw_item_from_record(&storage::hex(pw.hash()), pw);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
}
ret
}, },
}; };
@ -849,6 +859,12 @@ impl<'a> ActionManager<'a> {
pm.log_event_unchecked(event); pm.log_event_unchecked(event);
} }
pub(crate) fn is_db_empty(&mut self) -> bool {
self.mode_cache = {
(*self.mode.lock().unwrap()).clone()
};
self.item_lists.lock().unwrap().is_db_empty(self.mode_cache)
}
/// Populate the display list with data from the PDDB. Limited by total available RAM; probably /// Populate the display list with data from the PDDB. Limited by total available RAM; probably
/// would stop working if you have over 500-1k records with the current heap limits. /// would stop working if you have over 500-1k records with the current heap limits.
/// ///
@ -913,7 +929,7 @@ impl<'a> ActionManager<'a> {
if prev_entry.atime != pw_rec.atime || prev_entry.count != pw_rec.count { if prev_entry.atime != pw_rec.atime || prev_entry.count != pw_rec.count {
// this is expensive, so don't run it unless we have to // this is expensive, so don't run it unless we have to
let human_time = atime_to_str(pw_rec.atime); let human_time = atime_to_str(pw_rec.atime);
// note this code is duplicated in update_db_entry() // note this code is duplicated in make_pw_item_from_record()
extra.push_str(&human_time); extra.push_str(&human_time);
extra.push_str("; "); extra.push_str("; ");
extra.push_str(t!("vault.u2f.appinfo.authcount", xous::LANG)); extra.push_str(t!("vault.u2f.appinfo.authcount", xous::LANG));
@ -1016,20 +1032,7 @@ impl<'a> ActionManager<'a> {
for key in keys { for key in keys {
if let Some(data) = key.data { if let Some(data) = key.data {
if let Some(ai) = deserialize_app_info(data) { if let Some(ai) = deserialize_app_info(data) {
let extra = format!("{}; {}{}", let li = make_u2f_item_from_record(&key.name, ai);
atime_to_str(ai.atime),
t!("vault.u2f.appinfo.authcount", xous::LANG),
ai.count,
);
let desc = format!("{} (U2F)", ai.name);
let li = ListItem::new(
desc,
extra,
true,
key.name,
ai.count,
ai.atime,
);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li); self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
} else { } else {
let err = format!("{}:{}:{}: ({})[moved data]...", let err = format!("{}:{}:{}: ({})[moved data]...",
@ -1073,21 +1076,7 @@ impl<'a> ActionManager<'a> {
if let Some(data) = key.data { if let Some(data) = key.data {
match vault::ctap::storage::deserialize_credential(&data) { match vault::ctap::storage::deserialize_credential(&data) {
Some(result) => { Some(result) => {
let name = if let Some(display_name) = result.user_display_name { let li = make_fido_item_from_record(&key.name, result);
display_name
} else {
String::from_utf8(result.user_handle).unwrap_or("".to_string())
};
let desc = format!("{} / {} (FIDO2)", result.rp_id, String::from_utf8(result.credential_id).unwrap_or("---".to_string()));
let extra = format!("{}", name);
let li = ListItem::new(
desc,
extra,
true,
key.name,
0,
0,
);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li); self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
} }
None => { None => {
@ -1131,22 +1120,7 @@ impl<'a> ActionManager<'a> {
for key in keys { for key in keys {
if let Some(data) = key.data { if let Some(data) = key.data {
if let Some(totp) = storage::TotpRecord::try_from(data).ok() { if let Some(totp) = storage::TotpRecord::try_from(data).ok() {
let extra = format!("{}:{}:{}:{}:{}", let li = make_totp_item_from_record(&key.name, totp);
totp.secret,
totp.digits,
totp.timestep,
totp.algorithm,
if totp.is_hotp {"HOTP"} else {"TOTP"}
);
let desc = format!("{}", totp.name);
let li = ListItem::new(
desc,
extra,
true,
key.name,
0,
0,
);
self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li); self.item_lists.lock().unwrap().insert_unique(self.mode_cache, li);
} else { } else {
let err = format!("{}:{}:{}: ({})[moved data]...", let err = format!("{}:{}:{}: ({})[moved data]...",
@ -1617,4 +1591,75 @@ fn make_pw_name(description: &str, username: &str, dest: &mut String) {
dest.push_str(description); dest.push_str(description);
dest.push_str("/"); dest.push_str("/");
dest.push_str(username); dest.push_str(username);
}
fn make_u2f_item_from_record(guid: &str, ai: AppInfo) -> ListItem {
let extra = format!("{}; {}{}",
atime_to_str(ai.atime),
t!("vault.u2f.appinfo.authcount", xous::LANG),
ai.count,
);
let desc: String = format!("{} (U2F)", ai.name);
ListItem::new(
desc,
extra,
true,
guid.to_owned(),
ai.count,
ai.atime,
)
}
fn make_fido_item_from_record(guid: &str, result: PublicKeyCredentialSource) -> ListItem {
let name = if let Some(display_name) = result.user_display_name {
display_name
} else {
String::from_utf8(result.user_handle).unwrap_or("".to_string())
};
let desc = format!("{} / {} (FIDO2)", result.rp_id, String::from_utf8(result.credential_id).unwrap_or("---".to_string()));
let extra = format!("{}", name);
ListItem::new(
desc,
extra,
true,
guid.to_owned(),
0,
0,
)
}
fn make_totp_item_from_record(guid: &str, totp: TotpRecord) -> ListItem {
let extra = format!("{}:{}:{}:{}:{}",
totp.secret,
totp.digits,
totp.timestep,
totp.algorithm,
if totp.is_hotp {"HOTP"} else {"TOTP"}
);
let desc = format!("{}", totp.name);
ListItem::new(
desc,
extra,
true,
guid.to_owned(),
0,
0,
)
}
fn make_pw_item_from_record(guid: &str, pw: PasswordRecord) -> ListItem {
// create the list item from the updated entry
let mut desc = String::with_capacity(256);
make_pw_name(&pw.description, &pw.username, &mut desc);
let mut extra = String::with_capacity(256);
let human_time = atime_to_str(pw.atime);
extra.push_str(&human_time);
extra.push_str("; ");
extra.push_str(t!("vault.u2f.appinfo.authcount", xous::LANG));
extra.push_str(&pw.count.to_string());
ListItem::new(
desc.to_string(), // these allocs will be slow, but we do it only once on boot
extra.to_string(),
true,
guid.to_string(),
pw.atime,
pw.count,
)
} }

View file

@ -187,6 +187,9 @@ impl FilteredListView {
filter_range: None, filter_range: None,
} }
} }
pub fn is_db_empty(&self) -> bool {
self.list.len() == 0
}
pub fn expand(&mut self, capacity: usize) { pub fn expand(&mut self, capacity: usize) {
self.list.reserve(capacity.saturating_sub(self.list.len())) self.list.reserve(capacity.saturating_sub(self.list.len()))
} }
@ -467,6 +470,9 @@ impl ItemLists {
pw: FilteredListView::new(), pw: FilteredListView::new(),
} }
} }
pub fn is_db_empty(&self, list_type: VaultMode) -> bool {
self.li(list_type).is_db_empty()
}
fn li_mut(&mut self, list_type: VaultMode) -> &mut FilteredListView { fn li_mut(&mut self, list_type: VaultMode) -> &mut FilteredListView {
match list_type { match list_type {
VaultMode::Fido => &mut self.fido, VaultMode::Fido => &mut self.fido,

View file

@ -153,11 +153,7 @@ fn main() -> ! {
match opcode { match opcode {
Some(ActionOp::MenuAddnew) => { Some(ActionOp::MenuAddnew) => {
manager.activate(); manager.activate();
manager.menu_addnew(); manager.menu_addnew(); // this is responsible for updating the item cache
// this is necessary so the next redraw shows the newly added entry
// no cache clear is called for because new entries will always add to the list;
// there is no risk of "stale" entries persisting
manager.retrieve_db();
manager.deactivate(); manager.deactivate();
}, },
Some(ActionOp::MenuDeleteStage2) => { Some(ActionOp::MenuDeleteStage2) => {
@ -172,8 +168,7 @@ fn main() -> ! {
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let entry = buffer.to_original::<SelectedEntry, _>().unwrap(); let entry = buffer.to_original::<SelectedEntry, _>().unwrap();
manager.activate(); manager.activate();
manager.menu_edit(entry); manager.menu_edit(entry); // this is responsible for updating the item cache
manager.retrieve_db();
manager.deactivate(); manager.deactivate();
}, },
Some(ActionOp::MenuUnlockBasis) => { Some(ActionOp::MenuUnlockBasis) => {
@ -203,6 +198,13 @@ fn main() -> ! {
manager.deactivate(); manager.deactivate();
} }
Some(ActionOp::UpdateMode) => msg_blocking_scalar_unpack!(msg, _, _, _, _,{ Some(ActionOp::UpdateMode) => msg_blocking_scalar_unpack!(msg, _, _, _, _,{
// the password DBs are now not shared between modes, so no need to re-retrieve it.
if manager.is_db_empty() {
manager.retrieve_db();
}
xous::return_scalar(msg.sender, 1).unwrap();
}),
Some(ActionOp::ReloadDb) => msg_blocking_scalar_unpack!(msg, _, _, _, _,{
manager.retrieve_db(); manager.retrieve_db();
xous::return_scalar(msg.sender, 1).unwrap(); xous::return_scalar(msg.sender, 1).unwrap();
}), }),
@ -550,7 +552,7 @@ fn main() -> ! {
} }
Some(VaultOp::ReloadDbAndFullRedraw) => { Some(VaultOp::ReloadDbAndFullRedraw) => {
send_message(actions_conn, send_message(actions_conn,
Message::new_blocking_scalar(ActionOp::UpdateMode.to_usize().unwrap(), 0, 0, 0, 0) Message::new_blocking_scalar(ActionOp::ReloadDb.to_usize().unwrap(), 0, 0, 0, 0)
).ok(); ).ok();
vaultux.update_mode(); vaultux.update_mode();
if allow_redraw { if allow_redraw {
@ -562,7 +564,7 @@ fn main() -> ! {
// this set of calls will effectively force a reload of any UX data // this set of calls will effectively force a reload of any UX data
*mode.lock().unwrap() = VaultMode::Fido; *mode.lock().unwrap() = VaultMode::Fido;
send_message(actions_conn, send_message(actions_conn,
Message::new_blocking_scalar(ActionOp::UpdateMode.to_usize().unwrap(), 0, 0, 0, 0) Message::new_blocking_scalar(ActionOp::ReloadDb.to_usize().unwrap(), 0, 0, 0, 0)
).ok(); ).ok();
vaultux.update_mode(); vaultux.update_mode();
vaultux.input("").unwrap(); vaultux.input("").unwrap();

View file

@ -833,7 +833,7 @@ fn utc_now() -> DateTime<Utc> {
DateTime::from_utc(naive, Utc) DateTime::from_utc(naive, Utc)
} }
fn hex(data: Vec<u8>) -> String { pub fn hex(data: Vec<u8>) -> String {
use std::fmt::Write; use std::fmt::Write;
let mut s = String::with_capacity(2 * data.len()); let mut s = String::with_capacity(2 * data.len());
for byte in data { for byte in data {