add default version for the DB

Author: ghubertpalo

mithril-aggregator/src/command_args.rs

@@ -37,12 +37,7 @@ fn setup_genesis_dependencies(
     config: &GenesisConfiguration,
 ) -> Result<GenesisToolsDependency, Box<dyn std::error::Error>> {
     let sqlite_db_path = Some(config.get_sqlite_file());
-    DatabaseVersionChecker::new(
-        slog_scope::logger(),
-        ApplicationNodeType::Aggregator,
-        config.get_sqlite_file(),
-    )
-    .apply()?;
+    check_database_migration(config.get_sqlite_file())?;
 
     let chain_observer = Arc::new(
         mithril_common::chain_observer::CardanoCliChainObserver::new(Box::new(
@@ -143,6 +138,17 @@ async fn do_first_launch_initialization_if_needed(
     Ok(())
 }
 
+/// Database version checker.
+/// This is the place where migrations are to be registered.
+fn check_database_migration(sql_file_path: PathBuf) -> Result<(), Box<dyn Error>> {
+    DatabaseVersionChecker::new(
+        slog_scope::logger(),
+        ApplicationNodeType::Aggregator,
+        sql_file_path,
+    )
+    .apply()
+}
+
 /// Mithril Aggregator Node
 #[derive(Parser, Debug, Clone)]
 #[command(version)]
@@ -304,12 +310,7 @@ impl ServeCommand {
             .map_err(|e| format!("configuration deserialize error: {}", e))?;
         debug!("SERVE command"; "config" => format!("{:?}", config));
         let sqlite_db_path = Some(config.get_sqlite_file());
-        DatabaseVersionChecker::new(
-            slog_scope::logger(),
-            ApplicationNodeType::Aggregator,
-            config.get_sqlite_file(),
-        )
-        .apply()?;
+        check_database_migration(config.get_sqlite_file())?;
 
         // Init dependencies
         let snapshot_store = config.build_snapshot_store()?;

mithril-common/src/database/db_version.rs

@@ -127,7 +127,10 @@ impl<'conn> DatabaseVersionProvider<'conn> {
 
     /// Method to create the table at the beginning of the migration procedure.
     /// This code is temporary and should not last.
-    pub fn create_table_if_not_exists(&self) -> Result<(), Box<dyn Error>> {
+    pub fn create_table_if_not_exists(
+        &self,
+        application_type: &ApplicationNodeType,
+    ) -> Result<(), Box<dyn Error>> {
         let connection = self.get_connection();
         let sql = "select exists(select name from sqlite_master where type='table' and name='db_version') as table_exists";
         let table_exists = connection
@@ -140,9 +143,10 @@ impl<'conn> DatabaseVersionProvider<'conn> {
             == 1;
 
         if !table_exists {
-            let sql = r#"
-create table db_version (application_type text not null primary key, version integer not null, updated_at timestamp not null default CURRENT_TIMESTAMP)
-"#;
+            let sql = format!("
+create table db_version (application_type text not null primary key, version integer not null, updated_at timestamp not null default CURRENT_TIMESTAMP);
+insert into db_version (application_type, version) values ('{application_type}', 0);
+");
             connection.execute(sql)?;
         }
 

mithril-common/src/database/version_checker.rs

@@ -59,15 +59,13 @@ impl DatabaseVersionChecker {
         );
         let connection = Connection::open(&self.sqlite_file_path)?;
         let provider = DatabaseVersionProvider::new(&connection);
-        provider.create_table_if_not_exists()?;
+        provider.create_table_if_not_exists(&self.application_type)?;
         let updater = DatabaseVersionUpdater::new(&connection);
         let db_version = provider
             .get_application_version(&self.application_type)?
-            .unwrap_or_else(|| DatabaseVersion {
-                version: 0,
-                application_type: self.application_type.clone(),
-                updated_at: Local::now().naive_local(),
-            });
+            .unwrap(); // At least a record exists.
+
+        // if no migration registered then we are at version 0.
         let migration_version = self.migrations.iter().map(|m| m.version).max().unwrap_or(0);
 
         match migration_version.cmp(&db_version.version) {
@@ -176,17 +174,15 @@ mod tests {
         let version = provider
             .get_application_version(&ApplicationNodeType::Aggregator)
             .unwrap()
-            .unwrap_or_else(|| DatabaseVersion {
-                application_type: ApplicationNodeType::Aggregator,
-                version: 0,
-                updated_at: Local::now().naive_local(),
-            });
+            .unwrap();
 
         assert_eq!(db_version, version.version);
     }
 
     fn create_sqlite_file(name: &str) -> PathBuf {
-        let filepath = std::env::temp_dir().join(name);
+        let dirpath = std::env::temp_dir().join("mithril_test_database");
+        std::fs::create_dir_all(&dirpath).unwrap();
+        let filepath = dirpath.join(name);
 
         if filepath.exists() {
             std::fs::remove_file(filepath.as_path()).unwrap();
@@ -214,7 +210,7 @@ mod tests {
 
     #[test]
     fn test_upgrade_with_migration() {
-        let filepath = create_sqlite_file("test_1.sqlite3");
+        let filepath = create_sqlite_file("test_upgrade_with_migration.sqlite3");
         let mut db_checker = DatabaseVersionChecker::new(
             slog_scope::logger(),
             ApplicationNodeType::Aggregator,
@@ -273,7 +269,7 @@ mod tests {
 
     #[test]
     fn starting_with_migration() {
-        let filepath = create_sqlite_file("test_2.sqlite3");
+        let filepath = create_sqlite_file("starting_with_migration.sqlite3");
         let mut db_checker = DatabaseVersionChecker::new(
             slog_scope::logger(),
             ApplicationNodeType::Aggregator,
@@ -292,21 +288,66 @@ mod tests {
     }
 
     #[test]
+    /// This test case ensure that when multiple migrations are played and one fails:
+    /// * previous migrations are ok and the database version is updated
+    /// * further migrations are not played.
     fn test_failing_migration() {
-        let filepath = create_sqlite_file("test_3.sqlite3");
+        let filepath = create_sqlite_file("test_failing_migration.sqlite3");
         let mut db_checker = DatabaseVersionChecker::new(
             slog_scope::logger(),
             ApplicationNodeType::Aggregator,
             filepath.clone(),
         );
         // Table whatever does not exist, this should fail with error.
-        let alterations = "alter table whatever add column thing_content text; update whatever set thing_content = 'some content'";
+        let alterations = "create table whatever (thing_id integer); insert into whatever (thing_id) values (1), (2), (3), (4);";
         let migration = SqlMigration {
             version: 1,
             alterations: alterations.to_string(),
         };
         db_checker.add_migration(migration);
+        let alterations = "alter table wrong add column thing_content text; update whatever set thing_content = 'some content'";
+        let migration = SqlMigration {
+            version: 2,
+            alterations: alterations.to_string(),
+        };
+        db_checker.add_migration(migration);
+        let alterations = "alter table whatever add column thing_content text; update whatever set thing_content = 'some content'";
+        let migration = SqlMigration {
+            version: 3,
+            alterations: alterations.to_string(),
+        };
+        db_checker.add_migration(migration);
         db_checker.apply().unwrap_err();
-        check_database_version(&filepath, 0);
+        check_database_version(&filepath, 1);
+    }
+
+    #[test]
+    fn test_fail_downgrading() {
+        let filepath = create_sqlite_file("test_fail_downgrading.sqlite3");
+        let mut db_checker = DatabaseVersionChecker::new(
+            slog_scope::logger(),
+            ApplicationNodeType::Aggregator,
+            filepath.clone(),
+        );
+        let alterations = "create table whatever (thing_id integer); insert into whatever (thing_id) values (1), (2), (3), (4);";
+        let migration = SqlMigration {
+            version: 1,
+            alterations: alterations.to_string(),
+        };
+        db_checker.add_migration(migration);
+        db_checker.apply().unwrap();
+        check_database_version(&filepath, 1);
+
+        // re instanciate a new checker with no migration registered (version 0).
+        let db_checker = DatabaseVersionChecker::new(
+            slog_scope::logger(),
+            ApplicationNodeType::Aggregator,
+            filepath.clone(),
+        );
+        assert!(
+            db_checker.apply().is_err(),
+            "using an old version with an up to date database should fail"
+        );
+        check_database_version(&filepath, 1);
     }
 }