Struct places::history_sync::store::HistoryStore

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

Fields

db: &'a PlacesDb

interruptee: &'a SqlInterruptScope

Implementations

impl<'a> HistoryStore<'a>

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

fn put_meta(&self, key: &str, value: &dyn ToSql) -> Result<()>

fn get_meta<T: FromSql>(&self, key: &str) -> Result<Option<T>>

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

fn do_sync_finished(
    &self,
    new_timestamp: ServerTimestamp,
    records_synced: Vec<Guid>
) -> Result<()>

pub fn migrate_v1_global_state(db: &PlacesDb) -> Result<()>

A utility we can kill by the end of 2019 ;) Or even mid-2019? Note that this has no self - it just takes a connection. This is to ease the migration process, because this needs to be executed before bookmarks sync, otherwise the shared, persisted global state may be written by bookmarks before we've had a chance to migrate declined over.

Trait Implementations

impl<'a> Deref for HistoryStore<'a>

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.

impl<'a> Store for HistoryStore<'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<Guid>
) -> 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<()>

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.