Backed out 2 changesets (bug 1654192) for causing failures in browser_startup_mainthreadio.js CLOSED TREE

Backed out changeset 885b9b821bc0 (bug 1654192)
Backed out changeset f1ee7be3a135 (bug 1654192)

Cargo.lock

@@ -2525,6 +2525,7 @@ dependencies = [
  "failure",
  "lazy_static",
  "libc",
+ "lmdb-rkv",
  "log",
  "moz_task",
  "nserror",
@@ -5848,12 +5849,13 @@ dependencies = [
  "cstr",
  "failure",
  "libc",
+ "lmdb-rkv",
  "log",
  "moz_task",
  "nserror",
  "nsstring",
  "once_cell",
- "rkv 0.15.0",
+ "rkv 0.10.4",
  "serde_json",
  "tempfile",
  "xpcom",

toolkit/components/kvstore/Cargo.toml

@@ -9,6 +9,7 @@ crossbeam-utils = "0.6.3"
 cstr = "0.1"
 lazy_static = "1"
 libc = "0.2"
+lmdb-rkv = "0.14"
 log = "0.4"
 moz_task = { path = "../../../xpcom/rust/moz_task" }
 nserror = { path = "../../../xpcom/rust/nserror" }

toolkit/components/xulstore/Cargo.toml

@@ -8,12 +8,13 @@ license = "MPL-2.0"
 crossbeam-utils = "0.6.3"
 cstr = "0.1"
 libc = "0.2"
+lmdb-rkv = "0.14"
 log = "0.4"
 moz_task = { path = "../../../xpcom/rust/moz_task" }
 nsstring = { path = "../../../xpcom/rust/nsstring" }
 nserror = { path = "../../../xpcom/rust/nserror" }
 once_cell = "1"
-rkv = { version = "0.15.0", default-features = false }
+rkv = "0.10.2"
 serde_json = "1"
 tempfile = "3"
 xpcom = { path = "../../../xpcom/rust/xpcom" }

toolkit/components/xulstore/src/error.rs

@@ -5,7 +5,7 @@
 use nserror::{
     nsresult, NS_ERROR_FAILURE, NS_ERROR_ILLEGAL_VALUE, NS_ERROR_NOT_AVAILABLE, NS_ERROR_UNEXPECTED,
 };
-use rkv::{MigrateError as RkvMigrateError, StoreError as RkvStoreError};
+use rkv::{migrate::MigrateError as RkvMigrateError, StoreError as RkvStoreError};
 use serde_json::Error as SerdeJsonError;
 use std::{io::Error as IoError, str::Utf8Error, string::FromUtf16Error, sync::PoisonError};
 

toolkit/components/xulstore/src/lib.rs

@@ -8,6 +8,7 @@ extern crate cstr;
 #[macro_use]
 extern crate failure;
 extern crate libc;
+extern crate lmdb;
 #[macro_use]
 extern crate log;
 extern crate moz_task;

toolkit/components/xulstore/src/persist.rs

@@ -19,6 +19,7 @@ use crate::{
     statics::get_database,
 };
 use crossbeam_utils::atomic::AtomicCell;
+use lmdb::Error as LmdbError;
 use moz_task::{dispatch_background_task_with_options, DispatchOptions, Task, TaskRunnable};
 use nserror::nsresult;
 use once_cell::sync::Lazy;
@@ -72,7 +73,7 @@ fn sync_persist() -> XULStoreResult<()> {
                     // to remove a value that doesn't exist in the store,
                     // so we ignore the error (although in this case the key
                     // should exist, since it was in the cache!).
-                    Err(RkvStoreError::KeyValuePairNotFound) => {
+                    Err(RkvStoreError::LmdbError(LmdbError::NotFound)) => {
                         warn!("tried to remove key that isn't in the store");
                     }
 

toolkit/components/xulstore/src/statics.rs

@@ -7,22 +7,21 @@ use crate::{
     ffi::ProfileChangeObserver,
     make_key, SEPARATOR,
 };
+use lmdb::Error as LmdbError;
 use moz_task::is_main_thread;
 use nsstring::nsString;
 use once_cell::sync::Lazy;
-use rkv::backend::{SafeMode, SafeModeDatabase, SafeModeEnvironment};
-use rkv::{Migrator, StoreOptions, Value};
+use rkv::{migrate::Migrator, Rkv, SingleStore, StoreError, StoreOptions, Value};
 use std::{
     collections::BTreeMap,
-    fs::{create_dir_all, remove_file, File},
+    fs::{copy, create_dir_all, remove_file, File},
     path::PathBuf,
     str,
     sync::Mutex,
 };
+use tempfile::tempdir;
 use xpcom::{interfaces::nsIFile, XpCom};
 
-type Rkv = rkv::Rkv<SafeModeEnvironment>;
-type SingleStore = rkv::SingleStore<SafeModeDatabase>;
 type XULStoreCache = BTreeMap<String, BTreeMap<String, BTreeMap<String, String>>>;
 
 pub struct Database {
@@ -48,10 +47,27 @@ pub(crate) fn get_database() -> XULStoreResult<Database> {
     let xulstore_dir = get_xulstore_dir()?;
     let xulstore_path = xulstore_dir.as_path();
 
-    let env = Rkv::new::<SafeMode>(xulstore_path)?;
-    Migrator::easy_migrate_lmdb_to_safe_mode(xulstore_path, &env)?;
+    let env = match Rkv::new(xulstore_path) {
+        Ok(env) => Ok(env),
+        Err(StoreError::LmdbError(LmdbError::Invalid)) => {
+            let temp_env = tempdir()?;
+            let mut migrator = Migrator::new(&xulstore_path)?;
+            migrator.migrate(temp_env.path())?;
+            copy(
+                temp_env.path().join("data.mdb"),
+                xulstore_path.join("data.mdb"),
+            )?;
+            copy(
+                temp_env.path().join("lock.mdb"),
+                xulstore_path.join("lock.mdb"),
+            )?;
+            Rkv::new(xulstore_path)
+        }
+        Err(err) => Err(err),
+    }?;
 
     let store = env.open_single("db", StoreOptions::create())?;
+
     Ok(Database::new(env, store))
 }
 
@@ -170,11 +186,14 @@ fn cache_data() -> XULStoreResult<XULStoreCache> {
 
     for result in iterator {
         let (key, value): (&str, String) = match result {
-            Ok((key, value)) => match (str::from_utf8(&key), unwrap_value(&value)) {
-                (Ok(key), Ok(value)) => (key, value),
-                (Err(err), _) => return Err(err.into()),
-                (_, Err(err)) => return Err(err),
-            },
+            Ok((key, value)) => {
+                assert!(value.is_some(), "iterated key has value");
+                match (str::from_utf8(&key), unwrap_value(&value)) {
+                    (Ok(key), Ok(value)) => (key, value),
+                    (Err(err), _) => return Err(err.into()),
+                    (_, Err(err)) => return Err(err),
+                }
+            }
             Err(err) => return Err(err.into()),
         };
 
@@ -236,13 +255,17 @@ fn maybe_migrate_data(env: &Rkv, store: SingleStore) {
     .unwrap_or_else(|err| error!("error migrating data: {}", err));
 }
 
-fn unwrap_value(value: &Value) -> XULStoreResult<String> {
+fn unwrap_value(value: &Option<Value>) -> XULStoreResult<String> {
     match value {
-        Value::Str(val) => Ok(val.to_string()),
+        Some(Value::Str(val)) => Ok(val.to_string()),
+
+        // Per the XULStore API, return an empty string if the value
+        // isn't found.
+        None => Ok(String::new()),
 
         // This should never happen, but it could happen in theory
         // if someone writes a different kind of value into the store
         // using a more general API (kvstore, rkv, LMDB).
-        _ => Err(XULStoreError::UnexpectedValue),
+        Some(_) => Err(XULStoreError::UnexpectedValue),
     }
 }