mirror of
https://github.com/lexmount/moli.git
synced 2026-11-20 08:03:30 +00:00
refactor(storage): remove unused origin Web Storage usage aggregation
Remove the origin-wide Web Storage quota API and its unused SQLite key listing. CDP and navigator quota queries already exclude Web Storage. Retain single-area metadata reads and the indexed entry-count query needed for cold origin clears.
This commit is contained in:
@@ -867,7 +867,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn origin_area_usage_and_clear_include_partitioned_area_keys() {
|
||||
fn origin_clear_includes_partitioned_area_keys() {
|
||||
let origin = "https://cdn.example.test";
|
||||
let first_party = first_party_area_key(origin);
|
||||
let top_a = web_storage_partitioned_area_key(origin, "https://top-a.example.test");
|
||||
@@ -883,18 +883,12 @@ mod tests {
|
||||
assert!(store.set_item(&sibling, "s", "dddd"));
|
||||
|
||||
assert_eq!(store.usage_bytes(&first_party), 1);
|
||||
assert_eq!(store.usage_bytes_for_origin_areas(origin), 6);
|
||||
assert_eq!(
|
||||
store.usage_bytes_for_origin_areas("https://sibling.example.test"),
|
||||
4
|
||||
);
|
||||
|
||||
store.clear_origin(&first_party);
|
||||
assert_eq!(store.usage_bytes_for_origin_areas(origin), 5);
|
||||
assert_eq!(store.get_item(&top_a, "a"), Some("bb".to_owned()));
|
||||
|
||||
store.clear_origin_areas(origin);
|
||||
assert_eq!(store.usage_bytes_for_origin_areas(origin), 0);
|
||||
assert_eq!(store.get_item(&first_party, "fp"), None);
|
||||
assert_eq!(store.get_item(&top_a, "a"), None);
|
||||
assert_eq!(store.get_item(&top_b, "b"), None);
|
||||
assert_eq!(store.get_item(&sibling, "s"), Some("dddd".to_owned()));
|
||||
|
||||
@@ -35,11 +35,7 @@ pub(super) struct SqliteBackend {
|
||||
cache: Mutex<Cache>,
|
||||
pub(super) namespace: parking_lot::RwLock<()>,
|
||||
}
|
||||
struct AreaMetadata {
|
||||
usage: usize,
|
||||
entries: usize,
|
||||
}
|
||||
const ORIGIN_METADATA_SQL: &str = "SELECT storage_key,usage_bytes,entry_count FROM areas
|
||||
const ORIGIN_METADATA_SQL: &str = "SELECT storage_key,entry_count FROM areas
|
||||
WHERE storage_key=?1 OR (storage_key>=?2 AND storage_key<?3)";
|
||||
|
||||
fn origin_prefix_range(origin: &str) -> (String, String) {
|
||||
@@ -356,56 +352,22 @@ impl SqliteBackend {
|
||||
fn area_metadata_for_origin(
|
||||
&self,
|
||||
origin: &str,
|
||||
) -> std::result::Result<BTreeMap<String, AreaMetadata>, WebStorageMutationError> {
|
||||
) -> std::result::Result<BTreeMap<String, usize>, WebStorageMutationError> {
|
||||
let (prefix, upper) = origin_prefix_range(origin);
|
||||
let origin = origin.to_owned();
|
||||
Ok(self.client.query(move |connection| {
|
||||
let mut statement = connection.prepare_cached(ORIGIN_METADATA_SQL)?;
|
||||
statement
|
||||
.query_map(params![origin, prefix, upper], |row| {
|
||||
Ok((
|
||||
row.get::<_, String>(0)?,
|
||||
row.get::<_, i64>(1)?,
|
||||
row.get::<_, i64>(2)?,
|
||||
))
|
||||
Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
|
||||
})?
|
||||
.map(|row| {
|
||||
let (key, usage, entries) = row?;
|
||||
Ok((
|
||||
key,
|
||||
AreaMetadata {
|
||||
usage: usize::try_from(usage).map_err(WritebackError::new)?,
|
||||
entries: usize::try_from(entries).map_err(WritebackError::new)?,
|
||||
},
|
||||
))
|
||||
let (key, entries) = row?;
|
||||
Ok((key, usize::try_from(entries).map_err(WritebackError::new)?))
|
||||
})
|
||||
.collect()
|
||||
})?)
|
||||
}
|
||||
pub(super) fn usage_bytes_for_origin_areas(
|
||||
&self,
|
||||
origin: &str,
|
||||
) -> std::result::Result<usize, WebStorageMutationError> {
|
||||
let _namespace = self.namespace.write();
|
||||
// Pin live areas before querying SQL: a concurrent acknowledgement can
|
||||
// otherwise release the last copy of a newer logical value.
|
||||
let live = self.live_areas_for_origin(origin);
|
||||
let mut metadata = self.area_metadata_for_origin(origin)?;
|
||||
for (key, area) in live {
|
||||
if let Some(state) = &*area.state.lock() {
|
||||
metadata.insert(
|
||||
key,
|
||||
AreaMetadata {
|
||||
usage: state.size,
|
||||
entries: state.values.len(),
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
Ok(metadata
|
||||
.values()
|
||||
.fold(0usize, |sum, area| sum.saturating_add(area.usage)))
|
||||
}
|
||||
fn area(&self, origin: &str) -> Arc<Area> {
|
||||
let mut cache = self.cache.lock();
|
||||
if let Some(area) = cache.areas.get(origin).and_then(Weak::upgrade) {
|
||||
@@ -533,7 +495,7 @@ impl SqliteBackend {
|
||||
let nonempty = state
|
||||
.as_ref()
|
||||
.map(|data| !data.values.is_empty())
|
||||
.unwrap_or_else(|| metadata.get(key).is_some_and(|area| area.entries > 0));
|
||||
.unwrap_or_else(|| metadata.get(key).is_some_and(|entries| *entries > 0));
|
||||
if !nonempty {
|
||||
continue;
|
||||
}
|
||||
@@ -563,28 +525,6 @@ impl SqliteBackend {
|
||||
}
|
||||
Ok(changed)
|
||||
}
|
||||
pub(super) fn area_keys_for_origin(
|
||||
&self,
|
||||
origin: &str,
|
||||
) -> std::result::Result<Vec<String>, WebStorageMutationError> {
|
||||
let prefix = web_storage_area_key_prefix_for_origin(origin);
|
||||
let mut keys = self
|
||||
.area_metadata_for_origin(origin)?
|
||||
.into_keys()
|
||||
.collect::<Vec<_>>();
|
||||
keys.extend(
|
||||
self.cache
|
||||
.lock()
|
||||
.areas
|
||||
.iter()
|
||||
.filter(|(_, area)| area.strong_count() != 0)
|
||||
.map(|(key, _)| key.clone()),
|
||||
);
|
||||
keys.retain(|key| key == origin || key.starts_with(&prefix));
|
||||
keys.sort();
|
||||
keys.dedup();
|
||||
Ok(keys)
|
||||
}
|
||||
}
|
||||
impl WebStorageStore {
|
||||
pub fn lease_area(
|
||||
|
||||
@@ -441,45 +441,24 @@ fn origin_clear_includes_cold_partitioned_areas_and_preserves_other_origins() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn usage_queries_read_cold_metadata_and_overlay_uncommitted_area_sizes() {
|
||||
fn single_area_usage_reads_cold_metadata_and_current_dirty_size() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let runtime = Runtime::new().unwrap();
|
||||
let (store, owner) = open(root.path(), &runtime);
|
||||
let origin = "https://usage.test";
|
||||
let first = web_storage_partitioned_area_key(origin, origin);
|
||||
let other = web_storage_partitioned_area_key(origin, "https://other.test");
|
||||
let fresh = web_storage_partitioned_area_key(origin, "https://new.test");
|
||||
let sibling = web_storage_partitioned_area_key("https://usage.test.sibling", origin);
|
||||
for key in [origin, &first, &other, &sibling] {
|
||||
store.try_set_item(key, "key", "old").unwrap();
|
||||
}
|
||||
let key = web_storage_partitioned_area_key("https://usage.test", "https://usage.test");
|
||||
store.try_set_item(&key, "key", "old").unwrap();
|
||||
owner.flush().unwrap();
|
||||
assert_eq!(resident(&store), 0);
|
||||
let cold = store.lease_area(&first).unwrap().unwrap();
|
||||
assert!(cold.area.state.lock().is_none());
|
||||
assert_eq!(store.try_usage_bytes(&first).unwrap(), 3);
|
||||
assert_eq!(store.try_usage_bytes_for_origin_areas(origin).unwrap(), 9);
|
||||
let cold = store.lease_area(&key).unwrap().unwrap();
|
||||
assert_eq!(store.try_usage_bytes(&key).unwrap(), 3);
|
||||
assert!(
|
||||
cold.area.state.lock().is_none(),
|
||||
"usage must not materialize entries"
|
||||
);
|
||||
|
||||
store.try_set_item(&other, "key", "changed").unwrap();
|
||||
store.try_set_item(&fresh, "new", "fresh").unwrap();
|
||||
store.try_clear(origin).unwrap();
|
||||
// The known single area reads its uncommitted value; the origin query
|
||||
// overlays both newly created and modified maps, including pending clear.
|
||||
assert_eq!(store.try_usage_bytes(&other).unwrap(), 7);
|
||||
assert_eq!(store.try_usage_bytes_for_origin_areas(origin).unwrap(), 15);
|
||||
assert!(cold.area.state.lock().is_none());
|
||||
owner.flush().unwrap();
|
||||
assert_eq!(store.try_usage_bytes_for_origin_areas(origin).unwrap(), 15);
|
||||
assert_eq!(
|
||||
store
|
||||
.try_usage_bytes_for_origin_areas("https://usage.test.sibling")
|
||||
.unwrap(),
|
||||
3
|
||||
"usage must not load entries"
|
||||
);
|
||||
store.try_set_item(&key, "key", "changed").unwrap();
|
||||
assert_eq!(store.try_usage_bytes(&key).unwrap(), 7);
|
||||
store.try_clear(&key).unwrap();
|
||||
assert_eq!(store.try_usage_bytes(&key).unwrap(), 0);
|
||||
drop(cold);
|
||||
owner.close().unwrap();
|
||||
}
|
||||
|
||||
@@ -414,33 +414,6 @@ impl WebStorageStore {
|
||||
pub fn usage_bytes(&self, origin: &str) -> usize {
|
||||
self.try_usage_bytes(origin).unwrap_or(0)
|
||||
}
|
||||
fn area_keys_for_origin(
|
||||
&self,
|
||||
origin: &str,
|
||||
) -> std::result::Result<Vec<String>, WebStorageMutationError> {
|
||||
match &self.backend {
|
||||
WebStorageBackend::Memory(memory) => Ok(memory.lock().area_keys_for_origin(origin)),
|
||||
WebStorageBackend::Json(json) => Ok(json.lock().memory.area_keys_for_origin(origin)),
|
||||
WebStorageBackend::Sqlite(sqlite) => sqlite.area_keys_for_origin(origin),
|
||||
}
|
||||
}
|
||||
pub fn try_usage_bytes_for_origin_areas(
|
||||
&self,
|
||||
origin: &str,
|
||||
) -> std::result::Result<usize, WebStorageMutationError> {
|
||||
if let WebStorageBackend::Sqlite(sqlite) = &self.backend {
|
||||
return sqlite.usage_bytes_for_origin_areas(origin);
|
||||
}
|
||||
self.area_keys_for_origin(origin)?
|
||||
.iter()
|
||||
.try_fold(0usize, |sum, key| {
|
||||
self.try_usage_bytes(key)
|
||||
.map(|usage| sum.saturating_add(usage))
|
||||
})
|
||||
}
|
||||
pub fn usage_bytes_for_origin_areas(&self, origin: &str) -> usize {
|
||||
self.try_usage_bytes_for_origin_areas(origin).unwrap_or(0)
|
||||
}
|
||||
pub fn try_clear_origin_areas(
|
||||
&self,
|
||||
origin: &str,
|
||||
|
||||
Reference in New Issue
Block a user