summaryrefslogtreecommitdiff
path: root/src/db
diff options
context:
space:
mode:
Diffstat (limited to 'src/db')
-rw-r--r--src/db/backup.rs136
-rw-r--r--src/db/mod.rs144
2 files changed, 280 insertions, 0 deletions
diff --git a/src/db/backup.rs b/src/db/backup.rs
new file mode 100644
index 0000000..e34df9f
--- /dev/null
+++ b/src/db/backup.rs
@@ -0,0 +1,136 @@
+use std::{
+ ffi::{c_int, CStr, CString},
+ ptr::NonNull,
+ str::from_utf8_unchecked,
+};
+
+use libsqlite3_sys::{
+ sqlite3, sqlite3_backup, sqlite3_backup_finish, sqlite3_backup_init, sqlite3_backup_step,
+ sqlite3_errmsg, sqlite3_extended_errcode, SQLITE_BUSY, SQLITE_LOCKED, SQLITE_OK,
+};
+use sqlx::{
+ pool::PoolConnection,
+ sqlite::{Sqlite, SqlitePool},
+};
+
+pub struct Builder {
+ from: PoolConnection<Sqlite>,
+}
+
+impl Builder {
+ pub async fn to(self, to: &SqlitePool) -> sqlx::Result<Backup> {
+ Ok(Backup {
+ from: self.from,
+ to: to.acquire().await?,
+ })
+ }
+}
+
+impl Backup {
+ pub async fn from(from: &SqlitePool) -> sqlx::Result<Builder> {
+ Ok(Builder {
+ from: from.acquire().await?,
+ })
+ }
+}
+
+pub struct Backup {
+ from: PoolConnection<Sqlite>,
+ to: PoolConnection<Sqlite>,
+}
+
+impl Backup {
+ pub async fn backup(&mut self) -> Result<(), Error> {
+ let mut to = self.to.lock_handle().await?;
+ let mut from = self.from.lock_handle().await?;
+
+ let handle = Self::start(to.as_raw_handle(), from.as_raw_handle())?;
+ let step_result = Self::step(handle, -1);
+ Self::finish(to.as_raw_handle(), handle)?;
+
+ step_result
+ }
+
+ fn start(to: NonNull<sqlite3>, from: NonNull<sqlite3>) -> Result<*mut sqlite3_backup, Error> {
+ let name = CString::new("main").expect("static constant is a valid C string");
+ unsafe {
+ // Invariants:
+ //
+ // * `to` and `from` must be valid `sqlite3` pointers (guaranteed by sqlx)
+ // * `zDestName` and `zSourceName` must be valid C strings (see above)
+ //
+ // Never evaluates to null (even though `sqlite3_backup_init` can).
+ let handle =
+ sqlite3_backup_init(to.as_ptr(), name.as_ptr(), from.as_ptr(), name.as_ptr());
+ if handle.is_null() {
+ Err(Error::Backup {
+ code: Error::code_for(to),
+ message: Error::message_for(to),
+ })?;
+ }
+ Ok(handle)
+ }
+ }
+
+ fn step(handle: *mut sqlite3_backup, pages: c_int) -> Result<(), Error> {
+ let step = unsafe {
+ // Invariants:
+ //
+ // * `handle` must be a valid backup handle (see above).
+ sqlite3_backup_step(handle, pages)
+ };
+ if SQLITE_BUSY == step {
+ Err(Error::Backup {
+ code: step,
+ message: String::from("database busy"),
+ })
+ } else if SQLITE_LOCKED == step {
+ Err(Error::Backup {
+ code: step,
+ message: String::from("database locked"),
+ })
+ } else {
+ Ok(())
+ }
+ }
+
+ fn finish(to: NonNull<sqlite3>, handle: *mut sqlite3_backup) -> Result<(), Error> {
+ let finished = unsafe {
+ // Invariants:
+ //
+ // * `handle` must be a valid backup handle (see above).
+ sqlite3_backup_finish(handle)
+ };
+ if finished == SQLITE_OK {
+ Ok(())
+ } else {
+ Err(Error::Backup {
+ code: finished,
+ message: Error::message_for(to),
+ })
+ }
+ }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error(transparent)]
+ Sqlx(#[from] sqlx::Error),
+ #[error("backup failed: {message} (code={code})")]
+ Backup { code: c_int, message: String },
+}
+
+impl Error {
+ fn code_for(handle: NonNull<sqlite3>) -> c_int {
+ unsafe { sqlite3_extended_errcode(handle.as_ptr()) }
+ }
+
+ fn message_for(handle: NonNull<sqlite3>) -> String {
+ unsafe {
+ let msg = sqlite3_errmsg(handle.as_ptr());
+ debug_assert!(!msg.is_null());
+
+ from_utf8_unchecked(CStr::from_ptr(msg).to_bytes()).to_owned()
+ }
+ }
+}
diff --git a/src/db/mod.rs b/src/db/mod.rs
new file mode 100644
index 0000000..61d5c18
--- /dev/null
+++ b/src/db/mod.rs
@@ -0,0 +1,144 @@
+mod backup;
+
+use std::str::FromStr;
+
+use sqlx::{
+ migrate::MigrateDatabase as _,
+ sqlite::{Sqlite, SqliteConnectOptions, SqlitePool, SqlitePoolOptions},
+};
+
+pub async fn prepare(url: &str, backup_url: &str) -> Result<SqlitePool, Error> {
+ if backup_url != "sqlite::memory:" && Sqlite::database_exists(backup_url).await? {
+ return Err(Error::BackupExists(backup_url.into()));
+ }
+
+ let pool = create(url).await?;
+
+ // First migration of original migration series, from commit
+ // 9bd6d9862b1c243def02200bca2cfbf578ad2a2f or earlier.
+ reject_migration(&pool, "20240831024047", "login", "9949D238C4099295EC4BEE734BFDA8D87513B2973DFB895352A11AB01DD46CB95314B7F1B3431B77E3444A165FE3DC28").await?;
+
+ let backup_pool = create(backup_url).await?;
+ backup::Backup::from(&pool)
+ .await?
+ .to(&backup_pool)
+ .await?
+ .backup()
+ .await?;
+
+ if let Err(migrate_error) = sqlx::migrate!().run(&pool).await {
+ if let Err(restore_error) = backup::Backup::from(&backup_pool)
+ .await?
+ .to(&pool)
+ .await?
+ .backup()
+ .await
+ {
+ Err(Error::Restore(restore_error, migrate_error))?;
+ } else {
+ Err(migrate_error)?;
+ };
+ }
+
+ Sqlite::drop_database(backup_url).await?;
+ Ok(pool)
+}
+
+async fn create(database_url: &str) -> sqlx::Result<SqlitePool> {
+ let options = SqliteConnectOptions::from_str(database_url)?
+ .create_if_missing(true)
+ .optimize_on_close(true, /* analysis_limit */ None);
+
+ let pool = SqlitePoolOptions::new().connect_with(options).await?;
+ Ok(pool)
+}
+
+async fn reject_migration(
+ pool: &SqlitePool,
+ version: &str,
+ description: &str,
+ checksum_hex: &str,
+) -> Result<(), Error> {
+ if !sqlx::query_scalar!(
+ r#"
+ select count(*) as "exists: bool"
+ from sqlite_master
+ where name = '_sqlx_migrations'
+ "#
+ )
+ .fetch_one(pool)
+ .await?
+ {
+ // No migrations table; this is a fresh DB.
+ return Ok(());
+ }
+
+ if !sqlx::query_scalar!(
+ r#"
+ select count(*) as "exists: bool"
+ from _sqlx_migrations
+ where version = $1
+ and description = $2
+ and hex(checksum) = $3
+ "#,
+ version,
+ description,
+ checksum_hex,
+ )
+ .fetch_one(pool)
+ .await?
+ {
+ // Rejected migration does not exist; this DB never ran it.
+ return Ok(());
+ }
+
+ Err(Error::Rejected(version.into(), description.into()))
+}
+
+/// Errors occurring during database setup.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ /// Failure due to a database error. See [`sqlx::Error`].
+ #[error(transparent)]
+ Database(#[from] sqlx::Error),
+ /// Failure because an existing database backup already exists.
+ #[error("backup from a previous failed migration already exists: {0}")]
+ BackupExists(String),
+ /// Failure due to a database backup error. See [`backup::Error`].
+ #[error(transparent)]
+ Backup(#[from] backup::Error),
+ #[error("backing out failed migration also failed: {0} ({1})")]
+ Restore(backup::Error, sqlx::migrate::MigrateError),
+ /// Failure due to a database migration error. See
+ /// [`sqlx::migrate::MigrateError`].
+ #[error(transparent)]
+ Migration(#[from] sqlx::migrate::MigrateError),
+ /// Failure because the database contains a migration from an unsupported
+ /// schema version.
+ #[error("database contains rejected migration {0}:{1}, move it aside")]
+ Rejected(String, String),
+}
+
+pub trait NotFound {
+ type Ok;
+ fn not_found<E, F>(self, map: F) -> Result<Self::Ok, E>
+ where
+ E: From<sqlx::Error>,
+ F: FnOnce() -> E;
+}
+
+impl<T> NotFound for Result<T, sqlx::Error> {
+ type Ok = T;
+
+ fn not_found<E, F>(self, map: F) -> Result<T, E>
+ where
+ E: From<sqlx::Error>,
+ F: FnOnce() -> E,
+ {
+ match self {
+ Err(sqlx::Error::RowNotFound) => Err(map()),
+ Err(other) => Err(other.into()),
+ Ok(value) => Ok(value),
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-01-02 08:27:33 +0000