diff options
Diffstat (limited to '')
| -rw-r--r-- | third_party/rust/tabs/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | third_party/rust/tabs/Cargo.toml | 45 | ||||
| -rw-r--r-- | third_party/rust/tabs/README.md | 62 | ||||
| -rw-r--r-- | third_party/rust/tabs/build.rs | 7 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/error.rs | 90 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/lib.rs | 39 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/schema.rs | 70 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/storage.rs | 385 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/store.rs | 41 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/sync/bridge.rs | 457 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/sync/engine.rs | 515 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/sync/full_sync.rs | 72 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/sync/mod.rs | 35 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/sync/record.rs | 96 | ||||
| -rw-r--r-- | third_party/rust/tabs/src/tabs.udl | 108 | ||||
| -rw-r--r-- | third_party/rust/tabs/uniffi.toml | 8 |
16 files changed, 2031 insertions, 0 deletions
diff --git a/third_party/rust/tabs/.cargo-checksum.json b/third_party/rust/tabs/.cargo-checksum.json new file mode 100644 index 0000000000..f01b3f2d43 --- /dev/null +++ b/third_party/rust/tabs/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"c8183d47c99830e628827da4c1510a4dd939071f85fc7ca85c9419ae2521ba41","README.md":"c48b8f391ef822c4f3971b5f453a1e7b43bea232752d520460d2f04803aead1a","build.rs":"024918c1d468c8dae03e4edaad14d827b7ebe7995809a8fe99efb1d9faa1206a","src/error.rs":"ac3d450f0ba6a855c37fa2dd829004b22dce5ad4416ebec66a3d7d6212bdbcd7","src/lib.rs":"d7eff9e1c28f88a48bfffa5acc0e8da12336c0c6ad55f5df211da4720927cce7","src/schema.rs":"19941d1291500c20eff467caa57fa845d4902b349d80508edc5d453725d1d870","src/storage.rs":"ea815cd3b3c729ab54343571138a739ad408f506920902f3d67495f1a8896ef5","src/store.rs":"ab0b6214b30b0f0fa7c6a89098ff3db1a8f76264f6711c4481c0be460afe522b","src/sync/bridge.rs":"6e843315842ad31a08c2760f7b993c93295deada755ae9fab1123b04659ad1d8","src/sync/engine.rs":"928a827081c47c091b3d70046fe85188f02a148316d3058347814e3166afa959","src/sync/full_sync.rs":"412d24231f7a0c9a796c2afe482bc520d435f980bcba2841628c1147f6cbf479","src/sync/mod.rs":"8f0544ea54ad3f6daaf2650242d009229e09643ac9396e55ba111f2635cad232","src/sync/record.rs":"353b8e62f4f1a85edd8d693102d288ba59978e702e2c18a9c7415d731342b4d9","src/tabs.udl":"a555fe11b5fa7ea9aefa7d7be31906a63b31cbc16b9b7f5ad952fd0e08ba5c61","uniffi.toml":"5156701368f0b5856e658143714a43058385c8ac53bee72d7a5a332b576dfb82"},"package":null}
\ No newline at end of file diff --git a/third_party/rust/tabs/Cargo.toml b/third_party/rust/tabs/Cargo.toml new file mode 100644 index 0000000000..ff541caffe --- /dev/null +++ b/third_party/rust/tabs/Cargo.toml @@ -0,0 +1,45 @@ +[package] +name = "tabs" +edition = "2021" +version = "0.1.0" +authors = ["application-services@mozilla.com"] +license = "MPL-2.0" +exclude = ["/android", "/ios"] + +[features] +# When used in desktop we *do not* want the full-sync implementation so desktop +# doesn't get our crypto etc. +# When used on mobile, for simplicity we *do* still expose the unused "bridged engine" +# because none of the engine implementations need the crypto. +default = [] + +# TODO: we've enabled the "standalone-sync" feature - see the description +# of this feature in sync15's Cargo.toml for what we should do instead. +# (The short version here is that once tabs doesn't need to expose a `sync()` +# method for iOS, we can kill the `full-sync` feature entirely) +full-sync = ["sync15/standalone-sync"] + +[dependencies] +anyhow = "1.0" +error-support = { path = "../support/error" } +interrupt-support = { path = "../support/interrupt" } +lazy_static = "1.4" +log = "0.4" +rusqlite = { version = "0.28.0", features = ["bundled", "unlock_notify"] } +serde = "1" +serde_derive = "1" +serde_json = "1" +sql-support = { path = "../support/sql" } +sync-guid = { path = "../support/guid", features = ["random"] } +sync15 = { path = "../sync15", features = ["sync-engine"] } +thiserror = "1.0" +uniffi = "^0.21" +uniffi_macros = "^0.21" +url = "2.1" # mozilla-central can't yet take 2.2 (see bug 1734538) + +[dev-dependencies] +env_logger = { version = "0.8.0", default-features = false, features = ["termcolor", "atty", "humantime"] } +tempfile = "3.1" + +[build-dependencies] +uniffi_build = { version = "^0.21", features = [ "builtin-bindgen" ]} diff --git a/third_party/rust/tabs/README.md b/third_party/rust/tabs/README.md new file mode 100644 index 0000000000..fc57a02908 --- /dev/null +++ b/third_party/rust/tabs/README.md @@ -0,0 +1,62 @@ +# Synced Tabs Component + + + +## Implementation Overview + +This crate implements an in-memory syncing engine for remote tabs. + +## Directory structure +The relevant directories are as follows: + +- `src`: The meat of the library. This contains cross-platform rust code that + implements the syncing of tabs. +- `ffi`: The Rust public FFI bindings. This is a (memory-unsafe, by necessity) + API that is exposed to Kotlin and Swift. It leverages the `ffi_support` crate + to avoid many issues and make it more safe than it otherwise would be. + It uses protocol buffers for marshalling data over the FFI. +- `android`: This contains android bindings to synced tabs, written in Kotlin. These + use JNA to call into to the code in `ffi`. +- `ios`: This contains the iOS binding to synced tabs, written in Swift. These use + Swift's native support for calling code written in C to call into the code in + `ffi`. + +## Features +- Synchronization of the local and remote session states. + +## Business Logic + +### Storage + +The storage is all done in memory for simplicity purposes. The host applications are free to persist the remote tabs list if it makes sense to them. + +### Payload format + +Every remote sync record is roughly a list of tabs with their URL history (think of the back button). There is one record for each client. + +### Association with device IDs + +Each remote tabs sync record is associated to a "client" using a `client_id` field, which is really a foreign-key to a `clients` collection record. +However, because we'd like to move away from the clients collection, which is why this crate associates these records with Firefox Accounts device ids. +Currently for platforms using the sync-manager provided in this repo, the `client_id` is really the Firefox Accounts device ID and all is well, however for older platforms it is a distinct ID, which is why we have to feed the `clients` collection to this Tabs Sync engine to associate the correct Firefox Account device id. + +## Getting started + +**Prerequisites**: Firefox account authentication is necessary to obtain the keys to decrypt synced tabs data. See the [android-components FxA Client readme](https://github.com/mozilla-mobile/android-components/blob/master/components/service/firefox-accounts/README.md) for details on how to implement on Android. For iOS, Firefox for iOS still implement the legacy oauth. + +**Platform-specific details**: +- <TODO-ST> Android +- iOS: start with the [guide to consuming rust components on iOS](https://github.com/mozilla/application-services/blob/main/docs/howtos/consuming-rust-components-on-ios.md) + +## API Documentation +- TODO + +## Testing + +<TODO-ST> + +## Telemetry +<TODO-ST> + +## Examples +<TODO-ST> diff --git a/third_party/rust/tabs/build.rs b/third_party/rust/tabs/build.rs new file mode 100644 index 0000000000..0fc7f50a01 --- /dev/null +++ b/third_party/rust/tabs/build.rs @@ -0,0 +1,7 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +fn main() { + uniffi_build::generate_scaffolding("./src/tabs.udl").unwrap(); +} diff --git a/third_party/rust/tabs/src/error.rs b/third_party/rust/tabs/src/error.rs new file mode 100644 index 0000000000..748c21f656 --- /dev/null +++ b/third_party/rust/tabs/src/error.rs @@ -0,0 +1,90 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use error_support::{ErrorHandling, GetErrorHandling}; + +/// Result enum for the public interface +pub type ApiResult<T> = std::result::Result<T, TabsApiError>; +/// Result enum for internal functions +pub type Result<T> = std::result::Result<T, Error>; + +// Errors we return via the public interface. +#[derive(Debug, thiserror::Error)] +pub enum TabsApiError { + #[error("SyncError: {reason}")] + SyncError { reason: String }, + + #[error("SqlError: {reason}")] + SqlError { reason: String }, + + #[error("Unexpected tabs error: {reason}")] + UnexpectedTabsError { reason: String }, +} + +// Error we use internally +#[derive(Debug, thiserror::Error)] +pub enum Error { + #[cfg(feature = "full-sync")] + #[error("Error synchronizing: {0}")] + SyncAdapterError(#[from] sync15::Error), + + // Note we are abusing this as a kind of "mis-matched feature" error. + // This works because when `full-sync` isn't enabled we don't actually + // handle any sync15 errors as the bridged-engine never returns them. + #[cfg(not(feature = "full-sync"))] + #[error("Sync feature is disabled: {0}")] + SyncAdapterError(String), + + #[error("Error parsing JSON data: {0}")] + JsonError(#[from] serde_json::Error), + + #[error("Missing SyncUnlockInfo Local ID")] + MissingLocalIdError, + + #[error("Error parsing URL: {0}")] + UrlParseError(#[from] url::ParseError), + + #[error("Error executing SQL: {0}")] + SqlError(#[from] rusqlite::Error), + + #[error("Error opening database: {0}")] + OpenDatabaseError(#[from] sql_support::open_database::Error), +} + +// Define how our internal errors are handled and converted to external errors +// See `support/error/README.md` for how this works, especially the warning about PII. +impl GetErrorHandling for Error { + type ExternalError = TabsApiError; + + fn get_error_handling(&self) -> ErrorHandling<Self::ExternalError> { + match self { + Self::SyncAdapterError(e) => ErrorHandling::convert(TabsApiError::SyncError { + reason: e.to_string(), + }) + .report_error("tabs-sync-error"), + Self::JsonError(e) => ErrorHandling::convert(TabsApiError::UnexpectedTabsError { + reason: e.to_string(), + }) + .report_error("tabs-json-error"), + Self::MissingLocalIdError => { + ErrorHandling::convert(TabsApiError::UnexpectedTabsError { + reason: "MissingLocalId".to_string(), + }) + .report_error("tabs-missing-local-id-error") + } + Self::UrlParseError(e) => ErrorHandling::convert(TabsApiError::UnexpectedTabsError { + reason: e.to_string(), + }) + .report_error("tabs-url-parse-error"), + Self::SqlError(e) => ErrorHandling::convert(TabsApiError::SqlError { + reason: e.to_string(), + }) + .report_error("tabs-sql-error"), + Self::OpenDatabaseError(e) => ErrorHandling::convert(TabsApiError::SqlError { + reason: e.to_string(), + }) + .report_error("tabs-open-database-error"), + } + } +} diff --git a/third_party/rust/tabs/src/lib.rs b/third_party/rust/tabs/src/lib.rs new file mode 100644 index 0000000000..fbaddc471f --- /dev/null +++ b/third_party/rust/tabs/src/lib.rs @@ -0,0 +1,39 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#![allow(unknown_lints)] +#![warn(rust_2018_idioms)] + +#[macro_use] +pub mod error; +mod schema; +mod storage; +mod store; +mod sync; + +uniffi_macros::include_scaffolding!("tabs"); + +// Our UDL uses a `Guid` type. +use sync_guid::Guid as TabsGuid; +impl UniffiCustomTypeConverter for TabsGuid { + type Builtin = String; + + fn into_custom(val: Self::Builtin) -> uniffi::Result<TabsGuid> { + Ok(TabsGuid::new(val.as_str())) + } + + fn from_custom(obj: Self) -> Self::Builtin { + obj.into() + } +} + +pub use crate::storage::{ClientRemoteTabs, RemoteTabRecord, TabsDeviceType}; +pub use crate::store::TabsStore; +pub use error::{ApiResult, Error, Result, TabsApiError}; +use sync15::DeviceType; + +pub use crate::sync::engine::get_registered_sync_engine; + +pub use crate::sync::bridge::TabsBridgedEngine; +pub use crate::sync::engine::TabsEngine; diff --git a/third_party/rust/tabs/src/schema.rs b/third_party/rust/tabs/src/schema.rs new file mode 100644 index 0000000000..e5ff0c7f6e --- /dev/null +++ b/third_party/rust/tabs/src/schema.rs @@ -0,0 +1,70 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// Tabs is a bit special - it's a trivial SQL schema and is only used as a persistent +// cache, and the semantics of the "tabs" collection means there's no need for +// syncChangeCounter/syncStatus nor a mirror etc. + +use rusqlite::{Connection, Transaction}; +use sql_support::open_database::{ + ConnectionInitializer as MigrationLogic, Error as MigrationError, Result as MigrationResult, +}; + +// The payload is json and this module doesn't need to deserialize, so we just +// store each "payload" as a row. +// On each Sync we delete all local rows re-populate them with every record on +// the server. When we read the DB, we also read every single record. +// So we have no primary keys, no foreign keys, and really completely waste the +// fact we are using sql. +const CREATE_SCHEMA_SQL: &str = " + CREATE TABLE IF NOT EXISTS tabs ( + payload TEXT NOT NULL + ); +"; + +pub struct TabsMigrationLogin; + +impl MigrationLogic for TabsMigrationLogin { + const NAME: &'static str = "tabs storage db"; + const END_VERSION: u32 = 1; + + fn prepare(&self, conn: &Connection, _db_empty: bool) -> MigrationResult<()> { + let initial_pragmas = " + -- We don't care about temp tables being persisted to disk. + PRAGMA temp_store = 2; + -- we unconditionally want write-ahead-logging mode. + PRAGMA journal_mode=WAL; + -- foreign keys seem worth enforcing (and again, we don't care in practice) + PRAGMA foreign_keys = ON; + "; + conn.execute_batch(initial_pragmas)?; + // This is where we'd define our sql functions if we had any! + conn.set_prepared_statement_cache_capacity(128); + Ok(()) + } + + fn init(&self, db: &Transaction<'_>) -> MigrationResult<()> { + log::debug!("Creating schema"); + db.execute_batch(CREATE_SCHEMA_SQL)?; + Ok(()) + } + + fn upgrade_from(&self, _db: &Transaction<'_>, version: u32) -> MigrationResult<()> { + Err(MigrationError::IncompatibleVersion(version)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::storage::TabsStorage; + + #[test] + fn test_create_schema_twice() { + let mut db = TabsStorage::new_with_mem_path("test"); + let conn = db.open_or_create().unwrap(); + conn.execute_batch(CREATE_SCHEMA_SQL) + .expect("should allow running twice"); + } +} diff --git a/third_party/rust/tabs/src/storage.rs b/third_party/rust/tabs/src/storage.rs new file mode 100644 index 0000000000..0522ed37f4 --- /dev/null +++ b/third_party/rust/tabs/src/storage.rs @@ -0,0 +1,385 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// From https://searchfox.org/mozilla-central/rev/ea63a0888d406fae720cf24f4727d87569a8cab5/services/sync/modules/constants.js#75 +const URI_LENGTH_MAX: usize = 65536; +// https://searchfox.org/mozilla-central/rev/ea63a0888d406fae720cf24f4727d87569a8cab5/services/sync/modules/engines/tabs.js#8 +const TAB_ENTRIES_LIMIT: usize = 5; + +use crate::error::*; +use crate::DeviceType; +use rusqlite::{Connection, OpenFlags}; +use serde_derive::{Deserialize, Serialize}; +use sql_support::open_database::{self, open_database_with_flags}; +use sql_support::ConnExt; +use std::cell::RefCell; +use std::path::{Path, PathBuf}; + +pub type TabsDeviceType = crate::DeviceType; +pub type RemoteTabRecord = RemoteTab; + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct RemoteTab { + pub title: String, + pub url_history: Vec<String>, + pub icon: Option<String>, + pub last_used: i64, // In ms. +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct ClientRemoteTabs { + pub client_id: String, // Corresponds to the `clients` collection ID of the client. + pub client_name: String, + #[serde( + default = "devicetype_default_deser", + skip_serializing_if = "devicetype_is_unknown" + )] + pub device_type: DeviceType, + // serde default so we can read old rows that didn't persist this. + #[serde(default)] + pub last_modified: i64, + pub remote_tabs: Vec<RemoteTab>, +} + +fn devicetype_default_deser() -> DeviceType { + // replace with `DeviceType::default_deser` once #4861 lands. + DeviceType::Unknown +} + +// Unlike most other uses-cases, here we do allow serializing ::Unknown, but skip it. +fn devicetype_is_unknown(val: &DeviceType) -> bool { + matches!(val, DeviceType::Unknown) +} + +// Tabs has unique requirements for storage: +// * The "local_tabs" exist only so we can sync them out. There's no facility to +// query "local tabs", so there's no need to store these persistently - ie, they +// are write-only. +// * The "remote_tabs" exist purely for incoming items via sync - there's no facility +// to set them locally - they are read-only. +// Note that this means a database is only actually needed after Sync fetches remote tabs, +// and because sync users are in the minority, the use of a database here is purely +// optional and created on demand. The implication here is that asking for the "remote tabs" +// when no database exists is considered a normal situation and just implies no remote tabs exist. +// (Note however we don't attempt to remove the database when no remote tabs exist, so having +// no remote tabs in an existing DB is also a normal situation) +pub struct TabsStorage { + local_tabs: RefCell<Option<Vec<RemoteTab>>>, + db_path: PathBuf, + db_connection: Option<Connection>, +} + +impl TabsStorage { + pub fn new(db_path: impl AsRef<Path>) -> Self { + Self { + local_tabs: RefCell::default(), + db_path: db_path.as_ref().to_path_buf(), + db_connection: None, + } + } + + /// Arrange for a new memory-based TabsStorage. As per other DB semantics, creating + /// this isn't enough to actually create the db! + pub fn new_with_mem_path(db_path: &str) -> Self { + let name = PathBuf::from(format!("file:{}?mode=memory&cache=shared", db_path)); + Self::new(name) + } + + /// If a DB file exists, open and return it. + pub fn open_if_exists(&mut self) -> Result<Option<&Connection>> { + if let Some(ref existing) = self.db_connection { + return Ok(Some(existing)); + } + let flags = OpenFlags::SQLITE_OPEN_NO_MUTEX + | OpenFlags::SQLITE_OPEN_URI + | OpenFlags::SQLITE_OPEN_READ_WRITE; + match open_database_with_flags( + self.db_path.clone(), + flags, + &crate::schema::TabsMigrationLogin, + ) { + Ok(conn) => { + self.db_connection = Some(conn); + Ok(self.db_connection.as_ref()) + } + Err(open_database::Error::SqlError(rusqlite::Error::SqliteFailure(code, _))) + if code.code == rusqlite::ErrorCode::CannotOpen => + { + Ok(None) + } + Err(e) => Err(e.into()), + } + } + + /// Open and return the DB, creating it if necessary. + pub fn open_or_create(&mut self) -> Result<&Connection> { + if let Some(ref existing) = self.db_connection { + return Ok(existing); + } + let flags = OpenFlags::SQLITE_OPEN_NO_MUTEX + | OpenFlags::SQLITE_OPEN_URI + | OpenFlags::SQLITE_OPEN_READ_WRITE + | OpenFlags::SQLITE_OPEN_CREATE; + let conn = open_database_with_flags( + self.db_path.clone(), + flags, + &crate::schema::TabsMigrationLogin, + )?; + self.db_connection = Some(conn); + Ok(self.db_connection.as_ref().unwrap()) + } + + pub fn update_local_state(&mut self, local_state: Vec<RemoteTab>) { + self.local_tabs.borrow_mut().replace(local_state); + } + + pub fn prepare_local_tabs_for_upload(&self) -> Option<Vec<RemoteTab>> { + if let Some(local_tabs) = self.local_tabs.borrow().as_ref() { + return Some( + local_tabs + .iter() + .cloned() + .filter_map(|mut tab| { + if tab.url_history.is_empty() || !is_url_syncable(&tab.url_history[0]) { + return None; + } + let mut sanitized_history = Vec::with_capacity(TAB_ENTRIES_LIMIT); + for url in tab.url_history { + if sanitized_history.len() == TAB_ENTRIES_LIMIT { + break; + } + if is_url_syncable(&url) { + sanitized_history.push(url); + } + } + tab.url_history = sanitized_history; + Some(tab) + }) + .collect(), + ); + } + None + } + + pub fn get_remote_tabs(&mut self) -> Option<Vec<ClientRemoteTabs>> { + match self.open_if_exists() { + Err(e) => { + error_support::report_error!( + "tabs-read-remote", + "Failed to read remote tabs: {}", + e + ); + None + } + Ok(None) => None, + Ok(Some(c)) => { + match c.query_rows_and_then_cached( + "SELECT payload FROM tabs", + [], + |row| -> Result<_> { Ok(serde_json::from_str(&row.get::<_, String>(0)?)?) }, + ) { + Ok(crts) => Some(crts), + Err(e) => { + error_support::report_error!( + "tabs-read-remote", + "Failed to read database: {}", + e + ); + None + } + } + } + } + } +} + +impl TabsStorage { + pub(crate) fn replace_remote_tabs( + &mut self, + new_remote_tabs: Vec<ClientRemoteTabs>, + ) -> Result<()> { + let connection = self.open_or_create()?; + let tx = connection.unchecked_transaction()?; + // delete the world - we rebuild it from scratch every sync. + tx.execute_batch("DELETE FROM tabs")?; + + for crt in new_remote_tabs { + tx.execute_cached( + "INSERT INTO tabs (payload) VALUES (:payload);", + rusqlite::named_params! { + ":payload": serde_json::to_string(&crt).expect("tabs don't fail to serialize"), + }, + )?; + } + tx.commit()?; + Ok(()) + } + + pub(crate) fn wipe_remote_tabs(&mut self) -> Result<()> { + if let Some(db) = self.open_if_exists()? { + db.execute_batch("DELETE FROM tabs")?; + } + Ok(()) + } + + pub(crate) fn wipe_local_tabs(&self) { + self.local_tabs.replace(None); + } +} + +fn is_url_syncable(url: &str) -> bool { + url.len() <= URI_LENGTH_MAX + && !(url.starts_with("about:") + || url.starts_with("resource:") + || url.starts_with("chrome:") + || url.starts_with("wyciwyg:") + || url.starts_with("blob:") + || url.starts_with("file:") + || url.starts_with("moz-extension:")) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_is_url_syncable() { + assert!(is_url_syncable("https://bobo.com")); + assert!(is_url_syncable("ftp://bobo.com")); + assert!(!is_url_syncable("about:blank")); + // XXX - this smells wrong - we should insist on a valid complete URL? + assert!(is_url_syncable("aboutbobo.com")); + assert!(!is_url_syncable("file:///Users/eoger/bobo")); + } + + #[test] + fn test_open_if_exists_no_file() { + let dir = tempfile::tempdir().unwrap(); + let db_name = dir.path().join("test_open_for_read_no_file.db"); + let mut storage = TabsStorage::new(db_name.clone()); + assert!(storage.open_if_exists().unwrap().is_none()); + storage.open_or_create().unwrap(); // will have created it. + // make a new storage, but leave the file alone. + let mut storage = TabsStorage::new(db_name); + // db file exists, so opening for read should open it. + assert!(storage.open_if_exists().unwrap().is_some()); + } + + #[test] + fn test_prepare_local_tabs_for_upload() { + let mut storage = TabsStorage::new_with_mem_path("test_prepare_local_tabs_for_upload"); + assert_eq!(storage.prepare_local_tabs_for_upload(), None); + storage.update_local_state(vec![ + RemoteTab { + title: "".to_owned(), + url_history: vec!["about:blank".to_owned(), "https://foo.bar".to_owned()], + icon: None, + last_used: 0, + }, + RemoteTab { + title: "".to_owned(), + url_history: vec![ + "https://foo.bar".to_owned(), + "about:blank".to_owned(), + "about:blank".to_owned(), + "about:blank".to_owned(), + "about:blank".to_owned(), + "about:blank".to_owned(), + "about:blank".to_owned(), + "about:blank".to_owned(), + ], + icon: None, + last_used: 0, + }, + RemoteTab { + title: "".to_owned(), + url_history: vec![ + "https://foo.bar".to_owned(), + "about:blank".to_owned(), + "https://foo2.bar".to_owned(), + "https://foo3.bar".to_owned(), + "https://foo4.bar".to_owned(), + "https://foo5.bar".to_owned(), + "https://foo6.bar".to_owned(), + ], + icon: None, + last_used: 0, + }, + RemoteTab { + title: "".to_owned(), + url_history: vec![], + icon: None, + last_used: 0, + }, + ]); + assert_eq!( + storage.prepare_local_tabs_for_upload(), + Some(vec![ + RemoteTab { + title: "".to_owned(), + url_history: vec!["https://foo.bar".to_owned()], + icon: None, + last_used: 0, + }, + RemoteTab { + title: "".to_owned(), + url_history: vec![ + "https://foo.bar".to_owned(), + "https://foo2.bar".to_owned(), + "https://foo3.bar".to_owned(), + "https://foo4.bar".to_owned(), + "https://foo5.bar".to_owned() + ], + icon: None, + last_used: 0, + }, + ]) + ); + } + + #[test] + fn test_old_client_remote_tabs_version() { + env_logger::try_init().ok(); + // The initial version of ClientRemoteTabs which we persisted looks like: + let old = serde_json::json!({ + "client_id": "id", + "client_name": "name", + "remote_tabs": [ + serde_json::json!({ + "title": "tab title", + "url_history": ["url"], + "last_used": 1234, + }), + ] + }); + + let dir = tempfile::tempdir().unwrap(); + let db_name = dir.path().join("test_old_client_remote_tabs_version.db"); + let mut storage = TabsStorage::new(db_name); + + let connection = storage.open_or_create().expect("should create"); + connection + .execute_cached( + "INSERT INTO tabs (payload) VALUES (:payload);", + rusqlite::named_params! { + ":payload": serde_json::to_string(&old).expect("tabs don't fail to serialize"), + }, + ) + .expect("should insert"); + + // We should be able to read it out. + let clients = storage.get_remote_tabs().expect("should work"); + assert_eq!(clients.len(), 1, "must be 1 tab"); + let client = &clients[0]; + assert_eq!(client.client_id, "id"); + assert_eq!(client.client_name, "name"); + assert_eq!(client.remote_tabs.len(), 1); + assert_eq!(client.remote_tabs[0].title, "tab title"); + assert_eq!(client.remote_tabs[0].url_history, vec!["url".to_string()]); + assert_eq!(client.remote_tabs[0].last_used, 1234); + + // The old version didn't have last_modified - check it is the default. + assert_eq!(client.last_modified, 0); + } +} diff --git a/third_party/rust/tabs/src/store.rs b/third_party/rust/tabs/src/store.rs new file mode 100644 index 0000000000..67bae498f7 --- /dev/null +++ b/third_party/rust/tabs/src/store.rs @@ -0,0 +1,41 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use crate::storage::{ClientRemoteTabs, RemoteTab, TabsStorage}; +use std::path::Path; +use std::sync::Mutex; + +pub struct TabsStore { + pub storage: Mutex<TabsStorage>, +} + +impl TabsStore { + pub fn new(db_path: impl AsRef<Path>) -> Self { + Self { + storage: Mutex::new(TabsStorage::new(db_path)), + } + } + + pub fn new_with_mem_path(db_path: &str) -> Self { + Self { + storage: Mutex::new(TabsStorage::new_with_mem_path(db_path)), + } + } + + pub fn set_local_tabs(&self, local_state: Vec<RemoteTab>) { + self.storage.lock().unwrap().update_local_state(local_state); + } + + // like remote_tabs, but serves the uniffi layer + pub fn get_all(&self) -> Vec<ClientRemoteTabs> { + match self.remote_tabs() { + Some(list) => list, + None => vec![], + } + } + + pub fn remote_tabs(&self) -> Option<Vec<ClientRemoteTabs>> { + self.storage.lock().unwrap().get_remote_tabs() + } +} diff --git a/third_party/rust/tabs/src/sync/bridge.rs b/third_party/rust/tabs/src/sync/bridge.rs new file mode 100644 index 0000000000..33f686026c --- /dev/null +++ b/third_party/rust/tabs/src/sync/bridge.rs @@ -0,0 +1,457 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use std::sync::{Arc, Mutex}; + +use crate::error::{ApiResult, Result, TabsApiError}; +use crate::sync::engine::TabsSyncImpl; +use crate::TabsStore; +use error_support::handle_error; +use sync15::bso::{IncomingBso, OutgoingBso}; +use sync15::engine::{ApplyResults, BridgedEngine, CollSyncIds, EngineSyncAssociation}; +use sync15::{ClientData, ServerTimestamp}; +use sync_guid::Guid as SyncGuid; + +impl TabsStore { + // Returns a bridged sync engine for Desktop for this store. + pub fn bridged_engine(self: Arc<Self>) -> Arc<TabsBridgedEngine> { + let bridge_impl = crate::sync::bridge::BridgedEngineImpl::new(&self); + // This is a concrete struct exposed via uniffi. + let concrete = TabsBridgedEngine::new(bridge_impl); + Arc::new(concrete) + } +} + +/// A bridged engine implements all the methods needed to make the +/// `storage.sync` store work with Desktop's Sync implementation. +/// Conceptually it's very similar to our SyncEngine, and once we have SyncEngine +/// and BridgedEngine using the same types we can probably combine them (or at least +/// implement this bridged engine purely in terms of SyncEngine) +/// See also #2841 and #5139 +pub struct BridgedEngineImpl { + sync_impl: Mutex<TabsSyncImpl>, + incoming: Mutex<Vec<IncomingBso>>, +} + +impl BridgedEngineImpl { + /// Creates a bridged engine for syncing. + pub fn new(store: &Arc<TabsStore>) -> Self { + Self { + sync_impl: Mutex::new(TabsSyncImpl::new(store.clone())), + incoming: Mutex::default(), + } + } +} + +impl BridgedEngine for BridgedEngineImpl { + type Error = TabsApiError; + + fn last_sync(&self) -> ApiResult<i64> { + handle_error! { + Ok(self + .sync_impl + .lock() + .unwrap() + .last_sync + .unwrap_or_default() + .as_millis()) + } + } + + fn set_last_sync(&self, last_sync_millis: i64) -> ApiResult<()> { + handle_error! { + self.sync_impl.lock().unwrap().last_sync = + Some(ServerTimestamp::from_millis(last_sync_millis)); + Ok(()) + } + } + + fn sync_id(&self) -> ApiResult<Option<String>> { + handle_error! { + Ok(match self.sync_impl.lock().unwrap().get_sync_assoc() { + EngineSyncAssociation::Connected(id) => Some(id.coll.to_string()), + EngineSyncAssociation::Disconnected => None, + }) + } + } + + fn reset_sync_id(&self) -> ApiResult<String> { + handle_error! { + let new_id = SyncGuid::random().to_string(); + let new_coll_ids = CollSyncIds { + global: SyncGuid::empty(), + coll: new_id.clone().into(), + }; + self.sync_impl + .lock() + .unwrap() + .reset(EngineSyncAssociation::Connected(new_coll_ids))?; + Ok(new_id) + } + } + + fn ensure_current_sync_id(&self, sync_id: &str) -> ApiResult<String> { + handle_error! { + let mut sync_impl = self.sync_impl.lock().unwrap(); + let assoc = sync_impl.get_sync_assoc(); + if matches!(assoc, EngineSyncAssociation::Connected(c) if c.coll == sync_id) { + log::debug!("ensure_current_sync_id is current"); + } else { + let new_coll_ids = CollSyncIds { + global: SyncGuid::empty(), + coll: sync_id.into(), + }; + sync_impl.reset(EngineSyncAssociation::Connected(new_coll_ids))?; + } + Ok(sync_id.to_string()) // this is a bit odd, why the result? + } + } + + fn prepare_for_sync(&self, client_data: &str) -> ApiResult<()> { + handle_error! { + let data: ClientData = serde_json::from_str(client_data)?; + self.sync_impl.lock().unwrap().prepare_for_sync(data) + } + } + + fn sync_started(&self) -> ApiResult<()> { + // This is a no-op for the Tabs Engine + Ok(()) + } + + fn store_incoming(&self, incoming: Vec<IncomingBso>) -> ApiResult<()> { + handle_error! { + // Store the incoming payload in memory so we can use it in apply + *(self.incoming.lock().unwrap()) = incoming; + Ok(()) + } + } + + fn apply(&self) -> ApiResult<ApplyResults> { + handle_error! { + let mut incoming = self.incoming.lock().unwrap(); + // We've a reference to a Vec<> but it's owned by the mutex - swap the mutex owned + // value for an empty vec so we can consume the original. + let mut records = Vec::new(); + std::mem::swap(&mut records, &mut *incoming); + let mut telem = sync15::telemetry::Engine::new("tabs"); + + let mut sync_impl = self.sync_impl.lock().unwrap(); + let outgoing = sync_impl.apply_incoming(records, &mut telem)?; + + Ok(ApplyResults { + records: outgoing, + num_reconciled: Some(0), + }) + } + } + + fn set_uploaded(&self, server_modified_millis: i64, ids: &[SyncGuid]) -> ApiResult<()> { + handle_error! { + self + .sync_impl + .lock() + .unwrap() + .sync_finished(ServerTimestamp::from_millis(server_modified_millis), ids) + } + } + + fn sync_finished(&self) -> ApiResult<()> { + handle_error! { + *(self.incoming.lock().unwrap()) = Vec::default(); + Ok(()) + } + } + + fn reset(&self) -> ApiResult<()> { + handle_error! { + self.sync_impl + .lock() + .unwrap() + .reset(EngineSyncAssociation::Disconnected)?; + Ok(()) + } + } + + fn wipe(&self) -> ApiResult<()> { + handle_error! { + self.sync_impl.lock().unwrap().wipe()?; + Ok(()) + } + } +} + +// This is for uniffi to expose, and does nothing than delegate back to the trait. +pub struct TabsBridgedEngine { + bridge_impl: BridgedEngineImpl, +} + +impl TabsBridgedEngine { + pub fn new(bridge_impl: BridgedEngineImpl) -> Self { + Self { bridge_impl } + } + + pub fn last_sync(&self) -> ApiResult<i64> { + self.bridge_impl.last_sync() + } + + pub fn set_last_sync(&self, last_sync: i64) -> ApiResult<()> { + self.bridge_impl.set_last_sync(last_sync) + } + + pub fn sync_id(&self) -> ApiResult<Option<String>> { + self.bridge_impl.sync_id() + } + + pub fn reset_sync_id(&self) -> ApiResult<String> { + self.bridge_impl.reset_sync_id() + } + + pub fn ensure_current_sync_id(&self, sync_id: &str) -> ApiResult<String> { + self.bridge_impl.ensure_current_sync_id(sync_id) + } + + pub fn prepare_for_sync(&self, client_data: &str) -> ApiResult<()> { + self.bridge_impl.prepare_for_sync(client_data) + } + + pub fn sync_started(&self) -> ApiResult<()> { + self.bridge_impl.sync_started() + } + + // Decode the JSON-encoded IncomingBso's that UniFFI passes to us + fn convert_incoming_bsos(&self, incoming: Vec<String>) -> ApiResult<Vec<IncomingBso>> { + handle_error! { + let mut bsos = Vec::with_capacity(incoming.len()); + for inc in incoming { + bsos.push(serde_json::from_str::<IncomingBso>(&inc)?); + } + Ok(bsos) + } + } + + // Encode OutgoingBso's into JSON for UniFFI + fn convert_outgoing_bsos(&self, outgoing: Vec<OutgoingBso>) -> ApiResult<Vec<String>> { + handle_error! { + let mut bsos = Vec::with_capacity(outgoing.len()); + for e in outgoing { + bsos.push(serde_json::to_string(&e)?); + } + Ok(bsos) + } + } + + pub fn store_incoming(&self, incoming: Vec<String>) -> ApiResult<()> { + self.bridge_impl + .store_incoming(self.convert_incoming_bsos(incoming)?) + } + + pub fn apply(&self) -> ApiResult<Vec<String>> { + let apply_results = self.bridge_impl.apply()?; + self.convert_outgoing_bsos(apply_results.records) + } + + pub fn set_uploaded(&self, server_modified_millis: i64, guids: Vec<SyncGuid>) -> ApiResult<()> { + self.bridge_impl + .set_uploaded(server_modified_millis, &guids) + } + + pub fn sync_finished(&self) -> ApiResult<()> { + self.bridge_impl.sync_finished() + } + + pub fn reset(&self) -> ApiResult<()> { + self.bridge_impl.reset() + } + + pub fn wipe(&self) -> ApiResult<()> { + self.bridge_impl.wipe() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::storage::RemoteTab; + use crate::sync::record::TabsRecordTab; + use serde_json::json; + use std::collections::HashMap; + use sync15::{ClientData, RemoteClient}; + + const TTL_1_YEAR: u32 = 31_622_400; + + // A copy of the normal "engine" tests but which go via the bridge + #[test] + fn test_sync_via_bridge() { + env_logger::try_init().ok(); + + let store = Arc::new(TabsStore::new_with_mem_path("test-bridge_incoming")); + + // Set some local tabs for our device. + let my_tabs = vec![ + RemoteTab { + title: "my first tab".to_string(), + url_history: vec!["http://1.com".to_string()], + icon: None, + last_used: 0, + }, + RemoteTab { + title: "my second tab".to_string(), + url_history: vec!["http://2.com".to_string()], + icon: None, + last_used: 1, + }, + ]; + store.set_local_tabs(my_tabs.clone()); + + let bridge = store.bridged_engine(); + + let client_data = ClientData { + local_client_id: "my-device".to_string(), + recent_clients: HashMap::from([ + ( + "my-device".to_string(), + RemoteClient { + fxa_device_id: None, + device_name: "my device".to_string(), + device_type: None, + }, + ), + ( + "device-no-tabs".to_string(), + RemoteClient { + fxa_device_id: None, + device_name: "device with no tabs".to_string(), + device_type: None, + }, + ), + ( + "device-with-a-tab".to_string(), + RemoteClient { + fxa_device_id: None, + device_name: "device with a tab".to_string(), + device_type: None, + }, + ), + ]), + }; + bridge + .prepare_for_sync(&serde_json::to_string(&client_data).unwrap()) + .expect("should work"); + + let records = vec![ + // my-device should be ignored by sync - here it is acting as what our engine last + // wrote, but the actual tabs in our store we set above are what should be used. + json!({ + "id": "my-device", + "clientName": "my device", + "tabs": [{ + "title": "the title", + "urlHistory": [ + "https://mozilla.org/" + ], + "icon": "https://mozilla.org/icon", + "lastUsed": 1643764207 + }] + }), + json!({ + "id": "device-no-tabs", + "clientName": "device with no tabs", + "tabs": [], + }), + json!({ + "id": "device-with-a-tab", + "clientName": "device with a tab", + "tabs": [{ + "title": "the title", + "urlHistory": [ + "https://mozilla.org/" + ], + "icon": "https://mozilla.org/icon", + "lastUsed": 1643764207 + }] + }), + // This has the main payload as OK but the tabs part invalid. + json!({ + "id": "device-with-invalid-tab", + "clientName": "device with a tab", + "tabs": [{ + "foo": "bar", + }] + }), + // We want this to be a valid payload but an invalid tab - so it needs an ID. + json!({ + "id": "invalid-tab", + "foo": "bar" + }), + ]; + + let mut incoming = Vec::new(); + for record in records { + // Annoyingly we can't use `IncomingEnvelope` directly as it intentionally doesn't + // support Serialize - so need to use explicit json. + let envelope = json!({ + "id": record.get("id"), + "modified": 0, + "payload": serde_json::to_string(&record).unwrap(), + }); + incoming.push(serde_json::to_string(&envelope).unwrap()); + } + + bridge.store_incoming(incoming).expect("should store"); + + let out = bridge.apply().expect("should apply"); + + assert_eq!(out.len(), 1); + let ours = serde_json::from_str::<serde_json::Value>(&out[0]).unwrap(); + // As above, can't use `OutgoingEnvelope` as it doesn't Deserialize. + // First, convert my_tabs from the local `RemoteTab` to the Sync specific `TabsRecord` + let expected_tabs: Vec<TabsRecordTab> = + my_tabs.into_iter().map(|t| t.to_record_tab()).collect(); + let expected = json!({ + "id": "my-device".to_string(), + "payload": json!({ + "id": "my-device".to_string(), + "clientName": "my device", + "tabs": serde_json::to_value(expected_tabs).unwrap(), + }).to_string(), + "ttl": TTL_1_YEAR, + }); + + assert_eq!(ours, expected); + bridge.set_uploaded(1234, vec![]).unwrap(); + assert_eq!(bridge.last_sync().unwrap(), 1234); + } + + #[test] + fn test_sync_meta() { + env_logger::try_init().ok(); + + let store = Arc::new(TabsStore::new_with_mem_path("test-meta")); + let bridge = store.bridged_engine(); + + bridge.set_last_sync(3).unwrap(); + assert_eq!(bridge.last_sync().unwrap(), 3); + + assert!(bridge.sync_id().unwrap().is_none()); + + bridge.ensure_current_sync_id("some_guid").unwrap(); + assert_eq!(bridge.sync_id().unwrap(), Some("some_guid".to_string())); + // changing the sync ID should reset the timestamp + assert_eq!(bridge.last_sync().unwrap(), 0); + bridge.set_last_sync(3).unwrap(); + + bridge.reset_sync_id().unwrap(); + // should now be a random guid. + assert_ne!(bridge.sync_id().unwrap(), Some("some_guid".to_string())); + // should have reset the last sync timestamp. + assert_eq!(bridge.last_sync().unwrap(), 0); + bridge.set_last_sync(3).unwrap(); + + // `reset` clears the guid and the timestamp + bridge.reset().unwrap(); + assert_eq!(bridge.last_sync().unwrap(), 0); + assert!(bridge.sync_id().unwrap().is_none()); + } +} diff --git a/third_party/rust/tabs/src/sync/engine.rs b/third_party/rust/tabs/src/sync/engine.rs new file mode 100644 index 0000000000..6ffa5274df --- /dev/null +++ b/third_party/rust/tabs/src/sync/engine.rs @@ -0,0 +1,515 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use crate::storage::{ClientRemoteTabs, RemoteTab}; +use crate::store::TabsStore; +use crate::sync::record::{TabsRecord, TabsRecordTab}; +use crate::Result; +use std::collections::HashMap; +use std::sync::{Arc, Mutex, Weak}; +use sync15::bso::{IncomingBso, OutgoingBso, OutgoingEnvelope}; +use sync15::engine::{ + CollectionRequest, EngineSyncAssociation, IncomingChangeset, OutgoingChangeset, SyncEngine, + SyncEngineId, +}; +use sync15::{telemetry, ClientData, DeviceType, RemoteClient, ServerTimestamp}; +use sync_guid::Guid; + +const TTL_1_YEAR: u32 = 31_622_400; + +// Our "sync manager" will use whatever is stashed here. +lazy_static::lazy_static! { + // Mutex: just taken long enough to update the inner stuff + static ref STORE_FOR_MANAGER: Mutex<Weak<TabsStore>> = Mutex::new(Weak::new()); +} + +/// Called by the sync manager to get a sync engine via the store previously +/// registered with the sync manager. +pub fn get_registered_sync_engine(engine_id: &SyncEngineId) -> Option<Box<dyn SyncEngine>> { + let weak = STORE_FOR_MANAGER.lock().unwrap(); + match weak.upgrade() { + None => None, + Some(store) => match engine_id { + SyncEngineId::Tabs => Some(Box::new(TabsEngine::new(Arc::clone(&store)))), + // panicing here seems reasonable - it's a static error if this + // it hit, not something that runtime conditions can influence. + _ => unreachable!("can't provide unknown engine: {}", engine_id), + }, + } +} + +impl ClientRemoteTabs { + fn from_record_with_remote_client( + client_id: String, + last_modified: ServerTimestamp, + remote_client: &RemoteClient, + record: TabsRecord, + ) -> Self { + Self { + client_id, + client_name: remote_client.device_name.clone(), + device_type: remote_client.device_type.unwrap_or(DeviceType::Unknown), + last_modified: last_modified.as_millis(), + remote_tabs: record.tabs.iter().map(RemoteTab::from_record_tab).collect(), + } + } + + fn from_record(client_id: String, last_modified: ServerTimestamp, record: TabsRecord) -> Self { + Self { + client_id, + client_name: record.client_name, + device_type: DeviceType::Unknown, + last_modified: last_modified.as_millis(), + remote_tabs: record.tabs.iter().map(RemoteTab::from_record_tab).collect(), + } + } + fn to_record(&self) -> TabsRecord { + TabsRecord { + id: self.client_id.clone(), + client_name: self.client_name.clone(), + tabs: self + .remote_tabs + .iter() + .map(RemoteTab::to_record_tab) + .collect(), + } + } +} + +impl RemoteTab { + fn from_record_tab(tab: &TabsRecordTab) -> Self { + Self { + title: tab.title.clone(), + url_history: tab.url_history.clone(), + icon: tab.icon.clone(), + last_used: tab.last_used.checked_mul(1000).unwrap_or_default(), + } + } + pub(super) fn to_record_tab(&self) -> TabsRecordTab { + TabsRecordTab { + title: self.title.clone(), + url_history: self.url_history.clone(), + icon: self.icon.clone(), + last_used: self.last_used.checked_div(1000).unwrap_or_default(), + } + } +} + +// This is the implementation of syncing, which is used by the 2 different "sync engines" +// (We hope to get these 2 engines even closer in the future, but for now, we suck this up) +pub struct TabsSyncImpl { + pub(super) store: Arc<TabsStore>, + remote_clients: HashMap<String, RemoteClient>, + pub(super) last_sync: Option<ServerTimestamp>, + sync_store_assoc: EngineSyncAssociation, + pub(super) local_id: String, +} + +impl TabsSyncImpl { + pub fn new(store: Arc<TabsStore>) -> Self { + Self { + store, + remote_clients: HashMap::new(), + last_sync: None, + sync_store_assoc: EngineSyncAssociation::Disconnected, + local_id: Default::default(), + } + } + + pub fn prepare_for_sync(&mut self, client_data: ClientData) -> Result<()> { + self.remote_clients = client_data.recent_clients; + self.local_id = client_data.local_client_id; + Ok(()) + } + + pub fn apply_incoming( + &mut self, + inbound: Vec<IncomingBso>, + telem: &mut telemetry::Engine, + ) -> Result<Vec<OutgoingBso>> { + let local_id = self.local_id.clone(); + let mut remote_tabs = Vec::with_capacity(inbound.len()); + let mut incoming_telemetry = telemetry::EngineIncoming::new(); + + for incoming in inbound { + if incoming.envelope.id == local_id { + // That's our own record, ignore it. + continue; + } + let modified = incoming.envelope.modified; + let record = match incoming.into_content::<TabsRecord>().content() { + Some(record) => record, + None => { + // Invalid record or a "tombstone" which tabs don't have. + log::warn!("Ignoring incoming invalid tab"); + incoming_telemetry.failed(1); + continue; + } + }; + let id = record.id.clone(); + let crt = if let Some(remote_client) = self.remote_clients.get(&id) { + ClientRemoteTabs::from_record_with_remote_client( + remote_client + .fxa_device_id + .as_ref() + .unwrap_or(&id) + .to_owned(), + modified, + remote_client, + record, + ) + } else { + // A record with a device that's not in our remote clients seems unlikely, but + // could happen - in most cases though, it will be due to a disconnected client - + // so we really should consider just dropping it? (Sadly though, it does seem + // possible it's actually a very recently connected client, so we keep it) + + // XXX - this is actually a foot-gun, particularly for desktop. If we don't know + // the device, we assume the device ID is the fxa-device-id, which may not be the + // case. + // So we should drop these records! But we can't do this now because stand alone + // syncing (ie, store.sync()) doesn't allow us to pass the device list in, so + // we'd get no rows! + // See also: https://github.com/mozilla/application-services/issues/5199 + log::info!( + "Storing tabs from a client that doesn't appear in the devices list: {}", + id, + ); + ClientRemoteTabs::from_record(id, modified, record) + }; + remote_tabs.push(crt); + } + + // We want to keep the mutex for as short as possible + let local_tabs = { + let mut storage = self.store.storage.lock().unwrap(); + // In desktop we might end up here with zero records when doing a quick-write, in + // which case we don't want to wipe the DB. + if !remote_tabs.is_empty() { + storage.replace_remote_tabs(remote_tabs)?; + } + storage.prepare_local_tabs_for_upload() + }; + let outgoing = if let Some(local_tabs) = local_tabs { + let (client_name, device_type) = self + .remote_clients + .get(&local_id) + .map(|client| { + ( + client.device_name.clone(), + client.device_type.unwrap_or(DeviceType::Unknown), + ) + }) + .unwrap_or_else(|| (String::new(), DeviceType::Unknown)); + let local_record = ClientRemoteTabs { + client_id: local_id.clone(), + client_name, + device_type, + last_modified: 0, // ignored for outgoing records. + remote_tabs: local_tabs.to_vec(), + }; + log::trace!("outgoing {:?}", local_record); + let envelope = OutgoingEnvelope { + id: local_id.into(), + ttl: Some(TTL_1_YEAR), + ..Default::default() + }; + vec![OutgoingBso::from_content( + envelope, + local_record.to_record(), + )?] + } else { + vec![] + }; + telem.incoming(incoming_telemetry); + Ok(outgoing) + } + + pub fn sync_finished( + &mut self, + new_timestamp: ServerTimestamp, + records_synced: &[Guid], + ) -> Result<()> { + log::info!( + "sync completed after uploading {} records", + records_synced.len() + ); + self.last_sync = Some(new_timestamp); + Ok(()) + } + + pub fn reset(&mut self, assoc: EngineSyncAssociation) -> Result<()> { + self.remote_clients.clear(); + self.sync_store_assoc = assoc; + self.last_sync = None; + self.store.storage.lock().unwrap().wipe_remote_tabs()?; + Ok(()) + } + + pub fn wipe(&mut self) -> Result<()> { + self.reset(EngineSyncAssociation::Disconnected)?; + // not clear why we need to wipe the local tabs - the app is just going + // to re-add them? + self.store.storage.lock().unwrap().wipe_local_tabs(); + Ok(()) + } + + pub fn get_sync_assoc(&self) -> &EngineSyncAssociation { + &self.sync_store_assoc + } +} + +// This is the "SyncEngine" used when syncing via the Sync Manager. +pub struct TabsEngine { + pub sync_impl: Mutex<TabsSyncImpl>, +} + +impl TabsEngine { + pub fn new(store: Arc<TabsStore>) -> Self { + Self { + sync_impl: Mutex::new(TabsSyncImpl::new(store)), + } + } +} + +impl SyncEngine for TabsEngine { + fn collection_name(&self) -> std::borrow::Cow<'static, str> { + "tabs".into() + } + + fn prepare_for_sync(&self, get_client_data: &dyn Fn() -> ClientData) -> anyhow::Result<()> { + Ok(self + .sync_impl + .lock() + .unwrap() + .prepare_for_sync(get_client_data())?) + } + + fn apply_incoming( + &self, + inbound: Vec<IncomingChangeset>, + telem: &mut telemetry::Engine, + ) -> anyhow::Result<OutgoingChangeset> { + assert_eq!(inbound.len(), 1, "only requested one set of records"); + let inbound = inbound.into_iter().next().unwrap(); + let outgoing_records = self + .sync_impl + .lock() + .unwrap() + .apply_incoming(inbound.changes, telem)?; + + Ok(OutgoingChangeset::new_with_changes( + "tabs", + inbound.timestamp, + outgoing_records, + )) + } + + fn sync_finished( + &self, + new_timestamp: ServerTimestamp, + records_synced: Vec<Guid>, + ) -> anyhow::Result<()> { + Ok(self + .sync_impl + .lock() + .unwrap() + .sync_finished(new_timestamp, &records_synced)?) + } + + fn get_collection_requests( + &self, + server_timestamp: ServerTimestamp, + ) -> anyhow::Result<Vec<CollectionRequest>> { + let since = self.sync_impl.lock().unwrap().last_sync.unwrap_or_default(); + Ok(if since == server_timestamp { + vec![] + } else { + vec![CollectionRequest::new("tabs").full().newer_than(since)] + }) + } + + fn get_sync_assoc(&self) -> anyhow::Result<EngineSyncAssociation> { + Ok(self.sync_impl.lock().unwrap().get_sync_assoc().clone()) + } + + fn reset(&self, assoc: &EngineSyncAssociation) -> anyhow::Result<()> { + Ok(self.sync_impl.lock().unwrap().reset(assoc.clone())?) + } + + fn wipe(&self) -> anyhow::Result<()> { + Ok(self.sync_impl.lock().unwrap().wipe()?) + } +} + +impl crate::TabsStore { + // This allows the embedding app to say "make this instance available to + // the sync manager". The implementation is more like "offer to sync mgr" + // (thereby avoiding us needing to link with the sync manager) but + // `register_with_sync_manager()` is logically what's happening so that's + // the name it gets. + pub fn register_with_sync_manager(self: Arc<Self>) { + let mut state = STORE_FOR_MANAGER.lock().unwrap(); + *state = Arc::downgrade(&self); + } +} + +#[cfg(test)] +pub mod test { + use super::*; + use serde_json::json; + use sync15::bso::IncomingBso; + + #[test] + fn test_incoming_tabs() { + env_logger::try_init().ok(); + + let engine = TabsEngine::new(Arc::new(TabsStore::new_with_mem_path("test-incoming"))); + + let records = vec![ + json!({ + "id": "device-no-tabs", + "clientName": "device with no tabs", + "tabs": [], + }), + json!({ + "id": "device-with-a-tab", + "clientName": "device with a tab", + "tabs": [{ + "title": "the title", + "urlHistory": [ + "https://mozilla.org/" + ], + "icon": "https://mozilla.org/icon", + "lastUsed": 1643764207 + }] + }), + // This has the main payload as OK but the tabs part invalid. + json!({ + "id": "device-with-invalid-tab", + "clientName": "device with a tab", + "tabs": [{ + "foo": "bar", + }] + }), + // We want this to be a valid payload but an invalid tab - so it needs an ID. + json!({ + "id": "invalid-tab", + "foo": "bar" + }), + ]; + + let incoming = IncomingChangeset::new_with_changes( + engine.collection_name(), + ServerTimestamp(0), + records + .into_iter() + .map(IncomingBso::from_test_content) + .collect(), + ); + let outgoing = engine + .apply_incoming(vec![incoming], &mut telemetry::Engine::new("tabs")) + .expect("Should apply incoming and stage outgoing records"); + + assert!(outgoing.changes.is_empty()); + + // now check the store has what we think it has. + let sync_impl = engine.sync_impl.lock().unwrap(); + let mut storage = sync_impl.store.storage.lock().unwrap(); + let mut crts = storage.get_remote_tabs().expect("should work"); + crts.sort_by(|a, b| a.client_name.partial_cmp(&b.client_name).unwrap()); + assert_eq!(crts.len(), 2, "we currently include devices with no tabs"); + let crt = &crts[0]; + assert_eq!(crt.client_name, "device with a tab"); + assert_eq!(crt.device_type, DeviceType::Unknown); + assert_eq!(crt.remote_tabs.len(), 1); + assert_eq!(crt.remote_tabs[0].title, "the title"); + + let crt = &crts[1]; + assert_eq!(crt.client_name, "device with no tabs"); + assert_eq!(crt.device_type, DeviceType::Unknown); + assert_eq!(crt.remote_tabs.len(), 0); + } + + #[test] + fn test_no_incoming_doesnt_write() { + env_logger::try_init().ok(); + + let engine = TabsEngine::new(Arc::new(TabsStore::new_with_mem_path( + "test_no_incoming_doesnt_write", + ))); + + let records = vec![json!({ + "id": "device-with-a-tab", + "clientName": "device with a tab", + "tabs": [{ + "title": "the title", + "urlHistory": [ + "https://mozilla.org/" + ], + "icon": "https://mozilla.org/icon", + "lastUsed": 1643764207 + }] + })]; + + let incoming = IncomingChangeset::new_with_changes( + engine.collection_name(), + ServerTimestamp(0), + records + .into_iter() + .map(IncomingBso::from_test_content) + .collect(), + ); + engine + .apply_incoming(vec![incoming], &mut telemetry::Engine::new("tabs")) + .expect("Should apply incoming and stage outgoing records"); + + // now check the store has what we think it has. + { + let sync_impl = engine.sync_impl.lock().unwrap(); + let mut storage = sync_impl.store.storage.lock().unwrap(); + assert_eq!(storage.get_remote_tabs().expect("should work").len(), 1); + } + + // Now another sync with zero incoming records, should still be able to get back + // our one client. + let incoming = IncomingChangeset::new_with_changes( + engine.collection_name(), + ServerTimestamp(0), + vec![], + ); + engine + .apply_incoming(vec![incoming], &mut telemetry::Engine::new("tabs")) + .expect("Should succeed applying zero records"); + + { + let sync_impl = engine.sync_impl.lock().unwrap(); + let mut storage = sync_impl.store.storage.lock().unwrap(); + assert_eq!(storage.get_remote_tabs().expect("should work").len(), 1); + } + } + + #[test] + fn test_sync_manager_registration() { + let store = Arc::new(TabsStore::new_with_mem_path("test-registration")); + assert_eq!(Arc::strong_count(&store), 1); + assert_eq!(Arc::weak_count(&store), 0); + Arc::clone(&store).register_with_sync_manager(); + assert_eq!(Arc::strong_count(&store), 1); + assert_eq!(Arc::weak_count(&store), 1); + let registered = STORE_FOR_MANAGER + .lock() + .unwrap() + .upgrade() + .expect("should upgrade"); + assert!(Arc::ptr_eq(&store, ®istered)); + drop(registered); + // should be no new references + assert_eq!(Arc::strong_count(&store), 1); + assert_eq!(Arc::weak_count(&store), 1); + // dropping the registered object should drop the registration. + drop(store); + assert!(STORE_FOR_MANAGER.lock().unwrap().upgrade().is_none()); + } +} diff --git a/third_party/rust/tabs/src/sync/full_sync.rs b/third_party/rust/tabs/src/sync/full_sync.rs new file mode 100644 index 0000000000..defd4b473b --- /dev/null +++ b/third_party/rust/tabs/src/sync/full_sync.rs @@ -0,0 +1,72 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use crate::{sync::engine::TabsSyncImpl, ApiResult, Result, TabsEngine, TabsStore}; +use error_support::handle_error; +use interrupt_support::NeverInterrupts; +use std::sync::Arc; +use sync15::client::{sync_multiple, MemoryCachedState, Sync15StorageClientInit}; +use sync15::engine::EngineSyncAssociation; +use sync15::KeyBundle; + +impl TabsStore { + pub fn reset(self: Arc<Self>) -> ApiResult<()> { + handle_error! { + let mut sync_impl = TabsSyncImpl::new(Arc::clone(&self)); + sync_impl.reset(EngineSyncAssociation::Disconnected)?; + Ok(()) + } + } + + /// A convenience wrapper around sync_multiple. + pub fn sync( + self: Arc<Self>, + key_id: String, + access_token: String, + sync_key: String, + tokenserver_url: String, + local_id: String, + ) -> ApiResult<String> { + handle_error! { + let mut mem_cached_state = MemoryCachedState::default(); + let engine = TabsEngine::new(Arc::clone(&self)); + + // Since we are syncing without the sync manager, there's no + // command processor, therefore no clients engine, and in + // consequence `TabsStore::prepare_for_sync` is never called + // which means our `local_id` will never be set. + // Do it here. + engine.sync_impl.lock().unwrap().local_id = local_id; + + let storage_init = &Sync15StorageClientInit { + key_id, + access_token, + tokenserver_url: url::Url::parse(tokenserver_url.as_str())?, + }; + let root_sync_key = &KeyBundle::from_ksync_base64(sync_key.as_str())?; + + let mut result = sync_multiple( + &[&engine], + &mut None, + &mut mem_cached_state, + storage_init, + root_sync_key, + &NeverInterrupts, + None, + ); + + // for b/w compat reasons, we do some dances with the result. + // XXX - note that this means telemetry isn't going to be reported back + // to the app - we need to check with lockwise about whether they really + // need these failures to be reported or whether we can loosen this. + if let Err(e) = result.result { + return Err(e.into()); + } + match result.engine_results.remove("tabs") { + None | Some(Ok(())) => Ok(serde_json::to_string(&result.telemetry)?), + Some(Err(e)) => Err(e.into()), + } + } + } +} diff --git a/third_party/rust/tabs/src/sync/mod.rs b/third_party/rust/tabs/src/sync/mod.rs new file mode 100644 index 0000000000..0fccbb2aae --- /dev/null +++ b/third_party/rust/tabs/src/sync/mod.rs @@ -0,0 +1,35 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +pub(crate) mod bridge; +pub(crate) mod engine; +mod record; + +#[cfg(feature = "full-sync")] +pub mod full_sync; + +// When full-sync isn't enabled we need stub versions for these UDL exposed functions. +#[cfg(not(feature = "full-sync"))] +impl crate::TabsStore { + pub fn reset(self: std::sync::Arc<Self>) -> crate::error::ApiResult<()> { + log::warn!("reset: feature not enabled"); + Err(crate::error::TabsApiError::SyncError { + reason: "reset".to_string(), + }) + } + + pub fn sync( + self: std::sync::Arc<Self>, + _key_id: String, + _access_token: String, + _sync_key: String, + _tokenserver_url: String, + _local_id: String, + ) -> crate::error::ApiResult<String> { + log::warn!("sync: feature not enabled"); + Err(crate::error::TabsApiError::SyncError { + reason: "sync".to_string(), + }) + } +} diff --git a/third_party/rust/tabs/src/sync/record.rs b/third_party/rust/tabs/src/sync/record.rs new file mode 100644 index 0000000000..61e99e7316 --- /dev/null +++ b/third_party/rust/tabs/src/sync/record.rs @@ -0,0 +1,96 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use serde_derive::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Default)] +#[serde(rename_all = "camelCase")] +pub struct TabsRecordTab { + pub title: String, + pub url_history: Vec<String>, + pub icon: Option<String>, + pub last_used: i64, // Seconds since epoch! +} + +#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct TabsRecord { + // `String` instead of `SyncGuid` because some IDs are FxA device ID (XXX - that doesn't + // matter though - this could easily be a Guid!) + pub id: String, + pub client_name: String, + pub tabs: Vec<TabsRecordTab>, +} + +#[cfg(test)] +pub mod test { + use super::*; + use serde_json::json; + + #[test] + fn test_payload() { + let payload = json!({ + "id": "JkeBPC50ZI0m", + "clientName": "client name", + "tabs": [{ + "title": "the title", + "urlHistory": [ + "https://mozilla.org/" + ], + "icon": "https://mozilla.org/icon", + "lastUsed": 1643764207 + }] + }); + let record: TabsRecord = serde_json::from_value(payload).expect("should work"); + assert_eq!(record.id, "JkeBPC50ZI0m"); + assert_eq!(record.client_name, "client name"); + assert_eq!(record.tabs.len(), 1); + let tab = &record.tabs[0]; + assert_eq!(tab.title, "the title"); + assert_eq!(tab.icon, Some("https://mozilla.org/icon".to_string())); + assert_eq!(tab.last_used, 1643764207); + } + + #[test] + fn test_roundtrip() { + let tab = TabsRecord { + id: "JkeBPC50ZI0m".into(), + client_name: "client name".into(), + tabs: vec![TabsRecordTab { + title: "the title".into(), + url_history: vec!["https://mozilla.org/".into()], + icon: Some("https://mozilla.org/icon".into()), + last_used: 1643764207, + }], + }; + let round_tripped = + serde_json::from_value(serde_json::to_value(tab.clone()).unwrap()).unwrap(); + assert_eq!(tab, round_tripped); + } + + #[test] + fn test_extra_fields() { + let payload = json!({ + "id": "JkeBPC50ZI0m", + // Let's say we agree on new tabs to record, we want old versions to + // ignore them! + "ignoredField": "??", + "clientName": "client name", + "tabs": [{ + "title": "the title", + "urlHistory": [ + "https://mozilla.org/" + ], + "icon": "https://mozilla.org/icon", + "lastUsed": 1643764207, + // Ditto - make sure we ignore unexpected fields in each tab. + "ignoredField": "??", + }] + }); + let record: TabsRecord = serde_json::from_value(payload).unwrap(); + // The point of this test is really just to ensure the deser worked, so + // just check the ID. + assert_eq!(record.id, "JkeBPC50ZI0m"); + } +} diff --git a/third_party/rust/tabs/src/tabs.udl b/third_party/rust/tabs/src/tabs.udl new file mode 100644 index 0000000000..d1964ea0d2 --- /dev/null +++ b/third_party/rust/tabs/src/tabs.udl @@ -0,0 +1,108 @@ +[Custom] +typedef string TabsGuid; + +namespace tabs { + +}; + +[Error] +interface TabsApiError { + SyncError(string reason); + SqlError(string reason); + UnexpectedTabsError(string reason); +}; + + +interface TabsStore { + constructor(string path); + + sequence<ClientRemoteTabs> get_all(); + + void set_local_tabs(sequence<RemoteTabRecord> remote_tabs); + + [Self=ByArc] + void register_with_sync_manager(); + + [Throws=TabsApiError, Self=ByArc] + void reset(); + + [Throws=TabsApiError, Self=ByArc] + string sync(string key_id, string access_token, string sync_key, string tokenserver_url, string local_id); + + [Self=ByArc] + TabsBridgedEngine bridged_engine(); + +}; + +// Note that this enum is duplicated in fxa-client.udl (although the underlying type *is* +// shared). This duplication exists because there's no direct dependency between that crate and +// this one. We can probably remove the duplication when sync15 gets a .udl file, then we could +// reference it via an `[Extern=...]typedef` +enum TabsDeviceType { "Desktop", "Mobile", "Tablet", "VR", "TV", "Unknown" }; + +dictionary RemoteTabRecord { + string title; + sequence<string> url_history; + string? icon; + // Number of ms since the unix epoch (as reported by the client's clock) + i64 last_used; +}; + +dictionary ClientRemoteTabs { + string client_id; + string client_name; + TabsDeviceType device_type; + // Number of ms since the unix epoch (as reported by the server's clock) + i64 last_modified; + sequence<RemoteTabRecord> remote_tabs; +}; + +// Note the canonical docs for this are in https://searchfox.org/mozilla-central/source/services/interfaces/mozIBridgedSyncEngine.idl +// It's only actually used in desktop, but it's fine to expose this everywhere. +// NOTE: all timestamps here are milliseconds. +interface TabsBridgedEngine { + //readonly attribute long storageVersion; + // readonly attribute boolean allowSkippedRecord; + + // XXX - better logging story than this? + // attribute mozIServicesLogSink logger; + + [Throws=TabsApiError] + i64 last_sync(); + + [Throws=TabsApiError] + void set_last_sync(i64 last_sync); + + [Throws=TabsApiError] + string? sync_id(); + + [Throws=TabsApiError] + string reset_sync_id(); + + [Throws=TabsApiError] + string ensure_current_sync_id([ByRef]string new_sync_id); + + [Throws=TabsApiError] + void prepare_for_sync([ByRef]string client_data); + + [Throws=TabsApiError] + void sync_started(); + + [Throws=TabsApiError] + void store_incoming(sequence<string> incoming_envelopes_as_json); + + [Throws=TabsApiError] + sequence<string> apply(); + + [Throws=TabsApiError] + void set_uploaded(i64 new_timestamp, sequence<TabsGuid> uploaded_ids); + + [Throws=TabsApiError] + void sync_finished(); + + [Throws=TabsApiError] + void reset(); + + [Throws=TabsApiError] + void wipe(); +}; diff --git a/third_party/rust/tabs/uniffi.toml b/third_party/rust/tabs/uniffi.toml new file mode 100644 index 0000000000..697f8390c2 --- /dev/null +++ b/third_party/rust/tabs/uniffi.toml @@ -0,0 +1,8 @@ +[bindings.kotlin] +package_name = "mozilla.appservices.remotetabs" +cdylib_name = "megazord" + +[bindings.swift] +ffi_module_name = "MozillaRustComponents" +ffi_module_filename = "tabsFFI" +generate_module_map = false |