use std::borrow::Cow;
use std::collections::{HashMap, HashSet};
use ids::{IdsFollowersRecord, IdsUnfollowedRecord};
use itertools::Itertools as _;
use rand::{Rng as _, RngCore as _};
use redb::StorageError;
use redb_bincode::{ReadableTable, Table};
use rostra_core::event::{
EventContentRaw, EventExt as _, VerifiedEvent, VerifiedEventContent, content_kind,
};
use rostra_core::id::{RostraId, ToShort as _};
use rostra_core::{ContentHash, ExternalEventId, ShortEventId, Timestamp};
use tables::EventRecord;
use tables::event::{
ContentStoreRecord, EventContentResult, EventContentState, EventsMissingRecord,
};
use tables::ids::IdsFolloweesRecord;
use tracing::{debug, error};
use super::event_order::EventOrder;
use super::id_self::IdSelfAccountRecord;
use super::{
Database, DbError, DbResult, EventsHeadsTableRecord, InsertEventOutcome, content_rc,
content_store, events, events_by_time, events_content_state, events_heads, events_missing,
events_self, get_first_in_range, get_last_in_range, ids, ids_follow_events, ids_followees,
ids_followers, ids_self, tables,
};
use crate::{
IdSocialProfileRecord, IdsDataUsageRecord, LOG_TARGET, Latest, LatestEventValue,
SocialPostRecord, WotData, events_content_missing, ids_data_usage, ids_full, social_posts,
social_profiles,
};
pub(crate) trait RandomTableKey: Copy + Ord {
fn min_key() -> Self;
fn random_key() -> Self;
fn max_key() -> Self;
}
impl RandomTableKey for ShortEventId {
fn min_key() -> Self {
Self::ZERO
}
fn random_key() -> Self {
Self::random()
}
fn max_key() -> Self {
Self::MAX
}
}
impl RandomTableKey for ExternalEventId {
fn min_key() -> Self {
Self::new(RostraId::ZERO, ShortEventId::ZERO)
}
fn random_key() -> Self {
let mut rng = rand::rng();
let mut rostra_id = [0u8; 32];
let mut event_id = [0u8; 16];
rng.fill_bytes(&mut rostra_id);
rng.fill_bytes(&mut event_id);
Self::new(
RostraId::from_bytes(rostra_id),
ShortEventId::from_bytes(event_id),
)
}
fn max_key() -> Self {
Self::new(RostraId::MAX, ShortEventId::MAX)
}
}
impl Database {
fn merge_deleted_by_tx(
current: Option<ShortEventId>,
candidate: Option<EventOrder>,
events_table: &impl events::ReadableTable,
) -> DbResult<Option<ShortEventId>> {
let Some(candidate) = candidate else {
return Ok(current);
};
let Some(current_id) = current else {
return Ok(Some(candidate.event_id()));
};
let current_timestamp = events_table
.get(¤t_id)?
.map(|event| event.value().timestamp())
.ok_or(DbError::MissingDeletionAttribution {
event_id: current_id,
location: snafu::Location::new(file!(), line!(), column!()),
})?;
Ok(Some(
EventOrder::new(current_timestamp, current_id)
.max(candidate)
.event_id(),
))
}
pub(crate) fn read_followees_tx(
id: RostraId,
ids_followees_table: &impl ids_followees::ReadableTable,
) -> DbResult<HashMap<RostraId, IdsFolloweesRecord>> {
Ok(ids_followees_table
.range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
.map(|res| res.map(|(k, v)| (k.value().1, v.value())))
.collect::<Result<HashMap<_, _>, _>>()?)
}
pub(crate) fn read_followees_tx_iter(
id: RostraId,
ids_followees_table: &impl ids_followees::ReadableTable,
) -> DbResult<impl Iterator<Item = Result<(RostraId, IdsFolloweesRecord), StorageError>>> {
Ok(ids_followees_table
.range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
.map_ok(|(k, v)| (k.value().1, v.value())))
}
pub(crate) fn read_followers_tx(
id: RostraId,
ids_followers_table: &impl ids_followers::ReadableTable,
) -> DbResult<HashMap<RostraId, IdsFollowersRecord>> {
Ok(ids_followers_table
.range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
.map(|res| res.map(|(k, v)| (k.value().1, v.value())))
.collect::<Result<HashMap<_, _>, _>>()?)
}
pub(crate) fn compute_wot_tx(
self_id: RostraId,
direct_followees: &HashMap<RostraId, IdsFolloweesRecord>,
ids_followees_table: &impl ids_followees::ReadableTable,
) -> DbResult<WotData> {
let mut extended = HashSet::new();
for followee_id in direct_followees.keys() {
for result in Self::read_followees_tx_iter(*followee_id, ids_followees_table)? {
let (ext_id, _record) = result?;
if ext_id != self_id && !direct_followees.contains_key(&ext_id) {
extended.insert(ext_id);
}
}
}
Ok(WotData {
followees: direct_followees.clone(),
extended,
})
}
pub(crate) fn insert_self_event_id_tx(
event_id: impl Into<rostra_core::ShortEventId>,
events_self_table: &mut events_self::Table,
) -> DbResult<()> {
events_self_table.insert(&event_id.into(), &())?;
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn insert_event_tx(
event: VerifiedEvent,
ids_full_t: &mut ids_full::Table,
events_table: &mut events::Table,
events_missing_table: &mut events_missing::Table,
events_heads_table: &mut events_heads::Table,
events_by_time_table: &mut events_by_time::Table,
events_content_state_table: &mut events_content_state::Table,
content_store_table: &mut content_store::Table,
content_rc_table: &mut content_rc::Table,
events_content_missing_table: &mut events_content_missing::Table,
mut ids_data_usage_table: Option<&mut ids_data_usage::Table>,
) -> DbResult<InsertEventOutcome> {
let author = event.author();
let event_id = event.event_id.to_short();
ids_full_t.register(author)?;
if events_table.get(&event_id)?.is_some() {
return Ok(InsertEventOutcome::AlreadyPresent);
}
let (was_missing, is_deleted) = match events_missing_table
.remove(&(author, event_id))?
.map(|g| g.value())
{
Some(prev_missing) => {
(
true,
if let Some(deleted_by) = prev_missing.deleted_by {
events_content_state_table
.insert(&event_id, &EventContentState::Deleted { deleted_by })?;
true
} else {
false
},
)
}
_ => {
events_heads_table.insert(&(author, event_id), &EventsHeadsTableRecord)?;
(false, false)
}
};
let parent_ids = if event.parent_aux() == event.parent_prev() {
vec![(event.parent_aux(), true)]
} else {
vec![(event.parent_aux(), true), (event.parent_prev(), false)]
};
let mut deleted_parent = None;
let mut reverted_parent_content: Option<EventContentRaw> = None;
let mut missing_parents = vec![];
for (parent_id, parent_is_aux) in parent_ids {
let Some(parent_id) = parent_id else {
continue;
};
let parent_event = events_table
.get(&parent_id)?
.map(|r| r.value())
.filter(|parent| parent.author() == author);
if let Some(parent_event_record) = parent_event {
if event.is_delete_parent_aux_content_set() && parent_is_aux {
deleted_parent = Some(parent_id);
let parent_content_hash = parent_event_record.content_hash();
let old_state = events_content_state_table
.get(&parent_id)?
.map(|state| state.value());
let deleted_by = Self::merge_deleted_by_tx(
match old_state {
Some(EventContentState::Deleted { deleted_by }) => Some(deleted_by),
_ => None,
},
Some(EventOrder::new(event.timestamp(), event_id)),
events_table,
)?
.expect("a direct deletion candidate always produces attribution");
events_content_state_table
.insert(&parent_id, &EventContentState::Deleted { deleted_by })?;
if let Some(EventContentState::Missing {
next_fetch_attempt, ..
}) = old_state
{
events_content_missing_table.remove(&(next_fetch_attempt, parent_id))?;
}
let rc_already_decremented = matches!(
old_state,
Some(
EventContentState::Deleted { .. }
| EventContentState::Pruned
| EventContentState::Invalid
)
);
if old_state.is_none() {
if let Some(ContentStoreRecord(cow)) = content_store_table
.get(&parent_content_hash)?
.map(|g| g.value())
{
reverted_parent_content = Some(cow.into_owned());
}
}
if !rc_already_decremented {
Database::decrement_content_rc_tx(parent_content_hash, content_rc_table)?;
}
if !matches!(old_state, Some(EventContentState::Deleted { .. })) {
if let Some(ref mut usage_table) = ids_data_usage_table {
let parent_author = parent_event_record.author();
Database::track_payload_deletion_tx(
parent_author,
parent_event_record.content_len(),
old_state.as_ref(),
usage_table,
)?;
}
}
}
} else {
let old_deleted_by = events_missing_table
.get(&(author, parent_id))?
.and_then(|record| record.value().deleted_by);
let deleted_by = Self::merge_deleted_by_tx(
old_deleted_by,
(event.is_delete_parent_aux_content_set() && parent_is_aux)
.then_some(EventOrder::new(event.timestamp(), event_id)),
events_table,
)?;
events_missing_table
.insert(&(author, parent_id), &EventsMissingRecord { deleted_by })?;
missing_parents.push(parent_id);
}
events_heads_table.remove(&(author, parent_id))?;
}
events_table.insert(
&event_id,
&EventRecord {
signed: event.into(),
},
)?;
events_by_time_table.insert(&(event.timestamp(), event_id), &())?;
if let Some(ref mut usage_table) = ids_data_usage_table {
Database::track_new_event_tx(author, usage_table)?;
}
let content_hash = event.content_hash();
if is_deleted {
if let Some(ref mut usage_table) = ids_data_usage_table {
Database::track_new_deleted_payload_tx(author, event.content_len(), usage_table)?;
}
} else {
Database::increment_content_rc_tx(content_hash, content_rc_table)?;
if let Some(ref mut usage_table) = ids_data_usage_table {
Database::track_new_payload_tx(author, event.content_len(), usage_table)?;
}
if 0 < event.content_len() {
events_content_state_table.insert(
&event_id,
&EventContentState::Missing {
last_fetch_attempt: None,
fetch_attempt_count: 0,
next_fetch_attempt: Timestamp::ZERO,
},
)?;
if content_store_table.get(&content_hash)?.is_none() {
events_content_missing_table.insert(&(Timestamp::ZERO, event_id), &())?;
}
} else {
if content_store_table.get(&content_hash)?.is_none() {
content_store_table.insert(
&content_hash,
&ContentStoreRecord(Cow::Owned(EventContentRaw::new(vec![]))),
)?;
}
if let Some(ref mut usage_table) = ids_data_usage_table {
Database::track_payload_processed_tx(author, event.content_len(), usage_table)?;
}
}
}
Ok(InsertEventOutcome::Inserted {
was_missing,
is_deleted,
deleted_parent,
reverted_parent_content,
missing_parents,
}
.validate())
}
pub(crate) fn can_insert_event_content_tx(
VerifiedEventContent { event, .. }: &VerifiedEventContent,
events_content_state_table: &impl events_content_state::ReadableTable,
) -> DbResult<bool> {
let event_id = event.event_id.to_short();
if let Some(state) = events_content_state_table
.get(&event_id)?
.map(|g| g.value())
{
match state {
EventContentState::Missing { .. } => {
return Ok(true);
}
EventContentState::Deleted { .. }
| EventContentState::Pruned
| EventContentState::Invalid => {
return Ok(false);
}
}
}
Ok(false)
}
pub(crate) fn prune_event_content_tx(
event_id: impl Into<ShortEventId>,
content_hash: ContentHash,
events_content_state_table: &mut events_content_state::Table,
content_rc_table: &mut content_rc::Table,
events_content_missing_table: &mut events_content_missing::Table,
data_usage_info: Option<(RostraId, u32, &mut ids_data_usage::Table)>,
) -> DbResult<bool> {
let event_id = event_id.into();
let old_state = events_content_state_table
.get(&event_id)?
.map(|g| g.value());
match old_state {
Some(EventContentState::Deleted { .. }) => {
return Ok(false);
}
Some(EventContentState::Invalid) => {
return Ok(false);
}
Some(EventContentState::Pruned) => {
return Ok(true);
}
Some(EventContentState::Missing { .. }) | None => {
}
}
Database::decrement_content_rc_tx(content_hash, content_rc_table)?;
if let Some((author, content_len, usage_table)) = data_usage_info {
Database::track_payload_pruning_tx(
author,
content_len,
old_state.as_ref(),
usage_table,
)?;
}
events_content_state_table.insert(&event_id, &EventContentState::Pruned)?;
if let Some(EventContentState::Missing {
next_fetch_attempt, ..
}) = old_state
{
events_content_missing_table.remove(&(next_fetch_attempt, event_id))?;
}
Ok(true)
}
pub(crate) fn get_missing_events_for_id_tx(
author: RostraId,
events_missing_table: &impl events_missing::ReadableTable,
) -> DbResult<Vec<ShortEventId>> {
Ok(events_missing_table
.range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
.map(|r| r.map(|(k, _v)| k.value().1))
.collect::<Result<Vec<_>, _>>()?)
}
pub(crate) fn get_heads_events_tx(
author: RostraId,
events_heads_table: &impl events_heads::ReadableTable,
) -> DbResult<Vec<ShortEventId>> {
Ok(events_heads_table
.range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
.map(|r| r.map(|(k, _v)| k.value().1))
.collect::<Result<Vec<_>, _>>()?)
}
pub(crate) fn count_missing_events_for_id_tx(
author: RostraId,
events_missing_table: &impl events_missing::ReadableTable,
) -> DbResult<usize> {
Ok(events_missing_table
.range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
.count())
}
pub(crate) fn count_heads_events_tx(
author: RostraId,
events_heads_table: &impl events_heads::ReadableTable,
) -> DbResult<usize> {
Ok(events_heads_table
.range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
.count())
}
pub(crate) fn get_event_tx(
event: impl Into<ShortEventId>,
events_table: &impl events::ReadableTable,
) -> DbResult<Option<EventRecord>> {
Ok(events_table.get(&event.into())?.map(|r| r.value()))
}
pub(crate) fn get_social_post_tx(
event: impl Into<ShortEventId>,
social_posts_table: &impl social_posts::ReadableTable,
) -> DbResult<Option<SocialPostRecord>> {
Ok(social_posts_table.get(&event.into())?.map(|r| r.value()))
}
pub(crate) fn has_event_tx(
event: impl Into<ShortEventId>,
events_table: &impl events::ReadableTable,
) -> DbResult<bool> {
Ok(events_table.get(&event.into())?.is_some())
}
pub(crate) fn get_event_content_state_tx(
event: impl Into<ShortEventId>,
events_content_state_table: &impl events_content_state::ReadableTable,
) -> DbResult<Option<EventContentState>> {
Ok(events_content_state_table
.get(&event.into())?
.map(|r| r.value()))
}
pub(crate) fn get_event_content_full_tx(
event_id: impl Into<ShortEventId>,
content_hash: ContentHash,
events_content_state_table: &impl events_content_state::ReadableTable,
content_store_table: &impl content_store::ReadableTable,
) -> DbResult<Option<EventContentResult>> {
let event_id = event_id.into();
if let Some(state) = events_content_state_table
.get(&event_id)?
.map(|r| r.value())
{
match state {
EventContentState::Missing { .. } => {
}
EventContentState::Deleted { deleted_by } => {
return Ok(Some(EventContentResult::Deleted { deleted_by }));
}
EventContentState::Pruned => {
return Ok(Some(EventContentResult::Pruned));
}
EventContentState::Invalid => {
return Ok(Some(EventContentResult::Invalid));
}
}
}
Ok(Some(
match content_store_table.get(&content_hash)?.map(|r| r.value()) {
Some(ContentStoreRecord(content)) => {
EventContentResult::Present(content.into_owned())
}
None => EventContentResult::Missing,
},
))
}
pub(crate) fn has_event_content_tx(
event_id: impl Into<ShortEventId>,
content_hash: ContentHash,
events_content_state_table: &impl events_content_state::ReadableTable,
content_store_table: &impl content_store::ReadableTable,
) -> DbResult<bool> {
let event_id = event_id.into();
if events_content_state_table.get(&event_id)?.is_some() {
return Ok(false);
}
Ok(content_store_table.get(&content_hash)?.is_some())
}
#[cfg(test)]
pub(crate) fn is_content_available_for_event_tx(
event_id: impl Into<ShortEventId>,
content_hash: ContentHash,
events_content_state_table: &impl events_content_state::ReadableTable,
content_store_table: &impl content_store::ReadableTable,
) -> DbResult<bool> {
let event_id = event_id.into();
if let Some(state) = events_content_state_table
.get(&event_id)?
.map(|g| g.value())
{
match state {
EventContentState::Missing { .. } => {}
EventContentState::Deleted { .. }
| EventContentState::Pruned
| EventContentState::Invalid => {
return Ok(false);
}
}
}
Ok(content_store_table.get(&content_hash)?.is_some())
}
pub(crate) fn insert_follow_tx(
author: RostraId,
event_order: EventOrder,
content: content_kind::Follow,
followees_table: &mut Table<(RostraId, RostraId), IdsFolloweesRecord>,
followers_table: &mut Table<(RostraId, RostraId), IdsFollowersRecord>,
follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
unfollowed_table: &mut Table<(RostraId, RostraId), IdsUnfollowedRecord>,
) -> DbResult<bool> {
let followee = content.followee;
let db_key = (author, followee);
let epoch_boundary = unfollowed_table
.get(&db_key)?
.map(|record| record.value())
.map(|record| EventOrder::new(record.ts, record.event_id));
if epoch_boundary.is_some_and(|boundary| event_order <= boundary) {
return Ok(false);
}
follow_events_table.insert(
&(
author,
followee,
event_order.timestamp(),
event_order.event_id(),
),
&(),
)?;
let existing = followees_table.get(&db_key)?.map(|v| v.value());
if let Some(ref followees) = existing {
if event_order <= EventOrder::new(followees.latest_ts, followees.latest_event_id) {
let first_ts = Self::first_follow_ts_after_tx(
author,
followee,
epoch_boundary,
follow_events_table,
)?
.unwrap_or(followees.latest_ts);
if first_ts == followees.first_ts {
return Ok(false);
}
followees_table.insert(&db_key, &followees.clone().with_first_ts(first_ts))?;
return Ok(true);
}
}
let timestamp = event_order.timestamp();
let first_ts =
Self::first_follow_ts_after_tx(author, followee, epoch_boundary, follow_events_table)?
.unwrap_or(timestamp);
let tags_selector = content.persona_tags_selector.clone();
let selector = content.selector();
followees_table.insert(
&db_key,
&IdsFolloweesRecord::new(
timestamp,
event_order.event_id(),
first_ts,
selector,
tags_selector,
),
)?;
followers_table.insert(&(followee, author), &IdsFollowersRecord {})?;
debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Follow update");
Ok(true)
}
#[allow(deprecated)]
pub(crate) fn insert_unfollow_tx(
author: RostraId,
event_order: EventOrder,
followee: RostraId,
followees_table: &mut Table<(RostraId, RostraId), IdsFolloweesRecord>,
followers_table: &mut Table<(RostraId, RostraId), IdsFollowersRecord>,
follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
unfollowed_table: &mut Table<(RostraId, RostraId), IdsUnfollowedRecord>,
) -> DbResult<bool> {
let db_key = (author, followee);
if let Some(unfollowed) = unfollowed_table.get(&db_key)?.map(|v| v.value()) {
if event_order <= EventOrder::new(unfollowed.ts, unfollowed.event_id) {
return Ok(false);
}
}
unfollowed_table.insert(
&db_key,
&IdsUnfollowedRecord {
ts: event_order.timestamp(),
event_id: event_order.event_id(),
},
)?;
Self::prune_follow_events_through_tx(author, followee, event_order, follow_events_table)?;
let existing = followees_table.get(&db_key)?.map(|v| v.value());
if let Some(followees) = existing {
if event_order < EventOrder::new(followees.latest_ts, followees.latest_event_id) {
let first_ts = Self::first_follow_ts_after_tx(
author,
followee,
Some(event_order),
follow_events_table,
)?
.unwrap_or(followees.latest_ts);
followees_table.insert(&db_key, &followees.with_first_ts(first_ts))?;
debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Follow epoch boundary update");
return Ok(true);
}
}
followees_table.remove(&db_key)?;
followers_table.remove(&(followee, author))?;
debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Unfollow update");
Ok(true)
}
fn first_follow_ts_after_tx(
author: RostraId,
followee: RostraId,
boundary: Option<EventOrder>,
follow_events_table: &impl ids_follow_events::ReadableTable,
) -> DbResult<Option<Timestamp>> {
let lower = boundary
.map(|order| (author, followee, order.timestamp(), order.event_id()))
.unwrap_or((author, followee, Timestamp::ZERO, ShortEventId::ZERO));
let upper = (author, followee, Timestamp::MAX, ShortEventId::MAX);
for entry in follow_events_table.range(lower..=upper)? {
let (key, _) = entry?;
let (_, _, timestamp, event_id) = key.value();
let order = EventOrder::new(timestamp, event_id);
if boundary.is_none_or(|boundary| boundary < order) {
return Ok(Some(timestamp));
}
}
Ok(None)
}
fn prune_follow_events_through_tx(
author: RostraId,
followee: RostraId,
boundary: EventOrder,
follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
) -> DbResult<()> {
const BATCH_SIZE: usize = 256;
let range = (author, followee, Timestamp::ZERO, ShortEventId::ZERO)
..=(author, followee, boundary.timestamp(), boundary.event_id());
loop {
let keys = follow_events_table
.range(range.clone())?
.take(BATCH_SIZE)
.map(|entry| entry.map(|(key, _)| key.value()))
.collect::<Result<Vec<_>, _>>()?;
let len = keys.len();
for key in keys {
follow_events_table.remove(&key)?;
}
if len < BATCH_SIZE {
break;
}
}
Ok(())
}
pub(crate) fn insert_latest_value_tx<K, V>(
timestamp: Timestamp,
key: &K,
value: V,
table: &mut redb_bincode::Table<'_, K, Latest<V>>,
) -> DbResult<bool>
where
K: bincode::Encode + bincode::Decode<()>,
V: bincode::Encode + bincode::Decode<()>,
V: LatestEventValue,
{
let event_order = EventOrder::new(timestamp, value.event_id());
if let Some(existing_value) = table.get(key)?.map(|v| v.value()) {
if event_order <= EventOrder::new(existing_value.ts, existing_value.inner.event_id()) {
return Ok(false);
}
}
table.insert(
key,
&Latest {
ts: timestamp,
inner: value,
},
)?;
Ok(true)
}
pub(crate) fn read_self_id_tx(
id_self_table: &impl ids_self::ReadableTable,
) -> Result<Option<IdSelfAccountRecord>, DbError> {
Ok(id_self_table.get(&())?.map(|v| v.value()))
}
pub(crate) fn write_self_id_tx(
self_id: RostraId,
id_self_table: &mut Table<(), IdSelfAccountRecord>,
) -> DbResult<IdSelfAccountRecord> {
let id_self_record = IdSelfAccountRecord {
rostra_id: self_id,
iroh_secret: rand::rng().random(),
};
let _ = id_self_table.insert(&(), &id_self_record)?;
Ok(id_self_record)
}
pub(crate) fn read_head_tx(
self_id: RostraId,
events_heads_table: &impl ReadableTable<(RostraId, ShortEventId), EventsHeadsTableRecord>,
) -> DbResult<Option<ShortEventId>> {
Ok(events_heads_table
.range((self_id, ShortEventId::ZERO)..=(self_id, ShortEventId::MAX))?
.next()
.transpose()?
.map(|(k, _)| k.value().1))
}
pub(crate) fn get_heads_tx(
self_id: RostraId,
events_heads_table: &impl events_heads::ReadableTable,
) -> DbResult<HashSet<ShortEventId>> {
Ok(events_heads_table
.range((self_id, ShortEventId::ZERO)..=(self_id, ShortEventId::MAX))?
.map(|r| r.map(|(k, _)| k.value().1))
.collect::<Result<HashSet<_>, _>>()?)
}
pub(crate) fn get_social_profile_tx(
id: RostraId,
table: &impl social_profiles::ReadableTable,
) -> DbResult<Option<IdSocialProfileRecord>> {
Ok(table.get(&id)?.map(|v| v.value().inner))
}
pub(crate) fn get_random_table_key<K, V>(
table: &impl ReadableTable<K, V>,
) -> Result<Option<K>, DbError>
where
K: RandomTableKey + bincode::Decode<()> + bincode::Encode,
V: bincode::Decode<()> + bincode::Encode,
{
let pivot = K::random_key();
let before_pivot = K::min_key()..pivot;
let after_pivot = pivot..=K::max_key();
if rand::rng().random() {
if let Some(key) = get_first_in_range(table, after_pivot)? {
return Ok(Some(key));
}
return get_last_in_range(table, before_pivot);
}
if let Some(key) = get_last_in_range(table, before_pivot)? {
return Ok(Some(key));
}
get_first_in_range(table, after_pivot)
}
pub(crate) fn get_random_self_event(
events_self_table: &impl ReadableTable<ShortEventId, ()>,
) -> Result<Option<ShortEventId>, DbError> {
Self::get_random_table_key(events_self_table)
}
pub(crate) fn read_iroh_secret_tx(
ids_self_t: &impl ids_self::ReadableTable,
) -> DbResult<iroh::SecretKey> {
let self_id = Self::read_self_id_tx(ids_self_t)?
.expect("Must have iroh secret generated after opening");
Ok(iroh::SecretKey::from_bytes(&self_id.iroh_secret))
}
pub(crate) fn increment_content_rc_tx(
content_hash: ContentHash,
content_rc_table: &mut content_rc::Table,
) -> DbResult<u64> {
let current_count = content_rc_table
.get(&content_hash)?
.map(|g| g.value())
.unwrap_or(0);
let new_count = current_count + 1;
content_rc_table.insert(&content_hash, &new_count)?;
Ok(new_count)
}
pub(crate) fn decrement_content_rc_tx(
content_hash: ContentHash,
content_rc_table: &mut content_rc::Table,
) -> DbResult<u64> {
let current_count = match content_rc_table.get(&content_hash)?.map(|g| g.value()) {
Some(count) => count,
None => {
debug_assert!(
false,
"Decrementing RC for content with no RC entry: {content_hash}"
);
error!(
target: LOG_TARGET,
%content_hash,
"Decrementing RC for content with no RC entry - possible bug"
);
1
}
};
if current_count <= 1 {
content_rc_table.remove(&content_hash)?;
Ok(0)
} else {
let new_count = current_count
.checked_sub(1)
.expect("Reference count should never underflow");
content_rc_table.insert(&content_hash, &new_count)?;
Ok(new_count)
}
}
#[cfg(test)]
pub(crate) fn get_content_rc_tx(
content_hash: ContentHash,
content_rc_table: &impl content_rc::ReadableTable,
) -> DbResult<u64> {
Ok(content_rc_table
.get(&content_hash)?
.map(|g| g.value())
.unwrap_or(0)) }
pub const EVENT_METADATA_SIZE: u64 = 192;
fn get_usage_mut(
author: RostraId,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<IdsDataUsageRecord> {
Ok(ids_data_usage_table
.get(&author)?
.map(|g| g.value())
.unwrap_or_default())
}
pub(crate) fn track_new_event_tx(
author: RostraId,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<()> {
let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
usage.current_metadata_size += Self::EVENT_METADATA_SIZE;
usage.total_metadata_size += Self::EVENT_METADATA_SIZE;
usage.current_metadata_num += 1;
usage.total_metadata_num += 1;
ids_data_usage_table.insert(&author, &usage)?;
Ok(())
}
pub(crate) fn track_new_payload_tx(
author: RostraId,
content_len: u32,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<()> {
let len = u64::from(content_len);
let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
usage.total_content_size += len;
usage.total_payload_num += 1;
usage.missing_payload_size += len;
usage.missing_payload_num += 1;
ids_data_usage_table.insert(&author, &usage)?;
Ok(())
}
pub(crate) fn track_new_deleted_payload_tx(
author: RostraId,
content_len: u32,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<()> {
let len = u64::from(content_len);
let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
usage.total_content_size += len;
usage.total_payload_num += 1;
usage.deleted_payload_size += len;
usage.deleted_payload_num += 1;
ids_data_usage_table.insert(&author, &usage)?;
Ok(())
}
pub(crate) fn track_payload_processed_tx(
author: RostraId,
content_len: u32,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<()> {
let len = u64::from(content_len);
let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
usage.current_content_size += len;
usage.current_payload_num += 1;
ids_data_usage_table.insert(&author, &usage)?;
Ok(())
}
pub(crate) fn track_payload_invalid_tx(
author: RostraId,
content_len: u32,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<()> {
let len = u64::from(content_len);
let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
usage.invalid_payload_size += len;
usage.invalid_payload_num += 1;
ids_data_usage_table.insert(&author, &usage)?;
Ok(())
}
pub(crate) fn track_payload_deletion_tx(
author: RostraId,
content_len: u32,
old_state: Option<&EventContentState>,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<()> {
let len = u64::from(content_len);
let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
match old_state {
Some(EventContentState::Missing { .. }) => {
usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
}
Some(EventContentState::Invalid) => {
usage.invalid_payload_size = usage.invalid_payload_size.saturating_sub(len);
usage.invalid_payload_num = usage.invalid_payload_num.saturating_sub(1);
}
Some(EventContentState::Pruned) => {
usage.pruned_payload_size = usage.pruned_payload_size.saturating_sub(len);
usage.pruned_payload_num = usage.pruned_payload_num.saturating_sub(1);
}
None => {
usage.current_content_size = usage.current_content_size.saturating_sub(len);
usage.current_payload_num = usage.current_payload_num.saturating_sub(1);
}
Some(EventContentState::Deleted { .. }) => {}
}
usage.deleted_payload_size += len;
usage.deleted_payload_num += 1;
ids_data_usage_table.insert(&author, &usage)?;
Ok(())
}
pub(crate) fn track_payload_pruning_tx(
author: RostraId,
content_len: u32,
old_state: Option<&EventContentState>,
ids_data_usage_table: &mut ids_data_usage::Table,
) -> DbResult<()> {
let len = u64::from(content_len);
let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
match old_state {
Some(EventContentState::Missing { .. }) => {
usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
}
None => {
usage.current_content_size = usage.current_content_size.saturating_sub(len);
usage.current_payload_num = usage.current_payload_num.saturating_sub(1);
}
_ => {}
}
usage.pruned_payload_size += len;
usage.pruned_payload_num += 1;
ids_data_usage_table.insert(&author, &usage)?;
Ok(())
}
pub(crate) fn get_data_usage_tx(
author: RostraId,
ids_data_usage_table: &impl ids_data_usage::ReadableTable,
) -> DbResult<IdsDataUsageRecord> {
Ok(ids_data_usage_table
.get(&author)?
.map(|g| g.value())
.unwrap_or_default())
}
}