Make ExecutorHooks an async trait

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

crates/factors-executor/src/lib.rs

@@ -32,7 +32,12 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutor<T, U> {
             hooks: Default::default(),
         })
     }
+}
 
+impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutor<T, U>
+where
+    T::AppState: Sync,
+{
     /// Adds the given [`ExecutorHooks`] to this executor.
     ///
     /// Hooks are run in the order they are added.
@@ -53,7 +58,7 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutor<T, U> {
             .context("failed to configure app")?;
 
         for hooks in &mut self.hooks {
-            hooks.configure_app(&configured_app)?;
+            hooks.configure_app(&configured_app).await?;
         }
 
         let mut component_instance_pres = HashMap::new();
@@ -75,9 +80,14 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutor<T, U> {
     }
 }
 
-pub trait ExecutorHooks<T: RuntimeFactors, U>: Send + Sync {
+#[async_trait]
+pub trait ExecutorHooks<T, U>: Send + Sync
+where
+    T: RuntimeFactors,
+    T::AppState: Sync,
+{
     /// Configure app hooks run immediately after [`RuntimeFactors::configure_app`].
-    fn configure_app(&mut self, configured_app: &ConfiguredApp<T>) -> anyhow::Result<()> {
+    async fn configure_app(&mut self, configured_app: &ConfiguredApp<T>) -> anyhow::Result<()> {
         let _ = configured_app;
         Ok(())
     }
@@ -131,7 +141,12 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutorApp<T, U> {
             .with_context(|| format!("no such component {component_id:?}"))?;
         Ok(instance_pre.component())
     }
+}
 
+impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutorApp<T, U>
+where
+    T::AppState: Sync,
+{
     /// Returns an instance builder for the given component ID.
     pub fn prepare(&self, component_id: &str) -> anyhow::Result<FactorsInstanceBuilder<T, U>> {
         let app_component = self

crates/trigger/src/cli/sqlite_statements.rs

@@ -1,4 +1,5 @@
 use anyhow::Context as _;
+use spin_core::async_trait;
 use spin_factor_sqlite::SqliteFactor;
 use spin_factors::RuntimeFactors;
 use spin_factors_executor::ExecutorHooks;
@@ -21,68 +22,65 @@ impl SqlStatementExecutorHook {
     pub fn new(sql_statements: Vec<String>) -> Self {
         Self { sql_statements }
     }
-}
 
-impl<F: RuntimeFactors, U> ExecutorHooks<F, U> for SqlStatementExecutorHook {
-    fn configure_app(
-        &mut self,
-        configured_app: &spin_factors::ConfiguredApp<F>,
-    ) -> anyhow::Result<()> {
+    /// Executes the sql statements.
+    pub async fn execute(&self, sqlite: &spin_factor_sqlite::AppState) -> anyhow::Result<()> {
         if self.sql_statements.is_empty() {
             return Ok(());
         }
-        let Some(sqlite) = configured_app.app_state::<SqliteFactor>().ok() else {
-            return Ok(());
-        };
-        if let Ok(current) = tokio::runtime::Handle::try_current() {
-            let _ = current.spawn(execute(sqlite.clone(), self.sql_statements.clone()));
-        }
-        Ok(())
-    }
-}
-
-/// Executes the sql statements.
-pub async fn execute(
-    sqlite: spin_factor_sqlite::AppState,
-    sql_statements: Vec<String>,
-) -> anyhow::Result<()> {
-    let get_database = |label| {
-        let sqlite = &sqlite;
-        async move {
+        let get_database = |label| async move {
             sqlite
                 .get_connection(label)
                 .await
                 .transpose()
                 .with_context(|| format!("failed connect to database with label '{label}'"))
-        }
-    };
+        };
 
-    for statement in &sql_statements {
-        if let Some(config) = statement.strip_prefix('@') {
-            let (file, label) = parse_file_and_label(config)?;
-            let database = get_database(label).await?.with_context(|| {
+        for statement in &self.sql_statements {
+            if let Some(config) = statement.strip_prefix('@') {
+                let (file, label) = parse_file_and_label(config)?;
+                let database = get_database(label).await?.with_context(|| {
                     format!(
                         "based on the '@{config}' a registered database named '{label}' was expected but not found."
                     )
                 })?;
-            let sql = std::fs::read_to_string(file).with_context(|| {
-                format!("could not read file '{file}' containing sql statements")
-            })?;
-            database.execute_batch(&sql).await.with_context(|| {
-                format!("failed to execute sql against database '{label}' from file '{file}'")
-            })?;
-        } else {
-            let Some(default) = get_database(DEFAULT_SQLITE_LABEL).await? else {
-                debug_assert!(false, "the '{DEFAULT_SQLITE_LABEL}' sqlite database should always be available but for some reason was not");
-                return Ok(());
-            };
-            default
+                let sql = std::fs::read_to_string(file).with_context(|| {
+                    format!("could not read file '{file}' containing sql statements")
+                })?;
+                database.execute_batch(&sql).await.with_context(|| {
+                    format!("failed to execute sql against database '{label}' from file '{file}'")
+                })?;
+            } else {
+                let Some(default) = get_database(DEFAULT_SQLITE_LABEL).await? else {
+                    debug_assert!(false, "the '{DEFAULT_SQLITE_LABEL}' sqlite database should always be available but for some reason was not");
+                    return Ok(());
+                };
+                default
                     .query(statement, Vec::new())
                     .await
                     .with_context(|| format!("failed to execute following sql statement against default database: '{statement}'"))?;
+            }
         }
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl<F, U> ExecutorHooks<F, U> for SqlStatementExecutorHook
+where
+    F: RuntimeFactors,
+    F::AppState: Sync,
+{
+    async fn configure_app(
+        &mut self,
+        configured_app: &spin_factors::ConfiguredApp<F>,
+    ) -> anyhow::Result<()> {
+        let Some(sqlite) = configured_app.app_state::<SqliteFactor>().ok() else {
+            return Ok(());
+        };
+        self.execute(&sqlite).await?;
+        Ok(())
     }
-    Ok(())
 }
 
 /// Parses a @{file:label} sqlite statement

crates/trigger/src/cli/summary.rs

@@ -1,12 +1,14 @@
+use spin_core::async_trait;
 use spin_factor_key_value::KeyValueFactor;
 use spin_factors_executor::ExecutorHooks;
 
 use crate::factors::TriggerFactors;
 
 pub struct KeyValueDefaultStoreSummaryHook;
 
+#[async_trait]
 impl<U> ExecutorHooks<TriggerFactors, U> for KeyValueDefaultStoreSummaryHook {
-    fn configure_app(
+    async fn configure_app(
         &mut self,
         configured_app: &spin_factors::ConfiguredApp<TriggerFactors>,
     ) -> anyhow::Result<()> {

crates/trigger/src/stdio.rs

@@ -6,6 +6,7 @@ use std::{
 
 use anyhow::{Context, Result};
 use spin_common::ui::quoted_path;
+use spin_core::async_trait;
 use spin_factors_executor::ExecutorHooks;
 use tokio::io::AsyncWrite;
 
@@ -87,8 +88,9 @@ impl StdioLoggingExecutorHooks {
     }
 }
 
+#[async_trait]
 impl<U> ExecutorHooks<TriggerFactors, U> for StdioLoggingExecutorHooks {
-    fn configure_app(
+    async fn configure_app(
         &mut self,
         configured_app: &spin_factors::ConfiguredApp<TriggerFactors>,
     ) -> anyhow::Result<()> {