Struct places::bookmark_sync::store::BookmarksStore

pub struct BookmarksStore<'a> {
    pub db: &'a PlacesDb,
    interruptee: &'a SqlInterruptScope,
}

Fields

db: &'a PlacesDb

interruptee: &'a SqlInterruptScope

Implementations

impl<'a> BookmarksStore<'a>

pub fn new(db: &'a PlacesDb, interruptee: &'a SqlInterruptScope) -> Self

fn stage_incoming(
    &self,
    inbound: IncomingChangeset,
    incoming_telemetry: &mut EngineIncoming
) -> Result<ServerTimestamp>

fn has_changes(&self) -> Result<bool>

fn update_local_items_in_places<'t>(
    &self,
    now: Timestamp,
    ops: &CompletionOps<'t>
) -> Result<()>

Builds a temporary table with the merge states of all nodes in the merged tree, then updates the local tree to match the merged tree.

Conceptually, we examine the merge state of each item, and either leave the item unchanged, upload the local side, apply the remote side, or apply and then reupload the remote side with a new structure.

fn apply_remote_items(&self, now: Timestamp) -> Result<()>

fn stage_items_to_upload(
    &self,
    upload_items: &[UploadItem<'_>],
    upload_tombstones: &[UploadTombstone<'_>]
) -> Result<()>

Stores a snapshot of all locally changed items in a temporary table for upload. This is called from within the merge transaction, to ensure that changes made during the sync don't cause us to upload inconsistent records.

Conceptually, itemsToUpload is a transient "view" of locally changed items. The local change counter is the persistent record of items that we need to upload, so, if upload is interrupted or fails, we'll stage the items again on the next sync.

fn fetch_outgoing_records(
    &self,
    timestamp: ServerTimestamp
) -> Result<OutgoingChangeset>

Inflates Sync records for all staged outgoing items.

fn push_synced_items(
    &self,
    uploaded_at: ServerTimestamp,
    records_synced: Vec<SyncGuid>
) -> Result<()>

Decrements the change counter, updates the sync status, and cleans up tombstones for successfully synced items. Sync calls this method at the end of each bookmark sync.

pub(crate) fn update_frecencies(&self) -> Result<()>

Trait Implementations

impl<'a> Store for BookmarksStore<'a>

fn collection_name(&self) -> Cow<'static, str>

fn apply_incoming(
    &self,
    inbound: Vec<IncomingChangeset>,
    telem: &mut Engine
) -> Result<OutgoingChangeset>

inbound is a vector to support the case where get_collection_requests returned multiple requests. The changesets are in the same order as the requests were -- e.g. if vec![req_a, req_b] was returned from get_collection_requests, inbound will have the results from req_a as its first index, and those from req_b as it's second.

fn sync_finished(
    &self,
    new_timestamp: ServerTimestamp,
    records_synced: Vec<SyncGuid>
) -> Result<()>

fn get_collection_requests(
    &self,
    server_timestamp: ServerTimestamp
) -> Result<Vec<CollectionRequest>>

The store is responsible for building the collection request. Engines typically will store a lastModified timestamp and use that to build a request saying "give me full records since that date" - however, other engines might do something fancier. This could even later be extended to handle "backfills" etc

fn get_sync_assoc(&self) -> Result<StoreSyncAssociation>

Get persisted sync IDs. If they don't match the global state we'll be reset() with the new IDs.

fn reset(&self, assoc: &StoreSyncAssociation) -> Result<()>

Reset the store without wiping local data, ready for a "first sync". assoc defines how this store is to be associated with sync.

fn wipe(&self) -> Result<()>

Erases all local items. Unlike reset, this keeps all synced items until the next sync, when they will be replaced with tombstones. This also preserves the sync ID and last sync time.

Conceptually, the next sync will merge an empty local tree, and a full remote tree.

fn prepare_for_sync(&self, _get_client_data: &dyn Fn()) -> Result<(), Error>

Prepares the store for syncing. The tabs store currently uses this to store the current list of clients, which it uses to look up device names and types.