lib

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

lib.rs (4247B)

      1 #![deny(unsafe_code)]
      2 #![cfg_attr(coverage_nightly, feature(coverage_attribute))]
      3 
      4 //! Reusable, service-neutral SQLite mechanics for Radroots services.
      5 
      6 mod authority;
      7 mod backup;
      8 mod config;
      9 mod connection;
     10 mod error;
     11 #[cfg(any(target_os = "linux", target_os = "macos"))]
     12 mod failpoint;
     13 mod initialize;
     14 mod integrity;
     15 mod metadata;
     16 mod migration;
     17 #[cfg(any(target_os = "linux", target_os = "macos"))]
     18 mod native_metadata;
     19 mod open;
     20 #[cfg(any(target_os = "linux", target_os = "macos"))]
     21 mod persisted_value;
     22 mod restore;
     23 #[cfg(any(target_os = "linux", target_os = "macos"))]
     24 #[allow(
     25     unsafe_code,
     26     reason = "the sealed SQLx-handle adapter owns the missing SQLite online-backup calls"
     27 )]
     28 mod sqlite_native_backup;
     29 mod statement_policy;
     30 mod status;
     31 mod transaction_control;
     32 
     33 pub(crate) fn all_constraints<const N: usize>(constraints: [bool; N]) -> bool {
     34     constraints.into_iter().all(core::convert::identity)
     35 }
     36 
     37 #[cfg(any(test, target_os = "linux", target_os = "macos"))]
     38 pub(crate) fn require_condition(
     39     condition: bool,
     40     kind: ServiceSqliteErrorKind,
     41 ) -> Result<(), ServiceSqliteError> {
     42     if condition {
     43         Ok(())
     44     } else {
     45         Err(ServiceSqliteError::new(kind))
     46     }
     47 }
     48 
     49 pub use authority::WriterAuthority;
     50 pub use backup::{
     51     BACKUP_MANIFEST_CANONICAL_MAX_BYTES, BACKUP_MANIFEST_SCHEMA, BACKUP_MANIFEST_SCHEMA_VERSION,
     52     BACKUP_STATE_MEMBER_NAME, BackupCreatedAtUnixMs, BackupManifestContractError,
     53     BackupManifestIntegrity, BackupManifestSha256, BackupMemberSha256, ServiceBackupManifest,
     54     ServiceBackupMember, VerifiedServiceBackup, verify_backup_bundle,
     55 };
     56 pub use config::{ServiceSqliteConnectionOptions, ServiceSqliteConnectionOptionsError};
     57 pub use connection::{
     58     OpenedServiceDatabase, ServiceSqliteHost, ServiceSqliteTransaction,
     59     ServiceSqliteTransactionError, ServiceSqliteTransactionErrorKind,
     60     ServiceSqliteTransactionFuture,
     61 };
     62 pub use error::{
     63     SafeServiceSqliteError, ServiceSqliteError, ServiceSqliteErrorCode, ServiceSqliteErrorKind,
     64 };
     65 pub use initialize::{
     66     ServiceSqliteInitializer, ServiceSqliteInitializerFuture, initialize_database,
     67 };
     68 pub use integrity::{
     69     IntegrityCheckOutcome, IntegrityCheckedAtUnixMs, IntegrityDiagnosticCode, SchemaCatalog,
     70     SchemaCatalogContractError, SchemaDigest, SchemaObject, SchemaObjectKind, SchemaVersionCatalog,
     71     ServiceSqliteIntegrityReport,
     72 };
     73 pub use metadata::{
     74     ExistingServiceDatabaseIntent, ServiceDatabaseIdentity, ServiceDatabaseMetadata,
     75     ServiceSqliteApplicationId, ServiceSqliteMetadataValueError,
     76 };
     77 pub use migration::{
     78     MigrationApplicationOutcome, MigrationAppliedAtUnixSeconds, MigrationBuildIdentity,
     79     MigrationCallback, MigrationCallbackBinding, MigrationCallbackFuture, MigrationCatalog,
     80     MigrationChecksum, MigrationContractError, MigrationDescriptor, MigrationEvidenceError,
     81     MigrationKind, MigrationName, MigrationTransactionExecutor,
     82 };
     83 pub use open::{OpenMode, ServiceSqlitePathError, ServiceSqlitePaths};
     84 pub use restore::{StagedServiceRestore, finalize_staged_restore, stage_verified_restore};
     85 pub use status::{
     86     MinimumFreeBytes, PlatformStateFilesystemCapacitySource, StateFilesystemCapacity,
     87     StateFilesystemCapacityError, StateFilesystemCapacityReadiness, StateFilesystemCapacitySource,
     88     StorageHealth, StorageIntegrity, StorageStatus, inspect_state_filesystem_capacity,
     89 };
     90 
     91 #[cfg(test)]
     92 mod coverage_tests {
     93     use super::*;
     94 
     95     #[test]
     96     fn shared_condition_classifier_preserves_every_stable_error_kind() {
     97         for kind in [
     98             ServiceSqliteErrorKind::Authority,
     99             ServiceSqliteErrorKind::Open,
    100             ServiceSqliteErrorKind::Create,
    101             ServiceSqliteErrorKind::Pragma,
    102             ServiceSqliteErrorKind::Metadata,
    103             ServiceSqliteErrorKind::Migration,
    104             ServiceSqliteErrorKind::Backup,
    105             ServiceSqliteErrorKind::Restore,
    106             ServiceSqliteErrorKind::Integrity,
    107             ServiceSqliteErrorKind::Recovery,
    108         ] {
    109             assert!(require_condition(true, kind).is_ok());
    110             assert_eq!(
    111                 require_condition(false, kind)
    112                     .expect_err("false condition")
    113                     .kind(),
    114                 kind
    115             );
    116         }
    117     }
    118 }