turbo_tasks_backend/
lib.rs

1#![feature(anonymous_lifetime_in_impl_trait)]
2#![feature(associated_type_defaults)]
3#![feature(iter_collect_into)]
4#![feature(box_patterns)]
5
6mod backend;
7mod backing_storage;
8mod data;
9mod data_storage;
10mod database;
11mod kv_backing_storage;
12mod utils;
13
14use std::path::Path;
15
16use anyhow::Result;
17
18use crate::database::{noop_kv::NoopKvDb, turbo::TurboKeyValueDatabase};
19pub use crate::{
20    backend::{BackendOptions, StorageMode, TurboTasksBackend},
21    backing_storage::BackingStorage,
22    database::{
23        db_invalidation, db_invalidation::StartupCacheState, db_versioning::GitVersionInfo,
24    },
25    kv_backing_storage::KeyValueDatabaseBackingStorage,
26};
27
28#[cfg(feature = "lmdb")]
29pub type LmdbBackingStorage = KeyValueDatabaseBackingStorage<
30    database::read_transaction_cache::ReadTransactionCache<
31        database::startup_cache::StartupCacheLayer<
32            database::fresh_db_optimization::FreshDbOptimization<
33                crate::database::lmdb::LmbdKeyValueDatabase,
34            >,
35        >,
36    >,
37>;
38
39/// Creates an [`lmdb`]-based `BackingStorage` to be passed to [`TurboTasksBackend::new`].
40///
41/// Information about the state of the on-disk cache is returned using [`StartupCacheState`].
42///
43/// This is backend is slower than [`turbo_backing_storage`], but it's a known-good database that
44/// can be used when reproducing user-reported issues to isolate bugs.
45///
46/// When the `lmdb` cargo feature is enabled, [`default_backing_storage`] will return this value.
47#[cfg(feature = "lmdb")]
48pub fn lmdb_backing_storage(
49    base_path: &Path,
50    version_info: &GitVersionInfo,
51    is_ci: bool,
52) -> Result<(LmdbBackingStorage, StartupCacheState)> {
53    use crate::database::{
54        fresh_db_optimization::{FreshDbOptimization, is_fresh},
55        read_transaction_cache::ReadTransactionCache,
56        startup_cache::StartupCacheLayer,
57    };
58
59    KeyValueDatabaseBackingStorage::open_versioned_on_disk(
60        base_path.to_owned(),
61        version_info,
62        is_ci,
63        |versioned_path| {
64            let fresh_db = is_fresh(&versioned_path);
65            let database = crate::database::lmdb::LmbdKeyValueDatabase::new(&versioned_path)?;
66            let database = FreshDbOptimization::new(database, fresh_db);
67            let database =
68                StartupCacheLayer::new(database, versioned_path.join("startup.cache"), fresh_db)?;
69            Ok(ReadTransactionCache::new(database))
70        },
71    )
72}
73
74pub type TurboBackingStorage = KeyValueDatabaseBackingStorage<TurboKeyValueDatabase>;
75
76/// Creates a `BackingStorage` to be passed to [`TurboTasksBackend::new`].
77///
78/// Information about the state of the on-disk cache is returned using [`StartupCacheState`].
79///
80/// This is the fastest most-tested implementation of `BackingStorage`, and is normally returned by
81/// [`default_backing_storage`].
82pub fn turbo_backing_storage(
83    base_path: &Path,
84    version_info: &GitVersionInfo,
85    is_ci: bool,
86    is_short_session: bool,
87) -> Result<(TurboBackingStorage, StartupCacheState)> {
88    KeyValueDatabaseBackingStorage::open_versioned_on_disk(
89        base_path.to_owned(),
90        version_info,
91        is_ci,
92        |path| TurboKeyValueDatabase::new(path, is_ci, is_short_session),
93    )
94}
95
96pub type NoopBackingStorage = KeyValueDatabaseBackingStorage<NoopKvDb>;
97
98/// Creates an no-op in-memory `BackingStorage` to be passed to [`TurboTasksBackend::new`].
99pub fn noop_backing_storage() -> NoopBackingStorage {
100    KeyValueDatabaseBackingStorage::new_in_memory(NoopKvDb)
101}
102
103#[cfg(feature = "lmdb")]
104pub type DefaultBackingStorage = LmdbBackingStorage;
105
106#[cfg(not(feature = "lmdb"))]
107pub type DefaultBackingStorage = TurboBackingStorage;
108
109/// Calls [`turbo_backing_storage`] (recommended) or `lmdb_backing_storage`, depending on if the
110/// `lmdb` cargo feature is enabled.
111pub fn default_backing_storage(
112    path: &Path,
113    version_info: &GitVersionInfo,
114    is_ci: bool,
115    is_short_session: bool,
116) -> Result<(DefaultBackingStorage, StartupCacheState)> {
117    #[cfg(feature = "lmdb")]
118    {
119        lmdb_backing_storage(path, version_info, is_ci)
120    }
121    #[cfg(not(feature = "lmdb"))]
122    {
123        turbo_backing_storage(path, version_info, is_ci, is_short_session)
124    }
125}