lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

initialize.rs (78487B)


      1 //! Create-new initialization for one service-owned SQLite database.
      2 
      3 use core::{fmt, future::Future};
      4 use std::{
      5     error::Error,
      6     pin::Pin,
      7     sync::{
      8         Arc,
      9         atomic::{AtomicBool, Ordering},
     10     },
     11 };
     12 
     13 use futures::{future::BoxFuture, stream::BoxStream};
     14 use sqlx::{
     15     Either, Execute, Executor, SqlStr, Sqlite, SqliteConnection,
     16     sqlite::{SqliteQueryResult, SqliteRow, SqliteStatement, SqliteTypeInfo},
     17 };
     18 
     19 use crate::{
     20     OpenMode, SchemaCatalog, ServiceDatabaseMetadata, ServiceSqliteError, ServiceSqliteErrorKind,
     21     ServiceSqlitePaths, WriterAuthority,
     22 };
     23 
     24 /// A sealed initialization executor that never exposes its SQLite connection.
     25 ///
     26 /// Service repositories may create their product schema with ordinary typed
     27 /// SQLx queries through a mutable borrow. The service-SQLite runner exclusively
     28 /// owns transaction begin, commit, rollback, shared metadata, and the migration
     29 /// ledger.
     30 ///
     31 /// ```
     32 /// use radroots_service_sqlite::ServiceSqliteInitializer;
     33 ///
     34 /// async fn create_product_schema(
     35 ///     initializer: &mut ServiceSqliteInitializer<'_>,
     36 /// ) -> Result<(), sqlx::Error> {
     37 ///     sqlx::query(concat!("CREATE ", "TABLE product_items (id INTEGER PRIMARY KEY)"))
     38 ///         .execute(initializer)
     39 ///         .await?;
     40 ///     Ok(())
     41 /// }
     42 /// ```
     43 ///
     44 /// Transaction control and the raw connection remain inaccessible:
     45 ///
     46 /// ```compile_fail
     47 /// use radroots_service_sqlite::ServiceSqliteInitializer;
     48 ///
     49 /// async fn bypass(initializer: ServiceSqliteInitializer<'_>) {
     50 ///     initializer.commit().await.unwrap();
     51 /// }
     52 /// ```
     53 pub struct ServiceSqliteInitializer<'connection> {
     54     connection: &'connection mut SqliteConnection,
     55     statement_control_rejected: Arc<AtomicBool>,
     56 }
     57 
     58 struct RestrictedInitializationExecute<Q> {
     59     query: Q,
     60     statement_control_rejected: Arc<AtomicBool>,
     61 }
     62 
     63 impl<'query, Q> Execute<'query, Sqlite> for RestrictedInitializationExecute<Q>
     64 where
     65     Q: Execute<'query, Sqlite>,
     66 {
     67     fn sql(self) -> SqlStr {
     68         restricted_initialization_sql(self.query.sql(), &self.statement_control_rejected)
     69     }
     70 
     71     fn statement(&self) -> Option<&SqliteStatement> {
     72         None
     73     }
     74 
     75     fn take_arguments(
     76         &mut self,
     77     ) -> Result<Option<<Sqlite as sqlx::Database>::Arguments>, sqlx::error::BoxDynError> {
     78         self.query.take_arguments()
     79     }
     80 
     81     fn persistent(&self) -> bool {
     82         self.query.persistent()
     83     }
     84 }
     85 
     86 fn restricted_initialization_sql(sql: SqlStr, statement_control_rejected: &AtomicBool) -> SqlStr {
     87     if crate::statement_policy::contains_forbidden_statement_control(sql.as_str()) {
     88         statement_control_rejected.store(true, Ordering::Release);
     89         SqlStr::from_static("RADROOTS_FORBIDDEN_INITIALIZATION_STATEMENT_CONTROL")
     90     } else {
     91         sql
     92     }
     93 }
     94 
     95 impl fmt::Debug for ServiceSqliteInitializer<'_> {
     96     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
     97         formatter.write_str("ServiceSqliteInitializer([redacted])")
     98     }
     99 }
    100 
    101 impl<'executor, 'connection> Executor<'executor>
    102     for &'executor mut ServiceSqliteInitializer<'connection>
    103 where
    104     'connection: 'executor,
    105 {
    106     type Database = Sqlite;
    107 
    108     fn fetch_many<'e, 'q: 'e, Q>(
    109         self,
    110         query: Q,
    111     ) -> BoxStream<'e, Result<Either<SqliteQueryResult, SqliteRow>, sqlx::Error>>
    112     where
    113         'executor: 'e,
    114         Q: 'q + Execute<'q, Self::Database>,
    115     {
    116         (&mut *self.connection).fetch_many(RestrictedInitializationExecute {
    117             query,
    118             statement_control_rejected: Arc::clone(&self.statement_control_rejected),
    119         })
    120     }
    121 
    122     fn fetch_optional<'e, 'q: 'e, Q>(
    123         self,
    124         query: Q,
    125     ) -> BoxFuture<'e, Result<Option<SqliteRow>, sqlx::Error>>
    126     where
    127         'executor: 'e,
    128         Q: 'q + Execute<'q, Self::Database>,
    129     {
    130         (&mut *self.connection).fetch_optional(RestrictedInitializationExecute {
    131             query,
    132             statement_control_rejected: Arc::clone(&self.statement_control_rejected),
    133         })
    134     }
    135 
    136     fn prepare_with<'e>(
    137         self,
    138         sql: SqlStr,
    139         parameters: &'e [SqliteTypeInfo],
    140     ) -> BoxFuture<'e, Result<SqliteStatement, sqlx::Error>>
    141     where
    142         'executor: 'e,
    143     {
    144         (&mut *self.connection).prepare_with(
    145             restricted_initialization_sql(sql, &self.statement_control_rejected),
    146             parameters,
    147         )
    148     }
    149 }
    150 
    151 /// Boxed callback future tied to the borrowed initialization executor.
    152 pub type ServiceSqliteInitializerFuture<'a, E> =
    153     Pin<Box<dyn Future<Output = Result<(), E>> + Send + 'a>>;
    154 
    155 #[cfg(any(target_os = "linux", target_os = "macos"))]
    156 #[derive(Debug)]
    157 pub(crate) enum InitializeDatabaseOutcome {
    158     Initialized(WriterAuthority),
    159     Existing(WriterAuthority),
    160 }
    161 
    162 /// Creates and initializes a missing service database while holding sole writer authority.
    163 ///
    164 /// The callback receives only a mutable borrow of the sealed initialization
    165 /// executor. Product schema, shared metadata, the empty v1 migration ledger,
    166 /// and catalog verification occur in one runner-owned transaction. Cancellation
    167 /// or failure quarantines the one-shot connection and removes only the exact
    168 /// inode reserved by this call.
    169 pub async fn initialize_database<F, E>(
    170     paths: &ServiceSqlitePaths,
    171     mode: OpenMode,
    172     metadata: &ServiceDatabaseMetadata,
    173     schema_catalog: &SchemaCatalog,
    174     initialize_schema: F,
    175 ) -> Result<WriterAuthority, ServiceSqliteError>
    176 where
    177     F: for<'a> FnOnce(
    178         &'a mut ServiceSqliteInitializer<'_>,
    179     ) -> ServiceSqliteInitializerFuture<'a, E>,
    180     E: Error + Send + Sync + 'static,
    181 {
    182     if mode != OpenMode::Initialize {
    183         return Err(initialization_error(InitializationCause::new(
    184             InitializationFailureKind::UnsupportedMode,
    185         )));
    186     }
    187     if !metadata.matches_paths(paths) {
    188         return Err(ServiceSqliteError::new(ServiceSqliteErrorKind::Metadata));
    189     }
    190 
    191     let authority = WriterAuthority::acquire(paths, mode)?.ok_or_else(|| {
    192         initialization_error(InitializationCause::new(
    193             InitializationFailureKind::UnsupportedMode,
    194         ))
    195     })?;
    196 
    197     #[cfg(any(target_os = "linux", target_os = "macos"))]
    198     {
    199         authority.validate_for(paths)?;
    200         let recovery = crate::restore::refuse_unresolved_recovery(authority.directory());
    201         authority.validate_for(paths)?;
    202         recovery?;
    203     }
    204 
    205     #[cfg(any(target_os = "linux", target_os = "macos"))]
    206     {
    207         let failpoints = crate::failpoint::DurabilityFailpoints::default();
    208         match initialize_with_ops(
    209             paths,
    210             authority,
    211             metadata,
    212             schema_catalog,
    213             initialize_schema,
    214             &SystemInitializationOperations,
    215             &failpoints,
    216         )
    217         .await?
    218         {
    219             InitializeDatabaseOutcome::Initialized(authority) => Ok(authority),
    220             InitializeDatabaseOutcome::Existing(_authority) => Err(initialization_error(
    221                 InitializationCause::new(InitializationFailureKind::StateAlreadyExists),
    222             )),
    223         }
    224     }
    225 
    226     #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    227     {
    228         drop((authority, metadata, schema_catalog, initialize_schema));
    229         Err(initialization_error(InitializationCause::new(
    230             InitializationFailureKind::CreateUnavailable,
    231         )))
    232     }
    233 }
    234 
    235 #[cfg(any(target_os = "linux", target_os = "macos"))]
    236 pub(crate) async fn initialize_or_existing_database<F, E>(
    237     paths: &ServiceSqlitePaths,
    238     metadata: &ServiceDatabaseMetadata,
    239     schema_catalog: &SchemaCatalog,
    240     initialize_schema: F,
    241 ) -> Result<InitializeDatabaseOutcome, ServiceSqliteError>
    242 where
    243     F: for<'a> FnOnce(
    244         &'a mut ServiceSqliteInitializer<'_>,
    245     ) -> ServiceSqliteInitializerFuture<'a, E>,
    246     E: Error + Send + Sync + 'static,
    247 {
    248     if !metadata.matches_paths(paths) {
    249         return Err(ServiceSqliteError::new(ServiceSqliteErrorKind::Metadata));
    250     }
    251     let authority = WriterAuthority::acquire(paths, OpenMode::Initialize)?.ok_or_else(|| {
    252         initialization_error(InitializationCause::new(
    253             InitializationFailureKind::UnsupportedMode,
    254         ))
    255     })?;
    256     let failpoints = crate::failpoint::DurabilityFailpoints::default();
    257     initialize_with_ops(
    258         paths,
    259         authority,
    260         metadata,
    261         schema_catalog,
    262         initialize_schema,
    263         &SystemInitializationOperations,
    264         &failpoints,
    265     )
    266     .await
    267 }
    268 
    269 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    270 enum InitializationFailureKind {
    271     UnsupportedMode,
    272     #[cfg(any(target_os = "linux", target_os = "macos"))]
    273     StateAlreadyExists,
    274     CreateUnavailable,
    275     #[cfg(any(target_os = "linux", target_os = "macos"))]
    276     InvalidDatabase,
    277     #[cfg(any(target_os = "linux", target_os = "macos"))]
    278     SchemaInitializationFailed,
    279     #[cfg(any(target_os = "linux", target_os = "macos"))]
    280     DatabaseSyncFailed,
    281     #[cfg(any(target_os = "linux", target_os = "macos"))]
    282     DatabaseReplaced,
    283     #[cfg(any(target_os = "linux", target_os = "macos"))]
    284     DirectorySyncFailed,
    285     #[cfg(any(target_os = "linux", target_os = "macos"))]
    286     CleanupFailed,
    287     #[cfg(any(target_os = "linux", target_os = "macos"))]
    288     InjectedFailure,
    289 }
    290 
    291 struct InitializationCause {
    292     kind: InitializationFailureKind,
    293     source: Option<Box<dyn Error + Send + Sync + 'static>>,
    294 }
    295 
    296 impl InitializationCause {
    297     const fn new(kind: InitializationFailureKind) -> Self {
    298         Self { kind, source: None }
    299     }
    300 
    301     #[cfg(any(target_os = "linux", target_os = "macos"))]
    302     fn with_source(
    303         kind: InitializationFailureKind,
    304         source: impl Error + Send + Sync + 'static,
    305     ) -> Self {
    306         Self {
    307             kind,
    308             source: Some(Box::new(source)),
    309         }
    310     }
    311 }
    312 
    313 impl fmt::Debug for InitializationCause {
    314     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    315         formatter
    316             .debug_struct("InitializationCause")
    317             .field("kind", &self.kind)
    318             .field("source", &self.source.as_ref().map(|_| "[redacted]"))
    319             .finish()
    320     }
    321 }
    322 
    323 impl fmt::Display for InitializationCause {
    324     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    325         formatter.write_str(match self.kind {
    326             InitializationFailureKind::UnsupportedMode => {
    327                 "SQLite initialization requires initialize mode"
    328             }
    329             #[cfg(any(target_os = "linux", target_os = "macos"))]
    330             InitializationFailureKind::StateAlreadyExists => "SQLite state already exists",
    331             InitializationFailureKind::CreateUnavailable => "SQLite state could not be reserved",
    332             #[cfg(any(target_os = "linux", target_os = "macos"))]
    333             InitializationFailureKind::InvalidDatabase => "SQLite state file has invalid metadata",
    334             #[cfg(any(target_os = "linux", target_os = "macos"))]
    335             InitializationFailureKind::SchemaInitializationFailed => {
    336                 "SQLite schema initialization failed"
    337             }
    338             #[cfg(any(target_os = "linux", target_os = "macos"))]
    339             InitializationFailureKind::DatabaseSyncFailed => {
    340                 "SQLite state could not be synchronized"
    341             }
    342             #[cfg(any(target_os = "linux", target_os = "macos"))]
    343             InitializationFailureKind::DatabaseReplaced => {
    344                 "SQLite state identity changed during initialization"
    345             }
    346             #[cfg(any(target_os = "linux", target_os = "macos"))]
    347             InitializationFailureKind::DirectorySyncFailed => {
    348                 "SQLite state directory could not be synchronized"
    349             }
    350             #[cfg(any(target_os = "linux", target_os = "macos"))]
    351             InitializationFailureKind::CleanupFailed => "SQLite initialization cleanup failed",
    352             #[cfg(any(target_os = "linux", target_os = "macos"))]
    353             InitializationFailureKind::InjectedFailure => {
    354                 "SQLite initialization durability boundary failed"
    355             }
    356         })
    357     }
    358 }
    359 
    360 impl Error for InitializationCause {
    361     fn source(&self) -> Option<&(dyn Error + 'static)> {
    362         self.source
    363             .as_deref()
    364             .map(|source| source as &(dyn Error + 'static))
    365     }
    366 }
    367 
    368 fn initialization_error(cause: InitializationCause) -> ServiceSqliteError {
    369     ServiceSqliteError::with_source(ServiceSqliteErrorKind::Create, cause)
    370 }
    371 
    372 #[cfg(any(test, target_os = "linux", target_os = "macos"))]
    373 fn require_initialization_condition(
    374     condition: bool,
    375     kind: InitializationFailureKind,
    376 ) -> Result<(), InitializationCause> {
    377     condition
    378         .then_some(())
    379         .ok_or_else(|| InitializationCause::new(kind))
    380 }
    381 
    382 #[cfg(test)]
    383 mod failure_tests {
    384 
    385     use super::*;
    386 
    387     #[test]
    388     fn initialization_failure_inventory_is_complete_and_source_aware() {
    389         let cases = [
    390             (
    391                 InitializationFailureKind::UnsupportedMode,
    392                 "SQLite initialization requires initialize mode",
    393             ),
    394             (
    395                 InitializationFailureKind::CreateUnavailable,
    396                 "SQLite state could not be reserved",
    397             ),
    398         ]
    399         .into_iter();
    400         #[cfg(any(target_os = "linux", target_os = "macos"))]
    401         let cases = cases.chain([
    402             (
    403                 InitializationFailureKind::StateAlreadyExists,
    404                 "SQLite state already exists",
    405             ),
    406             (
    407                 InitializationFailureKind::InvalidDatabase,
    408                 "SQLite state file has invalid metadata",
    409             ),
    410             (
    411                 InitializationFailureKind::SchemaInitializationFailed,
    412                 "SQLite schema initialization failed",
    413             ),
    414             (
    415                 InitializationFailureKind::DatabaseSyncFailed,
    416                 "SQLite state could not be synchronized",
    417             ),
    418             (
    419                 InitializationFailureKind::DatabaseReplaced,
    420                 "SQLite state identity changed during initialization",
    421             ),
    422             (
    423                 InitializationFailureKind::DirectorySyncFailed,
    424                 "SQLite state directory could not be synchronized",
    425             ),
    426             (
    427                 InitializationFailureKind::CleanupFailed,
    428                 "SQLite initialization cleanup failed",
    429             ),
    430             (
    431                 InitializationFailureKind::InjectedFailure,
    432                 "SQLite initialization durability boundary failed",
    433             ),
    434         ]);
    435 
    436         for (kind, message) in cases {
    437             let plain = InitializationCause::new(kind);
    438             assert_eq!(plain.to_string(), message);
    439             assert!(plain.source().is_none());
    440             assert!(format!("{plain:?}").contains("source: None"));
    441             assert!(require_initialization_condition(true, kind).is_ok());
    442             assert_eq!(
    443                 require_initialization_condition(false, kind)
    444                     .expect_err("false condition")
    445                     .kind,
    446                 kind
    447             );
    448 
    449             #[cfg(any(target_os = "linux", target_os = "macos"))]
    450             {
    451                 let sourced =
    452                     InitializationCause::with_source(kind, std::io::Error::other("private-cause"));
    453                 assert_eq!(sourced.to_string(), message);
    454                 assert!(sourced.source().is_some());
    455                 let debug = format!("{sourced:?}");
    456                 assert!(debug.contains("[redacted]"));
    457                 assert!(!debug.contains("private-cause"));
    458             }
    459         }
    460     }
    461 }
    462 
    463 #[cfg(any(target_os = "linux", target_os = "macos"))]
    464 mod supported {
    465     use std::{fs::File, os::fd::AsRawFd};
    466 
    467     use rustix::{
    468         fs::{AtFlags, FileType, Mode, OFlags, fchmod, fstat, lstat, openat, statat, unlinkat},
    469         process::geteuid,
    470     };
    471 
    472     use super::*;
    473 
    474     #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    475     struct FileIdentity {
    476         device: u64,
    477         inode: u64,
    478     }
    479 
    480     pub(super) trait InitializationOperations {
    481         fn sync_database(&self, database: &File) -> Result<(), InitializationCause>;
    482         fn sync_directory(&self, directory: &File) -> Result<(), InitializationCause>;
    483         fn unlink_database(&self, directory: &File) -> Result<(), InitializationCause>;
    484     }
    485 
    486     pub(super) struct SystemInitializationOperations;
    487 
    488     impl InitializationOperations for SystemInitializationOperations {
    489         #[cfg_attr(coverage_nightly, coverage(off))]
    490         fn sync_database(&self, database: &File) -> Result<(), InitializationCause> {
    491             database.sync_all().map_err(|_| {
    492                 InitializationCause::new(InitializationFailureKind::DatabaseSyncFailed)
    493             })
    494         }
    495 
    496         #[cfg_attr(coverage_nightly, coverage(off))]
    497         fn sync_directory(&self, directory: &File) -> Result<(), InitializationCause> {
    498             directory.sync_all().map_err(|_| {
    499                 InitializationCause::new(InitializationFailureKind::DirectorySyncFailed)
    500             })
    501         }
    502 
    503         #[cfg_attr(coverage_nightly, coverage(off))]
    504         fn unlink_database(&self, directory: &File) -> Result<(), InitializationCause> {
    505             unlinkat(
    506                 directory,
    507                 radroots_runtime_paths::SERVICE_STATE_DATABASE_FILE_NAME,
    508                 AtFlags::empty(),
    509             )
    510             .map_err(|_| InitializationCause::new(InitializationFailureKind::CleanupFailed))
    511         }
    512     }
    513 
    514     struct PendingDatabase<'a, O: InitializationOperations> {
    515         directory: &'a File,
    516         database: File,
    517         identity: FileIdentity,
    518         operations: &'a O,
    519         committed: bool,
    520     }
    521 
    522     impl<'a, O: InitializationOperations> PendingDatabase<'a, O> {
    523         fn create(directory: &'a File, operations: &'a O) -> Result<Self, InitializationCause> {
    524             let descriptor = openat(
    525                 directory,
    526                 radroots_runtime_paths::SERVICE_STATE_DATABASE_FILE_NAME,
    527                 OFlags::RDWR | OFlags::CREATE | OFlags::EXCL | OFlags::NOFOLLOW | OFlags::CLOEXEC,
    528                 Mode::RUSR | Mode::WUSR,
    529             )
    530             .map_err(|error| {
    531                 if error == rustix::io::Errno::EXIST {
    532                     InitializationCause::new(InitializationFailureKind::StateAlreadyExists)
    533                 } else {
    534                     InitializationCause::new(InitializationFailureKind::CreateUnavailable)
    535                 }
    536             })?;
    537             let database = File::from(descriptor);
    538             let identity = descriptor_identity(&database)?;
    539             let pending = Self {
    540                 directory,
    541                 database,
    542                 identity,
    543                 operations,
    544                 committed: false,
    545             };
    546             fchmod(&pending.database, Mode::RUSR | Mode::WUSR).map_err(|_| {
    547                 InitializationCause::new(InitializationFailureKind::InvalidDatabase)
    548             })?;
    549             pending.validate()?;
    550             Ok(pending)
    551         }
    552 
    553         fn validate(&self) -> Result<(), InitializationCause> {
    554             let descriptor_identity = validate_descriptor(&self.database)?;
    555             require_initialization_condition(
    556                 descriptor_identity == self.identity,
    557                 InitializationFailureKind::InvalidDatabase,
    558             )?;
    559             self.validate_entry()
    560         }
    561 
    562         fn sqlite_descriptor_path(&self) -> String {
    563             let descriptor = self.database.as_raw_fd();
    564             #[cfg(target_os = "linux")]
    565             let path = format!("/proc/self/fd/{descriptor}");
    566             #[cfg(target_os = "macos")]
    567             let path = format!("/dev/fd/{descriptor}");
    568             path
    569         }
    570 
    571         fn validate_entry(&self) -> Result<(), InitializationCause> {
    572             let status = statat(
    573                 self.directory,
    574                 radroots_runtime_paths::SERVICE_STATE_DATABASE_FILE_NAME,
    575                 AtFlags::SYMLINK_NOFOLLOW,
    576             )
    577             .map_err(|_| InitializationCause::new(InitializationFailureKind::DatabaseReplaced))?;
    578             let device = crate::native_metadata::device(status.st_dev).map_err(|_| {
    579                 InitializationCause::new(InitializationFailureKind::InvalidDatabase)
    580             })?;
    581             let current = validate_status(
    582                 FileType::from_raw_mode(status.st_mode).is_file(),
    583                 crate::native_metadata::link_count(status.st_nlink),
    584                 status.st_uid,
    585                 crate::native_metadata::mode(status.st_mode),
    586                 device,
    587                 status.st_ino,
    588             )?;
    589             require_initialization_condition(
    590                 current == self.identity,
    591                 InitializationFailureKind::DatabaseReplaced,
    592             )?;
    593             Ok(())
    594         }
    595 
    596         fn current_entry_identity(&self) -> Result<FileIdentity, InitializationCause> {
    597             let status = statat(
    598                 self.directory,
    599                 radroots_runtime_paths::SERVICE_STATE_DATABASE_FILE_NAME,
    600                 AtFlags::SYMLINK_NOFOLLOW,
    601             )
    602             .map_err(|_| InitializationCause::new(InitializationFailureKind::DatabaseReplaced))?;
    603             let device = crate::native_metadata::device(status.st_dev).map_err(|_| {
    604                 InitializationCause::new(InitializationFailureKind::DatabaseReplaced)
    605             })?;
    606             Ok(FileIdentity {
    607                 device,
    608                 inode: status.st_ino,
    609             })
    610         }
    611 
    612         fn validate_canonical_path(
    613             &self,
    614             path: &std::path::Path,
    615         ) -> Result<(), InitializationCause> {
    616             let status = lstat(path).map_err(|_| {
    617                 InitializationCause::new(InitializationFailureKind::DatabaseReplaced)
    618             })?;
    619             let device = crate::native_metadata::device(status.st_dev).map_err(|_| {
    620                 InitializationCause::new(InitializationFailureKind::InvalidDatabase)
    621             })?;
    622             let current = validate_status(
    623                 FileType::from_raw_mode(status.st_mode).is_file(),
    624                 crate::native_metadata::link_count(status.st_nlink),
    625                 status.st_uid,
    626                 crate::native_metadata::mode(status.st_mode),
    627                 device,
    628                 status.st_ino,
    629             )?;
    630             require_initialization_condition(
    631                 current == self.identity,
    632                 InitializationFailureKind::DatabaseReplaced,
    633             )?;
    634             Ok(())
    635         }
    636 
    637         fn commit(
    638             &mut self,
    639             canonical_path: &std::path::Path,
    640             failpoints: &crate::failpoint::DurabilityFailpoints,
    641         ) -> Result<(), InitializationCause> {
    642             hit(
    643                 failpoints,
    644                 crate::failpoint::DurabilityFailpoint::InitializeBeforeFileSync,
    645             )?;
    646             self.operations.sync_database(&self.database)?;
    647             hit(
    648                 failpoints,
    649                 crate::failpoint::DurabilityFailpoint::InitializeAfterFileSync,
    650             )?;
    651             self.validate()?;
    652             self.validate_canonical_path(canonical_path)?;
    653             hit(
    654                 failpoints,
    655                 crate::failpoint::DurabilityFailpoint::InitializeBeforeCommitDirectorySync,
    656             )?;
    657             self.operations.sync_directory(self.directory)?;
    658             hit(
    659                 failpoints,
    660                 crate::failpoint::DurabilityFailpoint::InitializeAfterCommitDirectorySync,
    661             )?;
    662             self.committed = true;
    663             Ok(())
    664         }
    665 
    666         fn rollback(&mut self) -> Result<(), InitializationCause> {
    667             if self.committed {
    668                 return Ok(());
    669             }
    670             require_initialization_condition(
    671                 self.current_entry_identity()? == self.identity,
    672                 InitializationFailureKind::DatabaseReplaced,
    673             )?;
    674             self.operations.unlink_database(self.directory)?;
    675             self.operations.sync_directory(self.directory)?;
    676             self.committed = true;
    677             Ok(())
    678         }
    679     }
    680 
    681     impl<O: InitializationOperations> Drop for PendingDatabase<'_, O> {
    682         fn drop(&mut self) {
    683             let _ = self.rollback();
    684         }
    685     }
    686 
    687     fn validate_descriptor(
    688         descriptor: &impl std::os::fd::AsFd,
    689     ) -> Result<FileIdentity, InitializationCause> {
    690         let status = fstat(descriptor)
    691             .map_err(|_| InitializationCause::new(InitializationFailureKind::InvalidDatabase))?;
    692         let device = crate::native_metadata::device(status.st_dev)
    693             .map_err(|_| InitializationCause::new(InitializationFailureKind::InvalidDatabase))?;
    694         validate_status(
    695             FileType::from_raw_mode(status.st_mode).is_file(),
    696             crate::native_metadata::link_count(status.st_nlink),
    697             status.st_uid,
    698             crate::native_metadata::mode(status.st_mode),
    699             device,
    700             status.st_ino,
    701         )
    702     }
    703 
    704     fn descriptor_identity(
    705         descriptor: &impl std::os::fd::AsFd,
    706     ) -> Result<FileIdentity, InitializationCause> {
    707         let status = fstat(descriptor)
    708             .map_err(|_| InitializationCause::new(InitializationFailureKind::InvalidDatabase))?;
    709         let device = crate::native_metadata::device(status.st_dev)
    710             .map_err(|_| InitializationCause::new(InitializationFailureKind::InvalidDatabase))?;
    711         Ok(FileIdentity {
    712             device,
    713             inode: status.st_ino,
    714         })
    715     }
    716 
    717     fn validate_status(
    718         is_regular_file: bool,
    719         link_count: u64,
    720         actual_uid: u32,
    721         mode: u32,
    722         device: u64,
    723         inode: u64,
    724     ) -> Result<FileIdentity, InitializationCause> {
    725         require_initialization_condition(
    726             crate::native_metadata::exact_regular_file(
    727                 is_regular_file,
    728                 link_count,
    729                 actual_uid,
    730                 geteuid().as_raw(),
    731                 mode,
    732             ),
    733             InitializationFailureKind::InvalidDatabase,
    734         )?;
    735         Ok(FileIdentity { device, inode })
    736     }
    737 
    738     fn rollback_failure(
    739         primary: InitializationCause,
    740         cleanup: Result<(), InitializationCause>,
    741     ) -> ServiceSqliteError {
    742         match cleanup {
    743             Ok(()) => initialization_error(primary),
    744             Err(_cleanup) if primary.kind == InitializationFailureKind::DatabaseReplaced => {
    745                 initialization_error(primary)
    746             }
    747             Err(cleanup) => {
    748                 initialization_error(InitializationCause::with_source(cleanup.kind, primary))
    749             }
    750         }
    751     }
    752 
    753     async fn fail_with_rollback<O: InitializationOperations>(
    754         mut pending: PendingDatabase<'_, O>,
    755         primary: InitializationCause,
    756     ) -> Result<InitializeDatabaseOutcome, ServiceSqliteError> {
    757         Err(rollback_failure(primary, pending.rollback()))
    758     }
    759 
    760     async fn fail_metadata_with_rollback<O: InitializationOperations>(
    761         mut pending: PendingDatabase<'_, O>,
    762         primary: ServiceSqliteError,
    763     ) -> Result<InitializeDatabaseOutcome, ServiceSqliteError> {
    764         match pending.rollback() {
    765             Ok(()) => Err(primary),
    766             Err(cleanup) => Err(initialization_error(InitializationCause::with_source(
    767                 cleanup.kind,
    768                 primary,
    769             ))),
    770         }
    771     }
    772 
    773     pub(super) async fn initialize_with_ops<F, E, O>(
    774         paths: &ServiceSqlitePaths,
    775         authority: WriterAuthority,
    776         metadata: &ServiceDatabaseMetadata,
    777         schema_catalog: &SchemaCatalog,
    778         initialize_schema: F,
    779         operations: &O,
    780         failpoints: &crate::failpoint::DurabilityFailpoints,
    781     ) -> Result<InitializeDatabaseOutcome, ServiceSqliteError>
    782     where
    783         F: for<'a> FnOnce(
    784             &'a mut ServiceSqliteInitializer<'_>,
    785         ) -> ServiceSqliteInitializerFuture<'a, E>,
    786         E: Error + Send + Sync + 'static,
    787         O: InitializationOperations,
    788     {
    789         hit(
    790             failpoints,
    791             crate::failpoint::DurabilityFailpoint::InitializeBeforeCreate,
    792         )
    793         .map_err(initialization_error)?;
    794         let initialization_directory = authority.directory().try_clone().map_err(|source| {
    795             initialization_error(InitializationCause::with_source(
    796                 InitializationFailureKind::CreateUnavailable,
    797                 source,
    798             ))
    799         })?;
    800         let mut pending = match PendingDatabase::create(&initialization_directory, operations) {
    801             Ok(pending) => pending,
    802             Err(error) if error.kind == InitializationFailureKind::StateAlreadyExists => {
    803                 return Ok(InitializeDatabaseOutcome::Existing(authority));
    804             }
    805             Err(error) => return Err(initialization_error(error)),
    806         };
    807         if let Err(error) = hit(
    808             failpoints,
    809             crate::failpoint::DurabilityFailpoint::InitializeAfterCreate,
    810         ) {
    811             return fail_with_rollback(pending, error).await;
    812         }
    813         if let Err(error) = hit(
    814             failpoints,
    815             crate::failpoint::DurabilityFailpoint::InitializeBeforeReservationDirectorySync,
    816         ) {
    817             return fail_with_rollback(pending, error).await;
    818         }
    819         if let Err(error) = operations.sync_directory(authority.directory()) {
    820             return fail_with_rollback(pending, error).await;
    821         }
    822         if let Err(error) = hit(
    823             failpoints,
    824             crate::failpoint::DurabilityFailpoint::InitializeAfterReservationDirectorySync,
    825         ) {
    826             return fail_with_rollback(pending, error).await;
    827         }
    828         authority.validate_for(paths)?;
    829         let recovery = crate::restore::refuse_unresolved_recovery(authority.directory());
    830         authority.validate_for(paths)?;
    831         if let Err(error) = recovery {
    832             return fail_metadata_with_rollback(pending, error).await;
    833         }
    834         if let Err(error) = pending.validate_canonical_path(paths.state_database()) {
    835             return fail_with_rollback(pending, error).await;
    836         }
    837         let metadata_result = initialize_transaction(
    838             paths,
    839             &authority,
    840             &pending,
    841             metadata,
    842             schema_catalog,
    843             initialize_schema,
    844         )
    845         .await;
    846         authority.validate_for(paths)?;
    847         if let Err(error) = pending.validate() {
    848             return fail_with_rollback(pending, error).await;
    849         }
    850         if let Err(error) = pending.validate_canonical_path(paths.state_database()) {
    851             return fail_with_rollback(pending, error).await;
    852         }
    853         if let Err(error) = metadata_result {
    854             return fail_metadata_with_rollback(pending, error).await;
    855         }
    856         if let Err(error) = pending.validate() {
    857             return fail_with_rollback(pending, error).await;
    858         }
    859         if let Err(error) = pending.validate_canonical_path(paths.state_database()) {
    860             return fail_with_rollback(pending, error).await;
    861         }
    862         if let Err(error) = pending.commit(paths.state_database(), failpoints) {
    863             return fail_with_rollback(pending, error).await;
    864         }
    865         drop(pending);
    866         Ok(InitializeDatabaseOutcome::Initialized(authority))
    867     }
    868 
    869     async fn initialize_transaction<F, E, O>(
    870         paths: &ServiceSqlitePaths,
    871         authority: &WriterAuthority,
    872         pending: &PendingDatabase<'_, O>,
    873         metadata: &ServiceDatabaseMetadata,
    874         schema_catalog: &SchemaCatalog,
    875         initialize_schema: F,
    876     ) -> Result<(), ServiceSqliteError>
    877     where
    878         F: for<'a> FnOnce(
    879             &'a mut ServiceSqliteInitializer<'_>,
    880         ) -> ServiceSqliteInitializerFuture<'a, E>,
    881         E: Error + Send + Sync + 'static,
    882         O: InitializationOperations,
    883     {
    884         use sqlx::{
    885             ConnectOptions, Connection,
    886             sqlite::{SqliteConnectOptions, SqliteJournalMode},
    887         };
    888 
    889         authority.validate_for(paths)?;
    890         pending
    891             .validate()
    892             .and_then(|()| pending.validate_canonical_path(paths.state_database()))
    893             .map_err(initialization_error)?;
    894         let options = SqliteConnectOptions::new()
    895             .filename(pending.sqlite_descriptor_path())
    896             .create_if_missing(false)
    897             .foreign_keys(true)
    898             .journal_mode(SqliteJournalMode::Memory)
    899             .pragma("trusted_schema", "OFF")
    900             .disable_statement_logging();
    901         let connected = SqliteConnection::connect_with(&options).await;
    902         authority.validate_for(paths)?;
    903         pending
    904             .validate()
    905             .and_then(|()| pending.validate_canonical_path(paths.state_database()))
    906             .map_err(initialization_error)?;
    907         let mut connection = connected.map_err(|source| {
    908             initialization_error(InitializationCause::with_source(
    909                 InitializationFailureKind::SchemaInitializationFailed,
    910                 source,
    911             ))
    912         })?;
    913         let installed =
    914             crate::transaction_control::TransactionControlGate::install(&mut connection).await;
    915         authority.validate_for(paths)?;
    916         pending
    917             .validate()
    918             .and_then(|()| pending.validate_canonical_path(paths.state_database()))
    919             .map_err(initialization_error)?;
    920         let gate = installed.map_err(|source| {
    921             initialization_error(InitializationCause::with_source(
    922                 InitializationFailureKind::SchemaInitializationFailed,
    923                 source,
    924             ))
    925         })?;
    926         let begun = connection.begin_with("BEGIN IMMEDIATE").await;
    927         authority.validate_for(paths)?;
    928         pending
    929             .validate()
    930             .and_then(|()| pending.validate_canonical_path(paths.state_database()))
    931             .map_err(initialization_error)?;
    932         let mut transaction = begun.map_err(|source| {
    933             initialization_error(InitializationCause::with_source(
    934                 InitializationFailureKind::SchemaInitializationFailed,
    935                 source,
    936             ))
    937         })?;
    938 
    939         let statement_control_rejected = Arc::new(AtomicBool::new(false));
    940         let callback = {
    941             let mut initializer = ServiceSqliteInitializer {
    942                 connection: &mut transaction,
    943                 statement_control_rejected: Arc::clone(&statement_control_rejected),
    944             };
    945             initialize_schema(&mut initializer).await
    946         };
    947         authority.validate_for(paths)?;
    948         pending
    949             .validate()
    950             .and_then(|()| pending.validate_canonical_path(paths.state_database()))
    951             .map_err(initialization_error)?;
    952         let governed_after_callback =
    953             crate::migration::assert_governed_transaction(&mut transaction)
    954                 .await
    955                 .is_ok();
    956         authority.validate_for(paths)?;
    957 
    958         let operation = match callback {
    959             Ok(())
    960                 if !statement_control_rejected.load(Ordering::Acquire)
    961                     && !gate.control_violation_observed()
    962                     && governed_after_callback =>
    963             {
    964                 crate::metadata::write_database_metadata_in_transaction(
    965                     &mut transaction,
    966                     metadata,
    967                     schema_catalog,
    968                 )
    969                 .await
    970             }
    971             Ok(()) => Err(initialization_error(InitializationCause::new(
    972                 InitializationFailureKind::SchemaInitializationFailed,
    973             ))),
    974             Err(source) => Err(initialization_error(InitializationCause::with_source(
    975                 InitializationFailureKind::SchemaInitializationFailed,
    976                 source,
    977             ))),
    978         };
    979         authority.validate_for(paths)?;
    980         pending
    981             .validate()
    982             .and_then(|()| pending.validate_canonical_path(paths.state_database()))
    983             .map_err(initialization_error)?;
    984         let governed_before_commit =
    985             crate::migration::assert_governed_transaction(&mut transaction)
    986                 .await
    987                 .is_ok();
    988         authority.validate_for(paths)?;
    989 
    990         if let Err(primary) = operation {
    991             let permit = gate.permit_runner_rollback();
    992             let rollback = transaction.rollback().await;
    993             drop(permit);
    994             authority.validate_for(paths)?;
    995             pending
    996                 .validate()
    997                 .and_then(|()| pending.validate_canonical_path(paths.state_database()))
    998                 .map_err(initialization_error)?;
    999             let remove = gate.remove(&mut connection).await;
   1000             authority.validate_for(paths)?;
   1001             let close = connection.close().await;
   1002             authority.validate_for(paths)?;
   1003             if let Err(source) = rollback.and(remove).and(close) {
   1004                 return Err(initialization_error(InitializationCause::with_source(
   1005                     InitializationFailureKind::SchemaInitializationFailed,
   1006                     source,
   1007                 )));
   1008             }
   1009             return Err(primary);
   1010         }
   1011 
   1012         if gate.control_violation_observed() || !governed_before_commit {
   1013             let permit = gate.permit_runner_rollback();
   1014             let rollback = transaction.rollback().await;
   1015             drop(permit);
   1016             let remove = gate.remove(&mut connection).await;
   1017             let close = connection.close().await;
   1018             authority.validate_for(paths)?;
   1019             rollback.and(remove).and(close).map_err(|source| {
   1020                 initialization_error(InitializationCause::with_source(
   1021                     InitializationFailureKind::SchemaInitializationFailed,
   1022                     source,
   1023                 ))
   1024             })?;
   1025             return Err(initialization_error(InitializationCause::new(
   1026                 InitializationFailureKind::SchemaInitializationFailed,
   1027             )));
   1028         }
   1029 
   1030         let permit = gate.permit_outer_commit();
   1031         let committed = transaction.commit().await;
   1032         drop(permit);
   1033         authority.validate_for(paths)?;
   1034         pending
   1035             .validate()
   1036             .and_then(|()| pending.validate_canonical_path(paths.state_database()))
   1037             .map_err(initialization_error)?;
   1038         let removed = gate.remove(&mut connection).await;
   1039         authority.validate_for(paths)?;
   1040         let closed = connection.close().await;
   1041         authority.validate_for(paths)?;
   1042         committed.and(removed).and(closed).map_err(|source| {
   1043             initialization_error(InitializationCause::with_source(
   1044                 InitializationFailureKind::SchemaInitializationFailed,
   1045                 source,
   1046             ))
   1047         })
   1048     }
   1049 
   1050     fn hit(
   1051         failpoints: &crate::failpoint::DurabilityFailpoints,
   1052         point: crate::failpoint::DurabilityFailpoint,
   1053     ) -> Result<(), InitializationCause> {
   1054         failpoints.hit(point).map_err(|source| {
   1055             InitializationCause::with_source(InitializationFailureKind::InjectedFailure, source)
   1056         })
   1057     }
   1058 
   1059     #[cfg(test)]
   1060     mod tests {
   1061         use std::{
   1062             cell::{Cell, RefCell},
   1063             convert::Infallible,
   1064             fs,
   1065             future::{pending, ready},
   1066             io,
   1067             num::NonZeroU32,
   1068             os::unix::fs::{MetadataExt, PermissionsExt, symlink},
   1069             path::Path,
   1070             sync::Arc,
   1071         };
   1072 
   1073         use radroots_runtime_paths::{
   1074             InstanceId, RadrootsHostEnvironment, RadrootsPathProfile, RadrootsPathResolver,
   1075             RadrootsPlatform, RuntimeContext, RuntimeContextBootstrap, RuntimeContextSource,
   1076             ServiceId,
   1077         };
   1078         use radroots_storage::event::SourceGeneration;
   1079         use tokio::sync::Notify;
   1080 
   1081         use super::*;
   1082 
   1083         #[derive(Debug)]
   1084         struct CallbackFailure;
   1085 
   1086         impl fmt::Display for CallbackFailure {
   1087             fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
   1088                 formatter.write_str("secret callback path=/private/state.sqlite")
   1089             }
   1090         }
   1091 
   1092         impl Error for CallbackFailure {}
   1093 
   1094         #[derive(Default)]
   1095         struct RecordingOperations {
   1096             events: RefCell<Vec<&'static str>>,
   1097             fail_database_sync: Cell<bool>,
   1098             fail_directory_sync_on_call: Cell<Option<usize>>,
   1099             directory_sync_calls: Cell<usize>,
   1100             fail_unlink: Cell<bool>,
   1101         }
   1102 
   1103         impl InitializationOperations for RecordingOperations {
   1104             fn sync_database(&self, _database: &File) -> Result<(), InitializationCause> {
   1105                 self.events.borrow_mut().push("sync_database");
   1106                 if self.fail_database_sync.replace(false) {
   1107                     Err(InitializationCause::new(
   1108                         InitializationFailureKind::DatabaseSyncFailed,
   1109                     ))
   1110                 } else {
   1111                     Ok(())
   1112                 }
   1113             }
   1114 
   1115             fn sync_directory(&self, _directory: &File) -> Result<(), InitializationCause> {
   1116                 self.events.borrow_mut().push("sync_directory");
   1117                 let call = self.directory_sync_calls.get() + 1;
   1118                 self.directory_sync_calls.set(call);
   1119                 if self.fail_directory_sync_on_call.get() == Some(call) {
   1120                     Err(InitializationCause::new(
   1121                         InitializationFailureKind::DirectorySyncFailed,
   1122                     ))
   1123                 } else {
   1124                     Ok(())
   1125                 }
   1126             }
   1127 
   1128             fn unlink_database(&self, directory: &File) -> Result<(), InitializationCause> {
   1129                 self.events.borrow_mut().push("unlink_database");
   1130                 if self.fail_unlink.get() {
   1131                     return Err(InitializationCause::new(
   1132                         InitializationFailureKind::CleanupFailed,
   1133                     ));
   1134                 }
   1135                 SystemInitializationOperations.unlink_database(directory)
   1136             }
   1137         }
   1138 
   1139         fn paths(root: &Path, instance: &str) -> ServiceSqlitePaths {
   1140             let context = RuntimeContext::resolve(
   1141                 &RadrootsPathResolver::new(
   1142                     RadrootsPlatform::Linux,
   1143                     RadrootsHostEnvironment::default(),
   1144                 ),
   1145                 RuntimeContextBootstrap::new(
   1146                     RadrootsPathProfile::RepoLocal,
   1147                     Some(root.to_path_buf()),
   1148                     RuntimeContextSource::BootstrapCli,
   1149                     RuntimeContextSource::BootstrapCli,
   1150                 )
   1151                 .expect("bootstrap"),
   1152                 ServiceId::new("myc").expect("service"),
   1153                 InstanceId::new(instance).expect("instance"),
   1154             )
   1155             .expect("runtime context");
   1156             ServiceSqlitePaths::from_runtime_context(&context).expect("SQLite paths")
   1157         }
   1158 
   1159         fn prepare(paths: &ServiceSqlitePaths) {
   1160             fs::create_dir_all(paths.state_database().parent().expect("state directory"))
   1161                 .expect("create state directory");
   1162         }
   1163 
   1164         fn metadata(paths: &ServiceSqlitePaths) -> ServiceDatabaseMetadata {
   1165             ServiceDatabaseMetadata::new(
   1166                 paths,
   1167                 SourceGeneration::new([7; 32]).expect("source generation"),
   1168                 NonZeroU32::new(1).expect("schema version"),
   1169                 1_700_000_000_000,
   1170                 crate::ServiceSqliteApplicationId::new(0x5244_5351).expect("application ID"),
   1171             )
   1172             .expect("database metadata")
   1173         }
   1174 
   1175         fn schema_catalog(service_objects: Vec<crate::SchemaObject>) -> crate::SchemaCatalog {
   1176             let migrations = crate::MigrationCatalog::new([]).expect("empty migrations");
   1177             let digest =
   1178                 crate::SchemaVersionCatalog::computed_digest(1, service_objects.iter().cloned())
   1179                     .expect("schema digest");
   1180             let version = crate::SchemaVersionCatalog::new(1, service_objects, digest)
   1181                 .expect("schema version");
   1182             crate::SchemaCatalog::new(&migrations, [version]).expect("schema catalog")
   1183         }
   1184 
   1185         fn base_schema_catalog() -> crate::SchemaCatalog {
   1186             schema_catalog(Vec::new())
   1187         }
   1188 
   1189         fn service_schema_catalog() -> crate::SchemaCatalog {
   1190             const SQL: &str = "CREATE TABLE service_schema (id INTEGER PRIMARY KEY)";
   1191             let object = crate::SchemaObject::new(
   1192                 crate::SchemaObjectKind::Table,
   1193                 "service_schema",
   1194                 "service_schema",
   1195                 SQL,
   1196                 crate::SchemaObject::computed_digest(
   1197                     crate::SchemaObjectKind::Table,
   1198                     "service_schema",
   1199                     "service_schema",
   1200                     SQL,
   1201                 )
   1202                 .expect("service schema digest"),
   1203             )
   1204             .expect("service schema object");
   1205             schema_catalog(vec![object])
   1206         }
   1207 
   1208         #[tokio::test(flavor = "current_thread")]
   1209         async fn successful_initialization_is_create_new_mode_0600_and_retains_authority() {
   1210             let root = tempfile::tempdir().expect("root");
   1211             let paths = paths(root.path(), "success");
   1212             prepare(&paths);
   1213             let metadata = metadata(&paths);
   1214             let schema_catalog = service_schema_catalog();
   1215             let mut authority = initialize_database(
   1216                 &paths,
   1217                 OpenMode::Initialize,
   1218                 &metadata,
   1219                 &schema_catalog,
   1220                 |initializer| {
   1221                     Box::pin(async move {
   1222                         assert_eq!(
   1223                             format!("{initializer:?}"),
   1224                             "ServiceSqliteInitializer([redacted])"
   1225                         );
   1226                         sqlx::query("CREATE TABLE service_schema (id INTEGER PRIMARY KEY)")
   1227                             .execute(initializer)
   1228                             .await?;
   1229                         Ok::<(), sqlx::Error>(())
   1230                     })
   1231                 },
   1232             )
   1233             .await
   1234             .expect("initialize");
   1235 
   1236             let filesystem_metadata = fs::metadata(paths.state_database()).unwrap();
   1237             assert_eq!(filesystem_metadata.permissions().mode() & 0o777, 0o600);
   1238             assert_eq!(filesystem_metadata.nlink(), 1);
   1239             assert!(authority.is_held());
   1240             assert!(WriterAuthority::acquire(&paths, OpenMode::ReadWriteExisting).is_err());
   1241             authority.release().expect("release");
   1242             assert!(
   1243                 WriterAuthority::acquire(&paths, OpenMode::ReadWriteExisting)
   1244                     .expect("reacquire")
   1245                     .is_some()
   1246             );
   1247         }
   1248 
   1249         #[tokio::test(flavor = "current_thread")]
   1250         async fn existing_regular_symlink_directory_and_hardlink_are_never_mutated() {
   1251             for shape in ["regular", "symlink", "directory", "hardlink"] {
   1252                 let root = tempfile::tempdir().expect("root");
   1253                 let paths = paths(root.path(), shape);
   1254                 prepare(&paths);
   1255                 let target = root.path().join("existing-target");
   1256                 fs::write(&target, b"preserve-me").expect("target");
   1257                 match shape {
   1258                     "regular" => fs::write(paths.state_database(), b"existing").unwrap(),
   1259                     "symlink" => symlink(&target, paths.state_database()).unwrap(),
   1260                     "directory" => fs::create_dir(paths.state_database()).unwrap(),
   1261                     "hardlink" => fs::hard_link(&target, paths.state_database()).unwrap(),
   1262                     _ => unreachable!(),
   1263                 }
   1264                 let called = Cell::new(false);
   1265                 let metadata = metadata(&paths);
   1266                 let schema_catalog = base_schema_catalog();
   1267                 let error = initialize_database(
   1268                     &paths,
   1269                     OpenMode::Initialize,
   1270                     &metadata,
   1271                     &schema_catalog,
   1272                     |_| {
   1273                         called.set(true);
   1274                         Box::pin(ready(Ok::<(), CallbackFailure>(())))
   1275                     },
   1276                 )
   1277                 .await
   1278                 .expect_err("existing state must fail");
   1279                 assert_eq!(error.kind(), ServiceSqliteErrorKind::Create);
   1280                 assert!(!called.get());
   1281                 assert_eq!(fs::read(&target).unwrap(), b"preserve-me");
   1282             }
   1283         }
   1284 
   1285         #[tokio::test(flavor = "current_thread")]
   1286         async fn non_initialize_modes_have_zero_callback_and_filesystem_effects() {
   1287             for mode in [OpenMode::ReadWriteExisting, OpenMode::ReadOnlyInspection] {
   1288                 let root = tempfile::tempdir().expect("root");
   1289                 let paths = paths(root.path(), "wrong-mode");
   1290                 let called = Cell::new(false);
   1291                 let metadata = metadata(&paths);
   1292                 let schema_catalog = base_schema_catalog();
   1293                 let error = initialize_database(&paths, mode, &metadata, &schema_catalog, |_| {
   1294                     called.set(true);
   1295                     Box::pin(ready(Ok::<(), CallbackFailure>(())))
   1296                 })
   1297                 .await
   1298                 .expect_err("mode must reject");
   1299                 assert_eq!(error.kind(), ServiceSqliteErrorKind::Create);
   1300                 assert!(!called.get());
   1301                 assert!(!paths.state_database().exists());
   1302                 assert!(!paths.state_lock().exists());
   1303                 assert!(!paths.state_database().parent().unwrap().exists());
   1304             }
   1305         }
   1306 
   1307         #[tokio::test(flavor = "current_thread")]
   1308         async fn mismatched_metadata_paths_have_zero_callback_and_filesystem_effects() {
   1309             let root = tempfile::tempdir().expect("root");
   1310             let expected_paths = paths(root.path(), "expected");
   1311             let other = paths(root.path(), "other");
   1312             let called = Cell::new(false);
   1313             let other_metadata = metadata(&other);
   1314             let error = initialize_database(
   1315                 &expected_paths,
   1316                 OpenMode::Initialize,
   1317                 &other_metadata,
   1318                 &base_schema_catalog(),
   1319                 |_| {
   1320                     called.set(true);
   1321                     Box::pin(ready(Ok::<(), CallbackFailure>(())))
   1322                 },
   1323             )
   1324             .await
   1325             .expect_err("metadata paths must reject");
   1326             assert_eq!(error.kind(), ServiceSqliteErrorKind::Metadata);
   1327             assert!(!called.get());
   1328             assert!(!expected_paths.state_database().exists());
   1329             assert!(!expected_paths.state_lock().exists());
   1330             let error = initialize_or_existing_database(
   1331                 &expected_paths,
   1332                 &other_metadata,
   1333                 &base_schema_catalog(),
   1334                 |_| {
   1335                     called.set(true);
   1336                     Box::pin(ready(Ok::<(), CallbackFailure>(())))
   1337                 },
   1338             )
   1339             .await
   1340             .expect_err("existing-or-new initialization must reject mismatched identity");
   1341             assert_eq!(error.kind(), ServiceSqliteErrorKind::Metadata);
   1342             assert!(!called.get());
   1343             assert!(!expected_paths.state_database().exists());
   1344             assert!(!expected_paths.state_lock().exists());
   1345         }
   1346 
   1347         #[tokio::test(flavor = "current_thread")]
   1348         async fn callback_failure_cleans_up_releases_authority_and_preserves_trusted_cause() {
   1349             let root = tempfile::tempdir().expect("root");
   1350             let paths = paths(root.path(), "callback-failure");
   1351             prepare(&paths);
   1352             let metadata = metadata(&paths);
   1353             let schema_catalog = base_schema_catalog();
   1354             let error = initialize_database(
   1355                 &paths,
   1356                 OpenMode::Initialize,
   1357                 &metadata,
   1358                 &schema_catalog,
   1359                 |_| Box::pin(ready(Err::<(), _>(CallbackFailure))),
   1360             )
   1361             .await
   1362             .expect_err("callback failure");
   1363             assert_eq!(error.kind(), ServiceSqliteErrorKind::Create);
   1364             assert!(!paths.state_database().exists());
   1365             assert!(
   1366                 WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1367                     .unwrap()
   1368                     .is_some()
   1369             );
   1370 
   1371             let display = error.to_string();
   1372             let debug = format!("{error:?}");
   1373             assert!(!display.contains("secret"));
   1374             assert!(!debug.contains("secret"));
   1375             let first = error.source().expect("initialization cause");
   1376             assert_eq!(first.to_string(), "SQLite schema initialization failed");
   1377             assert_eq!(
   1378                 first.source().map(ToString::to_string).as_deref(),
   1379                 Some("secret callback path=/private/state.sqlite")
   1380             );
   1381 
   1382             let retry = initialize_database(
   1383                 &paths,
   1384                 OpenMode::Initialize,
   1385                 &metadata,
   1386                 &schema_catalog,
   1387                 |_| Box::pin(ready(Ok::<(), CallbackFailure>(()))),
   1388             )
   1389             .await
   1390             .expect("retry after cleanup");
   1391             assert!(retry.is_held());
   1392             assert!(paths.state_database().exists());
   1393         }
   1394 
   1395         #[tokio::test(flavor = "current_thread")]
   1396         async fn deferred_foreign_key_commit_failure_is_reported_without_initialized_state() {
   1397             use sqlx::{Connection, sqlite::SqliteConnectOptions};
   1398 
   1399             const PARENT: &str = "CREATE TABLE initialization_parent (id INTEGER PRIMARY KEY)";
   1400             const CHILD: &str = "CREATE TABLE initialization_child (id INTEGER PRIMARY KEY, parent_id INTEGER NOT NULL REFERENCES initialization_parent(id) DEFERRABLE INITIALLY DEFERRED)";
   1401 
   1402             for valid_parent in [false, true] {
   1403                 let root = tempfile::tempdir().expect("root");
   1404                 let paths = paths(root.path(), "deferred-commit");
   1405                 prepare(&paths);
   1406                 let metadata = metadata(&paths);
   1407                 let objects = [
   1408                     ("initialization_parent", PARENT),
   1409                     ("initialization_child", CHILD),
   1410                 ]
   1411                 .into_iter()
   1412                 .map(|(name, sql)| {
   1413                     crate::SchemaObject::new(
   1414                         crate::SchemaObjectKind::Table,
   1415                         name,
   1416                         name,
   1417                         sql,
   1418                         crate::SchemaObject::computed_digest(
   1419                             crate::SchemaObjectKind::Table,
   1420                             name,
   1421                             name,
   1422                             sql,
   1423                         )
   1424                         .expect("schema object digest"),
   1425                     )
   1426                     .expect("schema object")
   1427                 })
   1428                 .collect();
   1429                 let result = initialize_database(
   1430                     &paths,
   1431                     OpenMode::Initialize,
   1432                     &metadata,
   1433                     &schema_catalog(objects),
   1434                     move |initializer| {
   1435                         Box::pin(async move {
   1436                             sqlx::query(PARENT).execute(&mut *initializer).await?;
   1437                             sqlx::query(CHILD).execute(&mut *initializer).await?;
   1438                             if valid_parent {
   1439                                 sqlx::query("INSERT INTO initialization_parent(id) VALUES (1)")
   1440                                     .execute(&mut *initializer)
   1441                                     .await?;
   1442                             }
   1443                             sqlx::query(
   1444                                 "INSERT INTO initialization_child(id, parent_id) VALUES (1, 1)",
   1445                             )
   1446                             .execute(&mut *initializer)
   1447                             .await?;
   1448                             Ok::<(), sqlx::Error>(())
   1449                         })
   1450                     },
   1451                 )
   1452                 .await;
   1453                 if valid_parent {
   1454                     let mut authority = result.expect("valid deferred foreign key commits");
   1455                     let mut connection = SqliteConnection::connect_with(
   1456                         &SqliteConnectOptions::new()
   1457                             .filename(paths.state_database())
   1458                             .read_only(true)
   1459                             .create_if_missing(false),
   1460                     )
   1461                     .await
   1462                     .expect("inspect initialized state");
   1463                     crate::metadata::verify_database_metadata(
   1464                         &mut connection,
   1465                         &metadata.identity(),
   1466                     )
   1467                     .await
   1468                     .expect("metadata committed with product state");
   1469                     assert_eq!(
   1470                         sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM initialization_child")
   1471                             .fetch_one(&mut connection)
   1472                             .await
   1473                             .expect("committed child"),
   1474                         1
   1475                     );
   1476                     connection.close().await.expect("close inspection");
   1477                     authority.release().expect("release initialized authority");
   1478                 } else {
   1479                     let error = result.expect_err("a failed commit cannot initialize state");
   1480                     assert_eq!(error.kind(), ServiceSqliteErrorKind::Create);
   1481                     let cause = error
   1482                         .source()
   1483                         .and_then(Error::source)
   1484                         .and_then(|source| source.downcast_ref::<sqlx::Error>())
   1485                         .expect("original SQLite commit error remains available");
   1486                     assert_eq!(
   1487                         cause
   1488                             .as_database_error()
   1489                             .and_then(|error| error.code())
   1490                             .as_deref(),
   1491                         Some("787")
   1492                     );
   1493                     assert!(!paths.state_database().exists());
   1494                     let mut authority = WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1495                         .expect("failed initialization releases authority")
   1496                         .expect("initialize authority");
   1497                     authority.release().expect("release reacquired authority");
   1498                 }
   1499             }
   1500         }
   1501 
   1502         #[tokio::test(flavor = "current_thread")]
   1503         async fn transaction_control_and_attachments_are_rejected_before_sqlite_compilation() {
   1504             for scenario in ["commit", "rollback_begin", "attach_detach"] {
   1505                 let root = tempfile::tempdir().expect("root");
   1506                 let paths = paths(root.path(), scenario);
   1507                 prepare(&paths);
   1508                 let external = root.path().join("must-not-exist.sqlite");
   1509                 let external_for_callback = external.clone();
   1510                 let metadata = metadata(&paths);
   1511                 let schema_catalog = base_schema_catalog();
   1512                 let error = initialize_database(
   1513                     &paths,
   1514                     OpenMode::Initialize,
   1515                     &metadata,
   1516                     &schema_catalog,
   1517                     move |initializer| {
   1518                         Box::pin(async move {
   1519                             let sql = match scenario {
   1520                                 "commit" => "COMMIT".to_owned(),
   1521                                 "rollback_begin" => {
   1522                                     "ROLLBACK; BEGIN DEFERRED; CREATE TABLE escaped(value INTEGER)"
   1523                                         .to_owned()
   1524                                 }
   1525                                 "attach_detach" => format!(
   1526                                     "ATTACH DATABASE '{}' AS extra; DETACH DATABASE extra",
   1527                                     external_for_callback.display()
   1528                                 ),
   1529                                 _ => unreachable!(),
   1530                             };
   1531                             let _ = sqlx::query(sqlx::AssertSqlSafe(sql.as_str()))
   1532                                 .execute(initializer)
   1533                                 .await;
   1534                             Ok::<(), Infallible>(())
   1535                         })
   1536                     },
   1537                 )
   1538                 .await
   1539                 .expect_err("forbidden statement control must fail initialization");
   1540                 assert_eq!(error.kind(), ServiceSqliteErrorKind::Create);
   1541                 for rendered in [error.to_string(), format!("{error:?}")] {
   1542                     assert!(!rendered.contains("must-not-exist"));
   1543                     assert!(!rendered.contains("ATTACH"));
   1544                     assert!(!rendered.contains("ROLLBACK"));
   1545                 }
   1546                 assert!(!paths.state_database().exists());
   1547                 assert!(!external.exists());
   1548                 assert!(
   1549                     WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1550                         .expect("reacquire")
   1551                         .is_some()
   1552                 );
   1553             }
   1554         }
   1555 
   1556         #[tokio::test(flavor = "current_thread")]
   1557         async fn metadata_or_migration_ledger_conflict_cleans_the_exact_reserved_database() {
   1558             let root = tempfile::tempdir().expect("root");
   1559             for (instance, statement, expected_kind) in [
   1560                 (
   1561                     "metadata-failure",
   1562                     "CREATE TABLE radroots_service_metadata (value TEXT)",
   1563                     ServiceSqliteErrorKind::Metadata,
   1564                 ),
   1565                 (
   1566                     "migration-ledger-failure",
   1567                     "CREATE TABLE schema_migrations (value TEXT)",
   1568                     ServiceSqliteErrorKind::Migration,
   1569                 ),
   1570             ] {
   1571                 let paths = paths(root.path(), instance);
   1572                 prepare(&paths);
   1573                 let metadata = metadata(&paths);
   1574                 let schema_catalog = base_schema_catalog();
   1575                 let error = initialize_database(
   1576                     &paths,
   1577                     OpenMode::Initialize,
   1578                     &metadata,
   1579                     &schema_catalog,
   1580                     move |initializer| {
   1581                         Box::pin(async move {
   1582                             sqlx::query(statement).execute(initializer).await?;
   1583                             Ok::<(), sqlx::Error>(())
   1584                         })
   1585                     },
   1586                 )
   1587                 .await
   1588                 .expect_err("conflicting governed table must fail");
   1589 
   1590                 assert_eq!(error.kind(), expected_kind);
   1591                 assert!(!paths.state_database().exists());
   1592                 assert!(
   1593                     WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1594                         .expect("reacquire")
   1595                         .is_some()
   1596                 );
   1597             }
   1598         }
   1599 
   1600         #[tokio::test(flavor = "current_thread")]
   1601         async fn schema_catalog_mismatch_cleans_the_exact_reserved_database() {
   1602             let root = tempfile::tempdir().expect("root");
   1603             let paths = paths(root.path(), "schema-mismatch");
   1604             prepare(&paths);
   1605             let metadata = metadata(&paths);
   1606             let schema_catalog = base_schema_catalog();
   1607             let error = initialize_database(
   1608                 &paths,
   1609                 OpenMode::Initialize,
   1610                 &metadata,
   1611                 &schema_catalog,
   1612                 |initializer| {
   1613                     Box::pin(async move {
   1614                         sqlx::query("CREATE TABLE unexpected (value INTEGER)")
   1615                             .execute(initializer)
   1616                             .await?;
   1617                         Ok::<(), sqlx::Error>(())
   1618                     })
   1619                 },
   1620             )
   1621             .await
   1622             .expect_err("unlisted schema object must fail initialization");
   1623             assert_eq!(error.kind(), ServiceSqliteErrorKind::Integrity);
   1624             assert!(!paths.state_database().exists());
   1625             assert!(
   1626                 WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1627                     .unwrap()
   1628                     .is_some()
   1629             );
   1630         }
   1631 
   1632         #[tokio::test(flavor = "current_thread")]
   1633         async fn cancellation_rolls_back_and_releases_authority() {
   1634             let root = tempfile::tempdir().expect("root");
   1635             let paths = paths(root.path(), "cancelled");
   1636             prepare(&paths);
   1637             let metadata = metadata(&paths);
   1638             let schema_catalog = base_schema_catalog();
   1639             let task_paths = paths.clone();
   1640             let reached = Arc::new(Notify::new());
   1641             let reached_from_callback = Arc::clone(&reached);
   1642             let task = tokio::spawn(async move {
   1643                 initialize_database(
   1644                     &task_paths,
   1645                     OpenMode::Initialize,
   1646                     &metadata,
   1647                     &schema_catalog,
   1648                     move |initializer| {
   1649                         Box::pin(async move {
   1650                             sqlx::query("CREATE TABLE cancelled_probe (value INTEGER)")
   1651                                 .execute(initializer)
   1652                                 .await?;
   1653                             reached_from_callback.notify_one();
   1654                             pending::<Result<(), sqlx::Error>>().await
   1655                         })
   1656                     },
   1657                 )
   1658                 .await
   1659             });
   1660             reached.notified().await;
   1661             assert!(paths.state_database().exists());
   1662             assert!(WriterAuthority::acquire(&paths, OpenMode::Initialize).is_err());
   1663             task.abort();
   1664             task.await.expect_err("initialization task is cancelled");
   1665             assert!(!paths.state_database().exists());
   1666             assert!(
   1667                 WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1668                     .unwrap()
   1669                     .is_some()
   1670             );
   1671         }
   1672 
   1673         #[tokio::test(flavor = "current_thread")]
   1674         async fn replacement_is_detected_and_never_deleted() {
   1675             let root = tempfile::tempdir().expect("root");
   1676             let paths = paths(root.path(), "replacement");
   1677             prepare(&paths);
   1678             let metadata = metadata(&paths);
   1679             let schema_catalog = base_schema_catalog();
   1680             let replacement_path = paths.state_database().to_path_buf();
   1681             let error = initialize_database(
   1682                 &paths,
   1683                 OpenMode::Initialize,
   1684                 &metadata,
   1685                 &schema_catalog,
   1686                 move |_| {
   1687                     Box::pin(async move {
   1688                         fs::remove_file(&replacement_path)?;
   1689                         fs::write(&replacement_path, b"replacement")?;
   1690                         Ok::<(), io::Error>(())
   1691                     })
   1692                 },
   1693             )
   1694             .await
   1695             .expect_err("replacement must fail");
   1696             assert_eq!(error.kind(), ServiceSqliteErrorKind::Create);
   1697             assert_eq!(fs::read(paths.state_database()).unwrap(), b"replacement");
   1698         }
   1699 
   1700         #[tokio::test(flavor = "current_thread")]
   1701         async fn parent_directory_replacement_cannot_rebind_the_callback_path() {
   1702             let root = tempfile::tempdir().expect("root");
   1703             let paths = paths(root.path(), "parent-replacement");
   1704             prepare(&paths);
   1705             let metadata = metadata(&paths);
   1706             let schema_catalog = base_schema_catalog();
   1707             let state_directory = paths.state_database().parent().unwrap().to_path_buf();
   1708             let displaced_directory = state_directory.with_file_name("parent-replacement-old");
   1709             let displaced_for_callback = displaced_directory.clone();
   1710             let replacement_path = paths.state_database().to_path_buf();
   1711 
   1712             let error = initialize_database(
   1713                 &paths,
   1714                 OpenMode::Initialize,
   1715                 &metadata,
   1716                 &schema_catalog,
   1717                 move |_| {
   1718                     Box::pin(async move {
   1719                         fs::rename(&state_directory, &displaced_for_callback)?;
   1720                         fs::create_dir(&state_directory)?;
   1721                         fs::write(&replacement_path, b"replacement")?;
   1722                         fs::set_permissions(&replacement_path, fs::Permissions::from_mode(0o600))?;
   1723                         Ok::<(), io::Error>(())
   1724                     })
   1725                 },
   1726             )
   1727             .await
   1728             .expect_err("canonical path replacement must fail");
   1729 
   1730             assert_eq!(error.kind(), ServiceSqliteErrorKind::Authority);
   1731             assert_eq!(fs::read(paths.state_database()).unwrap(), b"replacement");
   1732             assert!(!displaced_directory.join("state.sqlite").exists());
   1733         }
   1734 
   1735         #[tokio::test(flavor = "current_thread")]
   1736         async fn injected_sync_and_cleanup_failures_preserve_exact_ordering() {
   1737             let scenarios = [
   1738                 "reservation-sync",
   1739                 "database-sync",
   1740                 "directory-sync",
   1741                 "cleanup",
   1742             ];
   1743             for scenario in scenarios {
   1744                 let root = tempfile::tempdir().expect("root");
   1745                 let paths = paths(root.path(), scenario);
   1746                 prepare(&paths);
   1747                 let metadata = metadata(&paths);
   1748                 let schema_catalog = base_schema_catalog();
   1749                 let authority = WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1750                     .unwrap()
   1751                     .unwrap();
   1752                 let operations = RecordingOperations::default();
   1753                 match scenario {
   1754                     "reservation-sync" => {
   1755                         operations.fail_directory_sync_on_call.set(Some(1));
   1756                     }
   1757                     "database-sync" => operations.fail_database_sync.set(true),
   1758                     "directory-sync" => {
   1759                         operations.fail_directory_sync_on_call.set(Some(2));
   1760                     }
   1761                     "cleanup" => operations.fail_unlink.set(true),
   1762                     _ => unreachable!(),
   1763                 }
   1764                 let result = if scenario == "cleanup" {
   1765                     initialize_with_ops(
   1766                         &paths,
   1767                         authority,
   1768                         &metadata,
   1769                         &schema_catalog,
   1770                         |_| Box::pin(ready(Err::<(), _>(CallbackFailure))),
   1771                         &operations,
   1772                         &crate::failpoint::DurabilityFailpoints::default(),
   1773                     )
   1774                     .await
   1775                 } else {
   1776                     initialize_with_ops(
   1777                         &paths,
   1778                         authority,
   1779                         &metadata,
   1780                         &schema_catalog,
   1781                         |_| Box::pin(ready(Ok::<(), CallbackFailure>(()))),
   1782                         &operations,
   1783                         &crate::failpoint::DurabilityFailpoints::default(),
   1784                     )
   1785                     .await
   1786                 };
   1787                 assert_eq!(
   1788                     result.expect_err("injected failure").kind(),
   1789                     ServiceSqliteErrorKind::Create
   1790                 );
   1791                 let events = operations.events.borrow();
   1792                 match scenario {
   1793                     "reservation-sync" => assert_eq!(
   1794                         events.as_slice(),
   1795                         ["sync_directory", "unlink_database", "sync_directory"]
   1796                     ),
   1797                     "database-sync" => assert_eq!(
   1798                         events.as_slice(),
   1799                         [
   1800                             "sync_directory",
   1801                             "sync_database",
   1802                             "unlink_database",
   1803                             "sync_directory"
   1804                         ]
   1805                     ),
   1806                     "directory-sync" => assert_eq!(
   1807                         events.as_slice(),
   1808                         [
   1809                             "sync_directory",
   1810                             "sync_database",
   1811                             "sync_directory",
   1812                             "unlink_database",
   1813                             "sync_directory"
   1814                         ]
   1815                     ),
   1816                     "cleanup" => {
   1817                         assert_eq!(
   1818                             events.as_slice(),
   1819                             ["sync_directory", "unlink_database", "unlink_database"]
   1820                         )
   1821                     }
   1822                     _ => unreachable!(),
   1823                 }
   1824             }
   1825         }
   1826 
   1827         #[test]
   1828         fn rollback_failure_classifier_preserves_primary_and_cleanup_precedence() {
   1829             let ordinary =
   1830                 || InitializationCause::new(InitializationFailureKind::SchemaInitializationFailed);
   1831             let replaced = || InitializationCause::new(InitializationFailureKind::DatabaseReplaced);
   1832             let cleanup = || InitializationCause::new(InitializationFailureKind::CleanupFailed);
   1833 
   1834             let ordinary_success = rollback_failure(ordinary(), Ok(()));
   1835             assert_eq!(ordinary_success.kind(), ServiceSqliteErrorKind::Create);
   1836             assert_eq!(
   1837                 ordinary_success
   1838                     .source()
   1839                     .map(ToString::to_string)
   1840                     .as_deref(),
   1841                 Some("SQLite schema initialization failed")
   1842             );
   1843 
   1844             let replaced_failure = rollback_failure(replaced(), Err(cleanup()));
   1845             assert_eq!(replaced_failure.kind(), ServiceSqliteErrorKind::Create);
   1846             assert_eq!(
   1847                 replaced_failure
   1848                     .source()
   1849                     .map(ToString::to_string)
   1850                     .as_deref(),
   1851                 Some("SQLite state identity changed during initialization")
   1852             );
   1853 
   1854             let cleanup_failure = rollback_failure(ordinary(), Err(cleanup()));
   1855             assert_eq!(cleanup_failure.kind(), ServiceSqliteErrorKind::Create);
   1856             let outer = cleanup_failure.source().expect("cleanup source");
   1857             assert_eq!(outer.to_string(), "SQLite initialization cleanup failed");
   1858             assert_eq!(
   1859                 outer.source().map(ToString::to_string).as_deref(),
   1860                 Some("SQLite schema initialization failed")
   1861             );
   1862         }
   1863 
   1864         #[tokio::test(flavor = "current_thread")]
   1865         async fn every_initialization_durability_edge_fails_once_and_rolls_back() {
   1866             use crate::failpoint::{DurabilityFailpoint, DurabilityFailpoints};
   1867 
   1868             for (index, (point, expected_events)) in [
   1869                 (DurabilityFailpoint::InitializeBeforeCreate, &[][..]),
   1870                 (
   1871                     DurabilityFailpoint::InitializeAfterCreate,
   1872                     &["unlink_database", "sync_directory"][..],
   1873                 ),
   1874                 (
   1875                     DurabilityFailpoint::InitializeBeforeReservationDirectorySync,
   1876                     &["unlink_database", "sync_directory"][..],
   1877                 ),
   1878                 (
   1879                     DurabilityFailpoint::InitializeAfterReservationDirectorySync,
   1880                     &["sync_directory", "unlink_database", "sync_directory"][..],
   1881                 ),
   1882                 (
   1883                     DurabilityFailpoint::InitializeBeforeFileSync,
   1884                     &["sync_directory", "unlink_database", "sync_directory"][..],
   1885                 ),
   1886                 (
   1887                     DurabilityFailpoint::InitializeAfterFileSync,
   1888                     &[
   1889                         "sync_directory",
   1890                         "sync_database",
   1891                         "unlink_database",
   1892                         "sync_directory",
   1893                     ][..],
   1894                 ),
   1895                 (
   1896                     DurabilityFailpoint::InitializeBeforeCommitDirectorySync,
   1897                     &[
   1898                         "sync_directory",
   1899                         "sync_database",
   1900                         "unlink_database",
   1901                         "sync_directory",
   1902                     ][..],
   1903                 ),
   1904                 (
   1905                     DurabilityFailpoint::InitializeAfterCommitDirectorySync,
   1906                     &[
   1907                         "sync_directory",
   1908                         "sync_database",
   1909                         "sync_directory",
   1910                         "unlink_database",
   1911                         "sync_directory",
   1912                     ][..],
   1913                 ),
   1914             ]
   1915             .into_iter()
   1916             .enumerate()
   1917             {
   1918                 let root = tempfile::tempdir().expect("root");
   1919                 let paths = paths(root.path(), &format!("failpoint-{index}"));
   1920                 prepare(&paths);
   1921                 let metadata = metadata(&paths);
   1922                 let schema_catalog = base_schema_catalog();
   1923                 let authority = WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1924                     .expect("authority acquisition")
   1925                     .expect("initialize authority");
   1926                 let failpoints = DurabilityFailpoints::armed(point);
   1927                 let operations = RecordingOperations::default();
   1928                 let error = initialize_with_ops(
   1929                     &paths,
   1930                     authority,
   1931                     &metadata,
   1932                     &schema_catalog,
   1933                     |_| Box::pin(ready(Ok::<(), CallbackFailure>(()))),
   1934                     &operations,
   1935                     &failpoints,
   1936                 )
   1937                 .await
   1938                 .expect_err("durability edge must fail");
   1939                 assert_eq!(error.kind(), ServiceSqliteErrorKind::Create);
   1940                 assert!(failpoints.fired());
   1941                 assert_eq!(
   1942                     failpoints.reached().last(),
   1943                     Some(&point),
   1944                     "named edge must be the last reached boundary"
   1945                 );
   1946                 assert_eq!(
   1947                     operations.events.borrow().as_slice(),
   1948                     expected_events,
   1949                     "named before/after edge must bracket the expected sync operation"
   1950                 );
   1951                 assert!(!paths.state_database().exists());
   1952                 let mut recovered = WriterAuthority::acquire(&paths, OpenMode::Initialize)
   1953                     .expect("reacquire after rollback")
   1954                     .expect("initialize authority");
   1955                 recovered.release().expect("release recovered authority");
   1956             }
   1957         }
   1958     }
   1959 }
   1960 
   1961 #[cfg(any(target_os = "linux", target_os = "macos"))]
   1962 use supported::{SystemInitializationOperations, initialize_with_ops};