summaryrefslogtreecommitdiffstats
path: root/third_party/rust/tabs/src
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/tabs/src')
-rw-r--r--third_party/rust/tabs/src/error.rs90
-rw-r--r--third_party/rust/tabs/src/lib.rs39
-rw-r--r--third_party/rust/tabs/src/schema.rs70
-rw-r--r--third_party/rust/tabs/src/storage.rs385
-rw-r--r--third_party/rust/tabs/src/store.rs41
-rw-r--r--third_party/rust/tabs/src/sync/bridge.rs457
-rw-r--r--third_party/rust/tabs/src/sync/engine.rs515
-rw-r--r--third_party/rust/tabs/src/sync/full_sync.rs72
-rw-r--r--third_party/rust/tabs/src/sync/mod.rs35
-rw-r--r--third_party/rust/tabs/src/sync/record.rs96
-rw-r--r--third_party/rust/tabs/src/tabs.udl108
11 files changed, 1908 insertions, 0 deletions
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, &registered));
+ 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();
+};
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-23 17:38:26 +0000