fix(hermes): thread_local sqlite resource management (#535)

* feat(hermes): update sqlite runtime extension to use thread-local storage, stop ignoring parallel_execution test

* chore(hermes): refactor sqlite state management

* feat(hermes): add sql validation for execute

* chore(hermes): refactor code, so it uses RteInit traits for release, simplified host-side usage of resources, resolve comments

* chore(hermes): pre-push fix

* chore(hermes): remove allow(unused) for wal mode

* chore(hermes): code refactoring, add comment for RteEvent

* chore(hermes): remove comment after counter fix

* fix(hermes): move closing of connections to drop

* chore(hermes): rename core module to kernel so traitreg would not argue

* fix(hermes): handle resource creation error during open

* chore(hermes): reuse finalize in statement drop

* fix(hermes): update wit for statement finalize, so it consumes the statement

* fix(hermes): fix finalize usage in tests

Author: aido-mth

hermes/apps/athena/modules/rbac-registration/src/lib.rs

@@ -45,7 +45,7 @@ use crate::{
     utils::log::log_info,
 };
 
-use hermes::cardano;
+use hermes::{cardano, sqlite::api::Statement};
 
 struct RbacRegistrationComponent;
 
@@ -115,8 +115,8 @@ impl exports::hermes::cardano::event_on_block::Guest for RbacRegistrationCompone
             }
             insert_rbac_registration(&rbac_stmt, rbac_data);
         }
-        let _ = rbac_stmt.finalize();
-        let _ = rbac_stake_stmt.finalize();
+        let _ = Statement::finalize(rbac_stmt);
+        let _ = Statement::finalize(rbac_stake_stmt);
 
         close_db_connection(sqlite);
     }

hermes/bin/src/runtime_extensions/hermes/sqlite/connection/core.rs

@@ -93,6 +93,10 @@ pub(crate) fn execute(
     db_ptr: *mut sqlite3,
     sql: &str,
 ) -> Result<(), Errno> {
+    if validate_sql(sql) {
+        return Err(Errno::ForbiddenPragmaCommand);
+    }
+
     let sql_cstring = std::ffi::CString::new(sql).map_err(|_| Errno::ConvertingCString)?;
 
     let rc = unsafe { sqlite3_exec(db_ptr, sql_cstring.as_ptr(), None, null_mut(), null_mut()) };
@@ -112,7 +116,7 @@ mod tests {
         runtime_extensions::{
             bindings::hermes::sqlite::api::Value,
             hermes::sqlite::{
-                core::open,
+                kernel::open,
                 statement::core::{column, finalize, step},
             },
         },
@@ -146,6 +150,16 @@ mod tests {
 
         assert!(matches!(stmt_ptr, Err(Errno::ForbiddenPragmaCommand)));
 
+        let sql = "pragma page_size;";
+        let result = execute(db_ptr, sql);
+
+        assert!(matches!(result, Err(Errno::ForbiddenPragmaCommand)));
+
+        let sql = "PRAGMA page_size;";
+        let result = execute(db_ptr, sql);
+
+        assert!(matches!(result, Err(Errno::ForbiddenPragmaCommand)));
+
         close(db_ptr).unwrap();
     }
 

hermes/bin/src/runtime_extensions/hermes/sqlite/connection/host.rs

@@ -2,12 +2,12 @@
 
 //! `SQLite` connection object host implementation for WASM runtime.
 
-use super::{super::state::get_db_state, core};
+use super::core;
 use crate::{
     runtime_context::HermesRuntimeContext,
     runtime_extensions::{
         bindings::hermes::sqlite::api::{Errno, ErrorInfo, HostSqlite, Sqlite, Statement},
-        hermes::sqlite::state::get_statement_state,
+        hermes::sqlite::state::resource_manager,
     },
 };
 
@@ -24,12 +24,10 @@ impl HostSqlite for HermesRuntimeContext {
     /// is automatically rolled back.
     fn close(
         &mut self,
-        resource: wasmtime::component::Resource<Sqlite>,
+        _resource: wasmtime::component::Resource<Sqlite>,
     ) -> wasmtime::Result<Result<(), Errno>> {
-        let app_state = get_db_state().get_app_state(self.app_name())?;
-        let db_ptr = app_state.delete_resource(resource)?;
-
-        Ok(core::close(db_ptr as *mut _))
+        // Connection close is handled automatically in `Drop` implementation
+        Ok(Ok(()))
     }
 
     /// Retrieves the numeric result code for the most recent failed `SQLite` operation on
@@ -42,10 +40,10 @@ impl HostSqlite for HermesRuntimeContext {
         &mut self,
         resource: wasmtime::component::Resource<Sqlite>,
     ) -> wasmtime::Result<Option<ErrorInfo>> {
-        let mut app_state = get_db_state().get_app_state(self.app_name())?;
-        let db_ptr = app_state.get_object(&resource)?;
+        let db_handle = resource.rep().try_into()?;
+        let db_ptr = resource_manager::get_connection_pointer(self.app_name(), db_handle)?;
 
-        Ok(core::errcode(*db_ptr as *mut _))
+        Ok(core::errcode(db_ptr as *mut _))
     }
 
     /// Compiles SQL text into byte-code that will do the work of querying or updating the
@@ -66,18 +64,20 @@ impl HostSqlite for HermesRuntimeContext {
         resource: wasmtime::component::Resource<Sqlite>,
         sql: String,
     ) -> wasmtime::Result<Result<wasmtime::component::Resource<Statement>, Errno>> {
-        let mut db_app_state = get_db_state().get_app_state(self.app_name())?;
-        let db_ptr = db_app_state.get_object(&resource)?;
+        let db_handle = resource.rep().try_into()?;
+        let db_ptr = resource_manager::get_connection_pointer(self.app_name(), db_handle)?;
 
-        let result = core::prepare(*db_ptr as *mut _, sql.as_str());
+        let result = core::prepare(db_ptr as *mut _, sql.as_str());
 
         match result {
             Ok(stmt_ptr) => {
                 if stmt_ptr.is_null() {
                     Ok(Err(Errno::ReturnedNullPointer))
                 } else {
-                    let stm_app_state = get_statement_state().get_app_state(self.app_name())?;
-                    let stmt = stm_app_state.create_resource(stmt_ptr as _);
+                    let stmt = resource_manager::create_statement_resource(
+                        self.app_name(),
+                        stmt_ptr as _,
+                    )?;
 
                     Ok(Ok(stmt))
                 }
@@ -97,21 +97,16 @@ impl HostSqlite for HermesRuntimeContext {
         resource: wasmtime::component::Resource<Sqlite>,
         sql: String,
     ) -> wasmtime::Result<Result<(), Errno>> {
-        let mut app_state = get_db_state().get_app_state(self.app_name())?;
-        let db_ptr = app_state.get_object(&resource)?;
+        let db_handle = resource.rep().try_into()?;
+        let db_ptr = resource_manager::get_connection_pointer(self.app_name(), db_handle)?;
 
-        Ok(core::execute(*db_ptr as *mut _, sql.as_str()))
+        Ok(core::execute(db_ptr as *mut _, sql.as_str()))
     }
 
     fn drop(
         &mut self,
-        rep: wasmtime::component::Resource<Sqlite>,
+        _rep: wasmtime::component::Resource<Sqlite>,
     ) -> wasmtime::Result<()> {
-        let app_state = get_db_state().get_app_state(self.app_name())?;
-        if let Ok(db_ptr) = app_state.delete_resource(rep) {
-            let _ = core::close(db_ptr as *mut _);
-        }
-
         Ok(())
     }
 }

hermes/bin/src/runtime_extensions/hermes/sqlite/host.rs

@@ -1,9 +1,15 @@
 //! `SQLite` host implementation for WASM runtime.
 
-use super::{core, state::get_db_state};
 use crate::{
     runtime_context::HermesRuntimeContext,
-    runtime_extensions::bindings::hermes::sqlite::api::{Errno, Host, Sqlite},
+    runtime_extensions::{
+        bindings::hermes::sqlite::api::{Errno, Host, Sqlite},
+        hermes::sqlite::{
+            connection::core::close,
+            kernel,
+            state::{connection::DbHandle, resource_manager},
+        },
+    },
 };
 
 impl Host for HermesRuntimeContext {
@@ -24,12 +30,33 @@ impl Host for HermesRuntimeContext {
         readonly: bool,
         memory: bool,
     ) -> wasmtime::Result<Result<wasmtime::component::Resource<Sqlite>, Errno>> {
-        match core::open(readonly, memory, self.app_name().clone()) {
-            Ok(db_ptr) => {
-                let app_state = get_db_state().get_app_state(self.app_name())?;
-                let db_id = app_state.create_resource(db_ptr as _);
+        let db_handle = DbHandle::from_readonly_and_memory(readonly, memory);
+
+        if let Some(resource) =
+            resource_manager::try_get_connection_resource(self.app_name(), db_handle)
+        {
+            return Ok(Ok(resource));
+        }
 
-                Ok(Ok(db_id))
+        match kernel::open(readonly, memory, self.app_name().clone()) {
+            Ok(db_ptr) => {
+                match resource_manager::create_connection_resource(
+                    self.app_name(),
+                    db_handle,
+                    db_ptr as _,
+                ) {
+                    Ok(resource) => Ok(Ok(resource)),
+                    Err(err) => {
+                        if let Err(errno) = close(db_ptr) {
+                            anyhow::bail!(
+                            "failed to create connection resource: {err}, also failed to close the connection with errno: {errno}..."
+                        )
+                        }
+                        anyhow::bail!(
+                            "failed to create connection resource: {err}, closing the connection..."
+                        )
+                    },
+                }
             },
             Err(err) => Ok(Err(err)),
         }

hermes/bin/src/runtime_extensions/hermes/sqlite/core.rs renamed to hermes/bin/src/runtime_extensions/hermes/sqlite/kernel.rs

@@ -80,7 +80,6 @@ extern "C" fn busy_handler(
 /// # Returns
 /// * `Ok(())` on success.
 /// * `Err(Errno)` if any of the configuration steps fail.
-#[allow(unused)]
 fn enable_wal_mode(db_ptr: *mut sqlite3) -> Result<(), Errno> {
     let pragmas = "PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;";
     let c_pragmas = std::ffi::CString::new(pragmas).map_err(|_| Errno::ConvertingCString)?;
@@ -163,8 +162,7 @@ pub(super) fn open(
     }
 
     if !memory && !readonly {
-        // TODO(anyone): fix issue with locks during hermes app execution https://github.com/input-output-hk/hermes/issues/521
-        // enable_wal_mode(db_ptr)?;
+        enable_wal_mode(db_ptr)?;
     }
 
     // config database size limitation

hermes/bin/src/runtime_extensions/hermes/sqlite/mod.rs

@@ -1,13 +1,67 @@
 //! `SQLite` runtime extension implementation.
 
+use tracing::debug;
+
+use crate::{
+    app::ApplicationName,
+    runtime_context::HermesRuntimeContext,
+    runtime_extensions::{
+        hermes::sqlite::state::resource_manager::init_app_state,
+        init::{
+            errors::RteInitResult, trait_app::RteInitApp, trait_event::RteInitEvent,
+            trait_module::RteInitModule, trait_runtime::RteInitRuntime,
+        },
+    },
+    wasm::module::ModuleId,
+};
+
 mod connection;
-mod core;
 mod host;
+mod kernel;
 mod state;
 mod statement;
 
-/// Advise Runtime Extensions of a new context
-pub(crate) fn new_context(ctx: &crate::runtime_context::HermesRuntimeContext) {
-    state::get_db_state().add_app(ctx.app_name().clone());
-    state::get_statement_state().add_app(ctx.app_name().clone());
+/// Runtime Extension for `SQLite`
+#[derive(Default)]
+struct RteSqlite;
+
+#[traitreg::register(default)]
+impl RteInitRuntime for RteSqlite {}
+
+#[traitreg::register(default)]
+impl RteInitApp for RteSqlite {}
+
+#[traitreg::register(default)]
+impl RteInitModule for RteSqlite {
+    fn init(
+        self: Box<Self>,
+        name: &ApplicationName,
+        module_id: &ModuleId,
+    ) -> RteInitResult {
+        debug!(name=%name, module_id=%module_id,"Hermes Runtime Extensions Initialized: Module");
+        init_app_state(name);
+
+        Ok(())
+    }
+}
+
+#[traitreg::register(default)]
+impl RteInitEvent for RteSqlite {
+    fn init(
+        self: Box<Self>,
+        ctx: &HermesRuntimeContext,
+    ) -> RteInitResult {
+        debug!(
+                name=%ctx.app_name(),
+                module=%ctx.module_id(),
+                event=%ctx.event_name(),
+                exc_count=%ctx.exc_counter(),
+                "Hermes Runtime Extensions Initialized: Event");
+
+        init_app_state(ctx.app_name());
+        Ok(())
+    }
 }
+
+/// Advise Runtime Extensions of a new context
+pub(crate) fn new_context(_ctx: &crate::runtime_context::HermesRuntimeContext) {}