move command_executor_service creation into l1, update call-sides

Author: Orciument

backend/src/commands/command_controller.rs

@@ -98,7 +98,7 @@ pub async fn set_enabled(
 ) -> AxResult<impl IntoResponse> {
     //TODO move into query parameter
     let enabled = bool::from_str(body.as_ref()).map_err(|_| StatusCode::BAD_REQUEST)?;
-    command_repo::set_enabled(state, trigger_id.as_ref(), enabled)
+    command_repo::set_enabled(state.l1.as_ref(), trigger_id.as_ref(), enabled)
         .await
         .map_err(|_| {
             // log
@@ -125,10 +125,10 @@ pub async fn set_visible(
 }
 
 pub async fn save(
-    State(state): State<AxumState>,
+    l1: L1Arc,
     Json(to_save): Json<Command>,
 ) -> impl IntoResponse {
-    match command_repo::save(state, &to_save).await {
+    match command_repo::save(l1.as_ref(), &to_save).await {
         Ok(()) => StatusCode::OK,
         Err(SaveCommandError::DbError(_db_error)) => {
             // log
@@ -143,10 +143,10 @@ pub async fn save(
 }
 
 pub async fn delete_by_id(
-    State(state): State<AxumState>,
+    l1: L1Arc,
     Path(trigger_id): Path<String>,
 ) -> AxResult<impl IntoResponse> {
-    command_repo::delete_by_id(state, trigger_id.as_ref()).await.map_err(|_| {
+    command_repo::delete_by_id(l1.as_ref(), trigger_id.as_ref()).await.map_err(|_| {
         // log
         StatusCode::INTERNAL_SERVER_ERROR
     })?;

backend/src/commands/command_executor_service.rs

@@ -132,41 +132,16 @@ static TEXT_COMMAND_CALLBACK: TriggerCallback = |app_state, trigger_id, _chat_me
 //  - indicate to users of our service that we are being created, and make them wait for us to finish.
 //  - move creation of out service into l1 state. The creation of this just requires the DB, the execution is difficult
 //    we also can't just create an emtpy version of ourselves, and fill the rest in later, because then our users would try to modify non existing commands
-#[derive(Default)]
 pub struct CommandExecutorService {
     triggers: RwLock<Vec<CommandTrigger>>,
     cooldown_service: CooldownService,
 }
 
-impl  CommandExecutorService {
-    pub async fn process_chat_message(app_state: Arc<FullState>, message: ChatMessage) {
-        for trigger in app_state.l2.command_executor_service.triggers.read().await.iter() {
-            app_state.l2.command_executor_service.execute_trigger_if_matching(app_state.clone(), trigger, message.clone()).await
-        }
-    }
-
-    async fn execute_trigger_if_matching(&self, app_state: Arc<FullState>, trigger: &CommandTrigger, chat_message: ChatMessage) {
-        if chat_message.user.permission < trigger.permission {
-            // logger.debug("User {} with {}, missing {} permission for command {}", message.user().name(), message.user().permission(), trigger.permission(), trigger.id());
-            return;
-        }
-
-        if !trigger.patterns.iter().any(|r| r.is_match(&chat_message.message)) {
-            return;
-        }
-
-        let cooldown_res = self.cooldown_service.check_update_cooldown(&chat_message, trigger.id.as_ref(), &trigger.user_cooldown, &trigger.global_cooldown);
-        if cooldown_res.is_some() {
-            // logger.debug("Call to command {} from {} rejected because of global cooldowns", trigger.id(), message.user().name());
-            // logger.debug("Call to command {} from {} rejected because of user cooldowns", trigger.id(), message.user().name());
-            return;
-        }
-
-        (trigger.callback)(app_state, trigger.id.clone(), chat_message).await;
+impl CommandExecutorService {
+    pub(crate) async fn new(_db: &ProdDB) -> CommandExecutorService {
+        todo!("get commands from db, and also return Result here")
     }
-}
 
-impl CommandExecutorService {
     pub(crate) async fn remove_command(&self, command_id: &TriggerId) {
         self.triggers.write().await.retain(|c| c.id.as_ref() != command_id);
     }
@@ -210,3 +185,31 @@ impl CommandExecutorService {
     }
 }
 
+impl  CommandExecutorService {
+    pub async fn process_chat_message(app_state: Arc<FullState>, message: ChatMessage) {
+        for trigger in app_state.l1.command_executor_service.triggers.read().await.iter() {
+            app_state.l1.command_executor_service.execute_trigger_if_matching(app_state.clone(), trigger, message.clone()).await
+        }
+    }
+
+    async fn execute_trigger_if_matching(&self, app_state: Arc<FullState>, trigger: &CommandTrigger, chat_message: ChatMessage) {
+        if chat_message.user.permission < trigger.permission {
+            // logger.debug("User {} with {}, missing {} permission for command {}", message.user().name(), message.user().permission(), trigger.permission(), trigger.id());
+            return;
+        }
+
+        if !trigger.patterns.iter().any(|r| r.is_match(&chat_message.message)) {
+            return;
+        }
+
+        let cooldown_res = self.cooldown_service.check_update_cooldown(&chat_message, trigger.id.as_ref(), &trigger.user_cooldown, &trigger.global_cooldown);
+        if cooldown_res.is_some() {
+            // logger.debug("Call to command {} from {} rejected because of global cooldowns", trigger.id(), message.user().name());
+            // logger.debug("Call to command {} from {} rejected because of user cooldowns", trigger.id(), message.user().name());
+            return;
+        }
+
+        (trigger.callback)(app_state, trigger.id.clone(), chat_message).await;
+    }
+}
+

backend/src/commands/command_repo.rs

@@ -1,8 +1,8 @@
-use crate::axum::AxumState;
 use crate::commands::command_controller::{Command, CooldownType, MessagePattern};
 use crate::commands::command_executor_service::{CommandWithRegex, TriggerId, TwitchUserPermission};
 use crate::commands::template_service::StringTemplate;
 use crate::db::ProdDB;
+use crate::state::L1State;
 use anyhow::Context;
 use num_traits::FromPrimitive;
 use sqlx::mysql::MySqlQueryResult;
@@ -221,8 +221,8 @@ async fn get_patterns(prod_db: &ProdDB, d: Vec<CommandTable>) -> anyhow::Result<
     Ok(commands)
 }
 
-pub(crate) async fn set_enabled(state: AxumState, trigger_id: &TriggerId, enabled: bool) -> anyhow::Result<Option<()>> {
-    let mut transaction = state.l1.prod_db.begin().await?;
+pub(crate) async fn set_enabled(l1: &L1State, trigger_id: &TriggerId, enabled: bool) -> anyhow::Result<Option<()>> {
+    let mut transaction = l1.prod_db.begin().await?;
     let affected = query!("UPDATE `sys-chat_trigger-patterns` SET is_enabled = ? WHERE parent_trigger_id = ?", enabled, trigger_id)
         .execute(transaction.deref_mut())
         .await
@@ -231,9 +231,7 @@ pub(crate) async fn set_enabled(state: AxumState, trigger_id: &TriggerId, enable
     if affected == 0 {
         return Ok(None)
     }
-    if let Some(l2) = state.l2.get() {
-        l2.command_executor_service.refresh_patterns(&state.l1.prod_db, trigger_id).await;
-    }
+    l1.command_executor_service.refresh_patterns(&l1.prod_db, trigger_id).await;
     transaction.commit().await?;
     Ok(Some(()))
 }
@@ -255,18 +253,15 @@ pub(crate) enum SaveCommandError {
     RegexError(regex::Error),
 }
 
-pub(crate) async fn save(state: AxumState, command: &Command) -> Result<(), SaveCommandError> {
-    // make this in the beginning, to make sure this is all valid regex
+pub(crate) async fn save(l1: &L1State, command: &Command) -> Result<(), SaveCommandError> {
     let with_regex: CommandWithRegex = command.try_into().map_err(|re| SaveCommandError::RegexError(re))?;
 
-    let mut transaction = state.l1.prod_db.begin().await.context("failed to start save command transaction")
+    let mut transaction = l1.prod_db.begin().await.context("failed to start save command transaction")
         .map_err(|e| SaveCommandError::DbError(e))?;
 
     save_command(&command, &mut transaction).await.map_err(|e| SaveCommandError::DbError(e))?;
 
-    if let Some(l2) = state.l2.get() {
-        l2.command_executor_service.upsert_command(with_regex).await
-    }
+    l1.command_executor_service.upsert_command(with_regex).await;
     transaction.commit().await.context("failed to commit save command transaction")
         .map_err(|e| SaveCommandError::DbError(e))?;
     Ok(())
@@ -310,8 +305,8 @@ async fn save_template<'a, E: MySqlExecutor<'a>>(prod_db: E, template: &StringTe
         .context("failed to save command template")
 }
 
-pub(crate) async fn delete_by_id(state: AxumState, trigger_id: &TriggerId) -> anyhow::Result<()> {
-    let pool = state.l1.prod_db.deref();
+pub(crate) async fn delete_by_id(l1: &L1State, trigger_id: &TriggerId) -> anyhow::Result<()> {
+    let pool = l1.prod_db.deref();
     query!("DELETE FROM `sys-string_templates` WHERE id = (SELECT template_id FROM `sys-chat_trigger-trigger` WHERE id = ?)", trigger_id)
         .execute(pool)
         .await
@@ -321,9 +316,7 @@ pub(crate) async fn delete_by_id(state: AxumState, trigger_id: &TriggerId) -> an
         .await
         .context("failed to delete command trigger")?;
 
-    if let Some(l2) = state.l2.get() {
-        l2.command_executor_service.remove_command(&trigger_id).await;
-    }
+    l1.command_executor_service.remove_command(&trigger_id).await;
     Ok(())
 }
 

backend/src/lib.rs

@@ -38,6 +38,7 @@ pub async fn start() {
             server_base_url: Url::from_str("http://localhost:4771").unwrap(),
             panel_auth_twitch_client_id: "zmxjjn3xmncg8ewew6tjk08tub26bb".to_string()
         }),
+        command_executor_service: CommandExecutorService::new(&prod_db).await,
         oauth_service: Default::default(),
         session_service: Default::default(),
         prod_db,
@@ -62,7 +63,6 @@ pub async fn start() {
     let service = TwitchService::new(l1.clone(), twitch_config).await.unwrap();
     let l2 = Arc::new(L2State {
         twitch_service: service,
-        command_executor_service: Default::default(),
     });
 
     // 3rd. (Full) Stage

backend/src/state.rs

@@ -45,11 +45,11 @@ pub struct L1State {
     pub session_service: SessionService,
     pub oauth_service: OAuthService,
     pub webserver_config: RwLock<WebserverConfig>,
+    pub command_executor_service: CommandExecutorService
 }
 
 pub struct L2State {
     pub twitch_service: TwitchService,
-    pub command_executor_service: CommandExecutorService
 }
 
 pub struct L1Arc(Arc<L1State>);

backend/src/twitch/twitch_service.rs

@@ -29,7 +29,7 @@ pub(crate) struct TwitchConfig {
     pub client_secret: String,
 }
 
-struct TwitchCredentialStatus {
+pub(super) struct TwitchCredentialStatus {
     valid_checked_at: Instant,
     was_valid_at_check: bool,
     credential: OauthCredential,