Run a vacuum on the database after cert hashes migration

Author: Alenar

mithril-aggregator/src/commands/tools_command.rs

@@ -1,5 +1,6 @@
 use clap::{Parser, Subcommand};
 use config::{builder::DefaultState, ConfigBuilder};
+use mithril_common::sqlite::vacuum_database;
 use slog_scope::debug;
 use std::{error::Error, sync::Arc};
 
@@ -69,13 +70,18 @@ impl RecomputeCertificatesHashCommand {
         let connection = dependencies_builder.get_sqlite_connection().await?;
         let migrator = CertificatesHashMigrator::new(
             CertificateRepository::new(connection.clone()),
-            Arc::new(SignedEntityStoreAdapter::new(connection)),
+            Arc::new(SignedEntityStoreAdapter::new(connection.clone())),
         );
 
         migrator
             .migrate()
             .await
-            .map_err(|err| format!("Certificate hash migrator error: {err}"))?;
+            .map_err(|err| format!("recompute-certificates-hash: migration error: {err}"))?;
+
+        vacuum_database(connection)
+            .await
+            .map_err(|err| format!("recompute-certificates-hash: database vacuum error: {err}"))?;
+
         Ok(())
     }
 }

mithril-aggregator/src/tools/certificates_hash_migrator.rs

@@ -161,6 +161,7 @@ impl CertificatesHashMigrator {
         self.certificate_repository
             .delete_certificates(&old_certificates.iter().collect::<Vec<_>>())
             .await?;
+
         Ok(())
     }
 }

mithril-common/src/sqlite/mod.rs

@@ -15,3 +15,34 @@ pub use entity::{HydrationError, SqLiteEntity};
 pub use projection::{Projection, ProjectionField};
 pub use provider::Provider;
 pub use source_alias::SourceAlias;
+
+use sqlite::Connection;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use crate::StdResult;
+
+/// Do a [vacuum](https://www.sqlite.org/lang_vacuum.html) on the given connection, this will
+/// reconstruct the database file, repacking it into a minimal amount of disk space.
+pub async fn vacuum_database(connection: Arc<Mutex<Connection>>) -> StdResult<()> {
+    let connection = &connection.lock().await;
+    connection.execute("vacuum")?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use crate::sqlite::vacuum_database;
+    use sqlite::Connection;
+    use std::sync::Arc;
+    use tokio::sync::Mutex;
+
+    #[tokio::test]
+    async fn calling_vacuum_on_an_empty_in_memory_db_should_not_fail() {
+        let connection = Arc::new(Mutex::new(Connection::open(":memory:").unwrap()));
+
+        vacuum_database(connection)
+            .await
+            .expect("Vacuum should not fail");
+    }
+}