Move more responsibilities into the KeyValueDatabaseBackingStorage constructor

Author: bgw

turbopack/crates/turbo-tasks-backend/src/database/turbo.rs

@@ -24,7 +24,7 @@ pub struct TurboKeyValueDatabase {
 
 impl TurboKeyValueDatabase {
     pub fn new(versioned_path: PathBuf) -> Result<Self> {
-        let db = Arc::new(TurboPersistence::open(versioned_path.to_path_buf())?);
+        let db = Arc::new(TurboPersistence::open(versioned_path)?);
         let mut this = Self {
             db: db.clone(),
             compact_join_handle: Mutex::new(None),

turbopack/crates/turbo-tasks-backend/src/kv_backing_storage.rs

@@ -8,11 +8,13 @@ use tracing::Span;
 use turbo_tasks::{SessionId, TaskId, backend::CachedTaskType, turbo_tasks_scope};
 
 use crate::{
+    GitVersionInfo,
     backend::{AnyOperation, TaskDataCategory},
     backing_storage::BackingStorage,
     data::CachedDataItem,
     database::{
-        db_invalidation::invalidate_db,
+        db_invalidation::{check_db_invalidation_and_cleanup, invalidate_db},
+        db_versioning::handle_db_versioning,
         key_value_database::{KeySpace, KeyValueDatabase},
         write_batch::{
             BaseWriteBatch, ConcurrentWriteBatch, SerialWriteBatch, WriteBatch, WriteBatchRef,
@@ -90,13 +92,26 @@ pub struct KeyValueDatabaseBackingStorage<T: KeyValueDatabase> {
 }
 
 impl<T: KeyValueDatabase> KeyValueDatabaseBackingStorage<T> {
-    pub fn new(database: T, base_path: Option<PathBuf>) -> Self {
+    pub fn new_in_memory(database: T) -> Self {
         Self {
             database,
-            base_path,
+            base_path: None,
         }
     }
 
+    pub fn open_versioned_on_disk(
+        base_path: PathBuf,
+        version_info: &GitVersionInfo,
+        database: impl FnOnce(PathBuf) -> Result<T>,
+    ) -> Result<Self> {
+        check_db_invalidation_and_cleanup(&base_path)?;
+        let versioned_path = handle_db_versioning(&base_path, version_info)?;
+        Ok(Self {
+            database: (database)(versioned_path)?,
+            base_path: Some(base_path),
+        })
+    }
+
     fn with_tx<R>(
         &self,
         tx: Option<&T::ReadTransaction<'_>>,

turbopack/crates/turbo-tasks-backend/src/lib.rs

@@ -14,11 +14,8 @@ mod utils;
 use std::path::Path;
 
 use anyhow::Result;
-use database::db_invalidation::check_db_invalidation_and_cleanup;
 
-use crate::database::{
-    db_versioning::handle_db_versioning, noop_kv::NoopKvDb, turbo::TurboKeyValueDatabase,
-};
+use crate::database::{noop_kv::NoopKvDb, turbo::TurboKeyValueDatabase};
 pub use crate::{
     backend::{BackendOptions, StorageMode, TurboTasksBackend},
     database::db_versioning::GitVersionInfo,
@@ -47,18 +44,18 @@ pub fn lmdb_backing_storage(
         startup_cache::StartupCacheLayer,
     };
 
-    check_db_invalidation_and_cleanup(base_path)?;
-    let versioned_path = handle_db_versioning(base_path, version_info)?;
-    let fresh_db = is_fresh(&versioned_path);
-    let database = crate::database::lmdb::LmbdKeyValueDatabase::new(&versioned_path)?;
-    let database = FreshDbOptimization::new(database, fresh_db);
-    let database =
-        StartupCacheLayer::new(database, versioned_path.join("startup.cache"), fresh_db)?;
-    let database = ReadTransactionCache::new(database);
-    Ok(KeyValueDatabaseBackingStorage::new(
-        database,
-        Some(base_path.to_owned()),
-    ))
+    KeyValueDatabaseBackingStorage::open_versioned_on_disk(
+        base_path.to_owned(),
+        version_info,
+        |versioned_path| {
+            let fresh_db = is_fresh(&versioned_path);
+            let database = crate::database::lmdb::LmbdKeyValueDatabase::new(&versioned_path)?;
+            let database = FreshDbOptimization::new(database, fresh_db);
+            let database =
+                StartupCacheLayer::new(database, versioned_path.join("startup.cache"), fresh_db)?;
+            Ok(ReadTransactionCache::new(database))
+        },
+    )
 }
 
 pub type TurboBackingStorage = KeyValueDatabaseBackingStorage<TurboKeyValueDatabase>;
@@ -67,19 +64,17 @@ pub fn turbo_backing_storage(
     base_path: &Path,
     version_info: &GitVersionInfo,
 ) -> Result<TurboBackingStorage> {
-    check_db_invalidation_and_cleanup(base_path)?;
-    let versioned_path = handle_db_versioning(base_path, version_info)?;
-    let database = TurboKeyValueDatabase::new(versioned_path)?;
-    Ok(KeyValueDatabaseBackingStorage::new(
-        database,
-        Some(base_path.to_owned()),
-    ))
+    KeyValueDatabaseBackingStorage::open_versioned_on_disk(
+        base_path.to_owned(),
+        version_info,
+        |versioned_path| TurboKeyValueDatabase::new(versioned_path),
+    )
 }
 
 pub type NoopBackingStorage = KeyValueDatabaseBackingStorage<NoopKvDb>;
 
 pub fn noop_backing_storage() -> NoopBackingStorage {
-    KeyValueDatabaseBackingStorage::new(NoopKvDb, None)
+    KeyValueDatabaseBackingStorage::new_in_memory(NoopKvDb)
 }
 
 #[cfg(feature = "lmdb")]