rostra-client-db 0.1.0

Embedded database and projections for a Rostra client
Documentation
use rostra_core::event::content_kind::{self, EventContentKind as _};
use rostra_core::event::{
    Event, EventContentRaw, EventExt as _, EventKind, VerifiedEvent, VerifiedEventContent,
};
use rostra_core::id::{RostraId, RostraIdSecretKey, ToShort as _};
use rostra_core::{ContentHash, EventId, ShortEventId, Timestamp};
use rostra_util_error::BoxedErrorResult;
use snafu::ResultExt as _;
use tempfile::tempdir;

use crate::event::EventContentState;
use crate::{
    Database, IdsDataUsageRecord, content_rc, content_store, db_version, events,
    events_content_missing, events_content_state, events_received_at, ids_data_usage,
    social_posts_by_received_at, social_posts_by_time,
};

#[derive(Debug, PartialEq, Eq)]
struct IngestionSnapshot {
    event_present: bool,
    content: Option<Vec<u8>>,
    content_state: Option<EventContentState>,
    queue: Vec<(Timestamp, ShortEventId)>,
    content_rc: Option<u64>,
    usage: UsageSnapshot,
    event_receipts: Vec<ShortEventId>,
    posts_by_time: Vec<(Timestamp, ShortEventId)>,
    post_receipts: Vec<ShortEventId>,
}

#[derive(Debug, PartialEq, Eq)]
struct UsageSnapshot {
    current_metadata_size: u64,
    total_metadata_size: u64,
    current_metadata_num: u64,
    total_metadata_num: u64,
    current_content_size: u64,
    total_content_size: u64,
    current_payload_num: u64,
    total_payload_num: u64,
    missing_payload_size: u64,
    missing_payload_num: u64,
    deleted_payload_size: u64,
    deleted_payload_num: u64,
    pruned_payload_size: u64,
    pruned_payload_num: u64,
    invalid_payload_size: u64,
    invalid_payload_num: u64,
}

impl From<IdsDataUsageRecord> for UsageSnapshot {
    fn from(usage: IdsDataUsageRecord) -> Self {
        Self {
            current_metadata_size: usage.current_metadata_size,
            total_metadata_size: usage.total_metadata_size,
            current_metadata_num: usage.current_metadata_num,
            total_metadata_num: usage.total_metadata_num,
            current_content_size: usage.current_content_size,
            total_content_size: usage.total_content_size,
            current_payload_num: usage.current_payload_num,
            total_payload_num: usage.total_payload_num,
            missing_payload_size: usage.missing_payload_size,
            missing_payload_num: usage.missing_payload_num,
            deleted_payload_size: usage.deleted_payload_size,
            deleted_payload_num: usage.deleted_payload_num,
            pruned_payload_size: usage.pruned_payload_size,
            pruned_payload_num: usage.pruned_payload_num,
            invalid_payload_size: usage.invalid_payload_size,
            invalid_payload_num: usage.invalid_payload_num,
        }
    }
}

async fn snapshot(
    db: &Database,
    author: RostraId,
    event_id: ShortEventId,
    content_hash: ContentHash,
) -> BoxedErrorResult<IngestionSnapshot> {
    let content = db
        .get_event_content(event_id)
        .await
        .map(|content| content.as_ref().to_vec());
    Ok(db
        .read_with(|tx| {
            let event_present = tx.open_table(&events::TABLE)?.get(&event_id)?.is_some();
            let content_state = tx
                .open_table(&events_content_state::TABLE)?
                .get(&event_id)?
                .map(|entry| entry.value());
            let queue = tx
                .open_table(&events_content_missing::TABLE)?
                .range(..)?
                .map(|entry| entry.map(|(key, _)| key.value()))
                .collect::<Result<Vec<_>, _>>()?;
            let content_rc = tx
                .open_table(&content_rc::TABLE)?
                .get(&content_hash)?
                .map(|entry| entry.value());
            let usage =
                Database::get_data_usage_tx(author, &tx.open_table(&ids_data_usage::TABLE)?)?;
            let event_receipts = tx
                .open_table(&events_received_at::TABLE)?
                .range(..)?
                .map(|entry| entry.map(|(_, value)| value.value().event_id))
                .collect::<Result<Vec<_>, _>>()?;
            let posts_by_time = tx
                .open_table(&social_posts_by_time::TABLE)?
                .range(..)?
                .map(|entry| entry.map(|(key, _)| key.value()))
                .collect::<Result<Vec<_>, _>>()?;
            let post_receipts = tx
                .open_table(&social_posts_by_received_at::TABLE)?
                .range(..)?
                .map(|entry| entry.map(|(_, value)| value.value()))
                .collect::<Result<Vec<_>, _>>()?;

            Ok(IngestionSnapshot {
                event_present,
                content,
                content_state,
                queue,
                content_rc,
                usage: usage.into(),
                event_receipts,
                posts_by_time,
                post_receipts,
            })
        })
        .await?)
}

fn post(secret: RostraIdSecretKey, text: &str) -> VerifiedEventContent {
    let content = content_kind::SocialPost::new(text.to_owned(), None, Default::default())
        .serialize_cbor()
        .expect("social post must serialize");
    verified_content(
        secret,
        EventKind::SOCIAL_POST,
        content,
        Some(time::OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(42)),
    )
}

fn verified_content(
    secret: RostraIdSecretKey,
    kind: EventKind,
    content: EventContentRaw,
    timestamp: Option<time::OffsetDateTime>,
) -> VerifiedEventContent {
    let event = match timestamp {
        Some(timestamp) => Event::builder_raw_content()
            .author(secret.id())
            .kind(kind)
            .content(&content)
            .timestamp(timestamp)
            .build(),
        None => Event::builder_raw_content()
            .author(secret.id())
            .kind(kind)
            .content(&content)
            .build(),
    };
    let signed = event.signed_by(secret);
    let event =
        VerifiedEvent::verify_signed(secret.id(), signed).expect("event signature must verify");
    VerifiedEventContent::assume_verified(event, content)
}

fn deletion(secret: RostraIdSecretKey, parent: EventId, target: EventId) -> VerifiedEvent {
    let empty = EventContentRaw::new(vec![]);
    let signed = Event::builder_raw_content()
        .author(secret.id())
        .kind(EventKind::SOCIAL_POST)
        .parent_prev(parent.into())
        .delete(target.into())
        .content(&empty)
        .build()
        .signed_by(secret);
    VerifiedEvent::verify_signed(secret.id(), signed).expect("deletion signature must verify")
}

fn force_total_replay(path: &std::path::Path) -> BoxedErrorResult<()> {
    let db = redb_bincode::Database::from(redb::Database::open(path).boxed()?);
    let tx = db.begin_write().boxed()?;
    tx.open_table(&db_version::TABLE)?.insert(&(), &24)?;
    tx.commit().boxed()?;
    Ok(())
}

#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn public_content_ingestion_matches_combined_for_both_arrival_orders() -> BoxedErrorResult<()>
{
    let secret = RostraIdSecretKey::from_bytes([91; 32]);
    let author = secret.id();
    let content = post(secret, "content boundary");
    let event_id = content.event_id().to_short();
    let content_hash = content.content_hash();
    let mut snapshots = Vec::new();

    for scenario in ["combined", "content-first", "envelope-first"] {
        let dir = tempdir()?;
        let path = dir.path().join("db.redb");
        let db = Database::open(&path, author).await.boxed()?;

        match scenario {
            "combined" => {
                db.process_event_with_content(&content).await;
            }
            "content-first" => {
                db.process_event_content(&content).await;
                let before_late_envelope = snapshot(&db, author, event_id, content_hash).await?;
                assert!(before_late_envelope.event_present);
                assert_eq!(before_late_envelope.content_state, None);
                assert_eq!(before_late_envelope.content_rc, Some(1));
                assert!(before_late_envelope.queue.is_empty());
                assert_eq!(before_late_envelope.posts_by_time.len(), 1);
                db.process_event(&content.event).await;
                assert_eq!(
                    snapshot(&db, author, event_id, content_hash).await?,
                    before_late_envelope,
                    "late duplicate envelope changed content-first ingestion"
                );
            }
            "envelope-first" => {
                db.process_event(&content.event).await;
                let before_content = snapshot(&db, author, event_id, content_hash).await?;
                assert!(matches!(
                    before_content.content_state,
                    Some(EventContentState::Missing { .. })
                ));
                assert_eq!(before_content.content_rc, Some(1));
                assert_eq!(before_content.queue, vec![(Timestamp::ZERO, event_id)]);
                assert!(before_content.posts_by_time.is_empty());
                db.process_event_content(&content).await;
            }
            _ => unreachable!(),
        }

        let first = snapshot(&db, author, event_id, content_hash).await?;
        db.process_event_content(&content).await;
        db.process_event(&content.event).await;
        db.process_event_with_content(&content).await;
        assert_eq!(
            snapshot(&db, author, event_id, content_hash).await?,
            first,
            "{scenario}: duplicate public calls changed lifecycle or projections"
        );

        drop(db);
        let reopened = Database::open(&path, author).await.boxed()?;
        assert_eq!(
            snapshot(&reopened, author, event_id, content_hash).await?,
            first,
            "{scenario}: reopen changed the terminal observation"
        );
        drop(reopened);

        force_total_replay(&path)?;
        let replayed = Database::open(&path, author).await.boxed()?;
        let after_replay = snapshot(&replayed, author, event_id, content_hash).await?;
        assert_eq!(after_replay, first, "{scenario}: total replay diverged");
        snapshots.push(after_replay);
    }

    assert!(snapshots.windows(2).all(|pair| pair[0] == pair[1]));
    let expected = &snapshots[0];
    assert!(expected.event_present);
    assert_eq!(
        expected.content.as_deref(),
        content.content.as_ref().map(AsRef::as_ref)
    );
    assert_eq!(expected.content_state, None);
    assert!(expected.queue.is_empty());
    assert_eq!(expected.content_rc, Some(1));
    assert_eq!(expected.event_receipts, vec![event_id]);
    assert_eq!(
        expected.posts_by_time,
        vec![(content.timestamp(), event_id)]
    );
    assert_eq!(expected.post_receipts, vec![event_id]);

    Ok(())
}

#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn public_content_ingestion_preserves_terminal_states() -> BoxedErrorResult<()> {
    let secret = RostraIdSecretKey::from_bytes([92; 32]);
    let author = secret.id();

    let deleted = post(secret, "deleted before content");
    let deleted_id = deleted.event_id().to_short();
    let deleted_hash = deleted.content_hash();
    let delete = deletion(secret, deleted.event_id(), deleted.event_id());
    let (_deleted_dir, deleted_db) = crate::tests::temp_db(author).await?;
    deleted_db.process_event(&delete).await;
    deleted_db.process_event_content(&deleted).await;
    let deleted_before = snapshot(&deleted_db, author, deleted_id, deleted_hash).await?;
    deleted_db.process_event_content(&deleted).await;
    assert_eq!(
        snapshot(&deleted_db, author, deleted_id, deleted_hash).await?,
        deleted_before
    );
    assert!(matches!(
        deleted_before.content_state,
        Some(EventContentState::Deleted { .. })
    ));
    assert_eq!(deleted_before.content, None);
    assert!(deleted_before.queue.is_empty());
    assert!(deleted_before.posts_by_time.is_empty());
    assert!(deleted_before.post_receipts.is_empty());

    let pruned = verified_content(
        secret,
        EventKind::RAW,
        EventContentRaw::new(vec![0x5a; Database::MAX_CONTENT_LEN as usize + 1]),
        None,
    );
    let pruned_id = pruned.event_id().to_short();
    let pruned_hash = pruned.content_hash();
    let (_pruned_dir, pruned_db) = crate::tests::temp_db(author).await?;
    pruned_db.process_event_content(&pruned).await;
    let pruned_before = snapshot(&pruned_db, author, pruned_id, pruned_hash).await?;
    pruned_db.process_event_content(&pruned).await;
    assert_eq!(
        snapshot(&pruned_db, author, pruned_id, pruned_hash).await?,
        pruned_before
    );
    assert_eq!(pruned_before.content_state, Some(EventContentState::Pruned));
    assert_eq!(pruned_before.content, None);
    assert!(pruned_before.queue.is_empty());

    let invalid = verified_content(
        secret,
        EventKind::SOCIAL_POST,
        EventContentRaw::new(vec![0xff]),
        None,
    );
    let invalid_id = invalid.event_id().to_short();
    let invalid_hash = invalid.content_hash();
    let (_invalid_dir, invalid_db) = crate::tests::temp_db(author).await?;
    invalid_db.process_event_content(&invalid).await;
    let invalid_before = snapshot(&invalid_db, author, invalid_id, invalid_hash).await?;
    invalid_db.process_event_content(&invalid).await;
    assert_eq!(
        snapshot(&invalid_db, author, invalid_id, invalid_hash).await?,
        invalid_before
    );
    assert_eq!(
        invalid_before.content_state,
        Some(EventContentState::Invalid)
    );
    assert_eq!(invalid_before.content, None);
    assert!(invalid_before.queue.is_empty());
    assert!(invalid_before.posts_by_time.is_empty());
    assert!(invalid_before.post_receipts.is_empty());
    assert_eq!(
        invalid_db
            .read_with(|tx| Ok(tx.open_table(&content_store::TABLE)?.range(..)?.count()))
            .await?,
        0
    );

    Ok(())
}