add updated_at for application version

Author: ghubertpalo

mithril-aggregator/src/command_args.rs

@@ -1,3 +1,4 @@
+use chrono::Local;
 use clap::{Parser, Subcommand};
 use config::{builder::DefaultState, ConfigBuilder, Map, Source, Value, ValueKind};
 use semver::{Version, VersionReq};
@@ -37,45 +38,52 @@ use crate::{
     ProtocolParametersStorer, SingleSignatureStore, VerificationKeyStore,
 };
 
-fn check_database_version(connection: &Connection) -> Result<bool, Box<dyn Error>> {
-    let provider = VersionProvider::new(connection);
+fn check_database_version(filepath: &Option<PathBuf>) -> Result<(), Box<dyn Error>> {
+    let connection = match filepath {
+        Some(file) => Connection::open(file)?,
+        None => Connection::open(":memory:")?,
+    };
+    let provider = VersionProvider::new(&connection);
     provider.create_table_if_not_exists()?;
     let application_type = ApplicationNodeType::new("aggregator")?;
-    let maybe_option = provider.get_database_version(&application_type)?;
+    let maybe_option = provider.get_application_version(&application_type)?;
+    let current_version = ApplicationVersion {
+        semver: Version::parse(env!("CARGO_PKG_VERSION"))?,
+        application_type,
+        updated_at: Local::now().naive_local(),
+    };
 
-    let version = match maybe_option {
+    match maybe_option {
         None => {
-            let provider = VersionUpdaterProvider::new(connection);
-            let version = ApplicationVersion {
-                database_version: Version::parse(env!("CARGO_PKG_VERSION"))?,
-                application_type,
-            };
-            provider.save(version)?
+            let provider = VersionUpdaterProvider::new(&connection);
+            let _ = provider.save(current_version)?;
+            debug!("application version saved in database");
+        }
+        Some(version) => {
+            let req = VersionReq::parse(&current_version.semver.to_string()).unwrap();
+
+            if !req.matches(&version.semver) {
+                warn!(
+                    "application version '{}' is out of date, new version is '{}'. Upgrading database…",
+                    version.semver, current_version.semver
+                );
+                let upgrader_provider = VersionUpdaterProvider::new(&connection);
+                upgrader_provider.save(current_version)?;
+                debug!("database updated");
+            } else {
+                debug!("database up to date");
+            }
         }
-        Some(version) => version,
     };
-    let req = VersionReq::parse(env!("CARGO_PKG_VERSION")).unwrap();
 
-    Ok(req.matches(&version.database_version))
+    Ok(())
 }
 
 fn setup_genesis_dependencies(
     config: &GenesisConfiguration,
 ) -> Result<GenesisToolsDependency, Box<dyn std::error::Error>> {
     let sqlite_db_path = Some(config.get_sqlite_file());
-
-    let connection = match sqlite_db_path.clone() {
-        Some(filepath) => Connection::open(filepath)?,
-        None => Connection::open(":memory:")?,
-    };
-    if !check_database_version(&connection)? {
-        warn!("❌ The database is out of date, application may fail.");
-    } else {
-        debug!(
-            "Database schematic for application version {} has been checked OK!",
-            env!("CARGO_PKG_VERSION")
-        );
-    }
+    check_database_version(&sqlite_db_path)?;
 
     let chain_observer = Arc::new(
         mithril_common::chain_observer::CardanoCliChainObserver::new(Box::new(
@@ -336,25 +344,13 @@ impl ServeCommand {
             .try_deserialize()
             .map_err(|e| format!("configuration deserialize error: {}", e))?;
         debug!("SERVE command"; "config" => format!("{:?}", config));
+        let sqlite_db_path = Some(config.get_sqlite_file());
+        check_database_version(&sqlite_db_path)?;
+
         // Init dependencies
         let snapshot_store = config.build_snapshot_store()?;
         let snapshot_uploader = config.build_snapshot_uploader()?;
 
-        let sqlite_db_path = Some(config.get_sqlite_file());
-        let connection = match sqlite_db_path.clone() {
-            Some(filepath) => Connection::open(filepath)?,
-            None => Connection::open(":memory:")?,
-        };
-
-        if !check_database_version(&connection)? {
-            warn!("❌ The database is out of date, application may fail.");
-        } else {
-            debug!(
-                "Database schematic for application version {} has been checked OK!",
-                env!("CARGO_PKG_VERSION")
-            );
-        }
-
         let certificate_pending_store = Arc::new(CertificatePendingStore::new(Box::new(
             SQLiteAdapter::new("pending_certificate", sqlite_db_path.clone())?,
         )));

mithril-common/src/database/db_version.rs

@@ -1,5 +1,6 @@
 use std::{collections::HashMap, error::Error, fmt::Display};
 
+use chrono::NaiveDateTime;
 use semver::Version;
 use sqlite::{Connection, Row, Value};
 
@@ -36,22 +37,31 @@ impl Display for ApplicationNodeType {
 }
 
 /// Entity related to the `app_version` database table.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct ApplicationVersion {
     /// Semver of the database structure.
-    pub database_version: Version,
+    pub semver: Version,
 
     /// Name of the application.
     pub application_type: ApplicationNodeType,
+
+    /// Date of the last version upgrade, Sqlite does not store timezone
+    /// information hence we have to use a `Chrono::NaiveDateTime` here.
+    pub updated_at: NaiveDateTime,
 }
 
 impl SqLiteEntity for ApplicationVersion {
     fn hydrate(row: Row) -> Result<Self, HydrationError> {
         Ok(Self {
-            database_version: Version::parse(&row.get::<String, _>(0))
+            semver: Version::parse(&row.get::<String, _>(0))
                 .map_err(|e| HydrationError::InvalidData(format!("{}", e)))?,
             application_type: ApplicationNodeType::new(&row.get::<String, _>(1))
                 .map_err(|e| HydrationError::InvalidData(format!("{}", e)))?,
+            updated_at: NaiveDateTime::parse_from_str(
+                &row.get::<String, _>(2),
+                "%Y-%m-%d %H:%M:%S",
+            )
+            .map_err(|e| HydrationError::InvalidData(format!("{}", e)))?,
         })
     }
 }
@@ -73,12 +83,13 @@ impl Projection for ApplicationVersionProjection {
 impl ApplicationVersionProjection {
     pub fn new() -> Self {
         let mut projection = Self { fields: Vec::new() };
-        projection.add_field("version", "{:app_version:}.version", "text");
+        projection.add_field("semver", "{:app_version:}.semver", "text");
         projection.add_field(
             "application_type",
             "{:app_version:}.application_type",
             "text",
         );
+        projection.add_field("updated_at", "{:app_version:}.updated_at", "timestamp");
 
         projection
     }
@@ -115,16 +126,16 @@ impl<'conn> VersionProvider<'conn> {
 
         if !table_exists {
             let sql = r#"
-create table app_version (application_type text not null primary key, version text not null)
+create table app_version (application_type text not null primary key, semver text not null, updated_at timestamp not null default CURRENT_TIMESTAMP)
 "#;
             connection.execute(sql)?;
         }
 
         Ok(())
     }
 
-    /// Read the database version from the database.
-    pub fn get_database_version(
+    /// Read the application version from the database.
+    pub fn get_application_version(
         &self,
         application_type: &ApplicationNodeType,
     ) -> Result<Option<ApplicationVersion>, Box<dyn Error>> {
@@ -183,7 +194,7 @@ impl<'conn> VersionUpdaterProvider<'conn> {
     pub fn save(&self, version: ApplicationVersion) -> Result<ApplicationVersion, Box<dyn Error>> {
         let params = [
             Value::String(format!("{}", version.application_type)),
-            Value::String(version.database_version.to_string()),
+            Value::String(version.semver.to_string()),
         ];
         let entity = self
             .find(None, &params)?
@@ -213,8 +224,8 @@ impl<'conn> Provider<'conn> for VersionUpdaterProvider<'conn> {
 
         format!(
             r#"
-insert into app_version (application_type, version) values (?, ?)
-  on conflict (application_type) do update set version = excluded.version
+insert into app_version (application_type, semver) values (?, ?)
+  on conflict (application_type) do update set semver = excluded.semver, updated_at = CURRENT_TIMESTAMP
 returning {projection}
 "#
         )
@@ -232,7 +243,7 @@ mod tests {
         let _ = aliases.insert("{:app_version:}".to_string(), "whatever".to_string());
 
         assert_eq!(
-            "whatever.version as version, whatever.application_type as application_type"
+            "whatever.semver as semver, whatever.application_type as application_type, whatever.updated_at as updated_at"
                 .to_string(),
             projection.expand(aliases)
         );
@@ -245,7 +256,7 @@ mod tests {
 
         assert_eq!(
             r#"
-select app_version.version as version, app_version.application_type as application_type
+select app_version.semver as semver, app_version.application_type as application_type, app_version.updated_at as updated_at
 from app_version
 where true
 "#,
@@ -260,9 +271,9 @@ where true
 
         assert_eq!(
             r#"
-insert into app_version (application_type, version) values (?, ?)
-  on conflict (application_type) do update set version = excluded.version
-returning app_version.version as version, app_version.application_type as application_type
+insert into app_version (application_type, semver) values (?, ?)
+  on conflict (application_type) do update set semver = excluded.semver, updated_at = CURRENT_TIMESTAMP
+returning app_version.semver as semver, app_version.application_type as application_type, app_version.updated_at as updated_at
 "#,
             provider.get_definition(None)
         )