Reproxy

1 files changed, 76 insertions, 70 deletions

diff --git a/src/system/plugin/autoproxy.rs b/src/system/plugin/autoproxy.rs
index d9beaf0..03e20b8 100644
--- a/src/system/plugin/autoproxy.rs
+++ b/src/system/plugin/autoproxy.rs
@@ -28,6 +28,44 @@ impl Autoproxy {
     }
 }
 
+impl Autoproxy {
+    // Sets the latch and sets a timeout to unlatch it if
+    // state is identical when the timeout goes off
+    async fn set_latch(&self, member: &Member, latch_time: &Timestamp) {
+        let starting_state = {self.current_state.lock().await.clone()};
+
+        let is_latch = match starting_state {
+            InnerState::LatchActive { current_member: _, last_message: _ }
+            | InnerState::LatchInactive => true,
+            _ => false,
+        };
+
+        if !is_latch {
+            return
+        }
+
+        {*self.current_state.lock().await = InnerState::LatchActive {
+           current_member: member.clone(),
+           last_message: latch_time.clone(),
+        }};
+
+        let state_arc = self.current_state.clone();
+        let sent_member = member.clone();
+        let sent_timestamp = latch_time.clone();
+
+        tokio::spawn(async move {
+            sleep(Duration::from_secs(15 * 60)).await;
+            let current_state = {state_arc.lock().await.clone()};
+
+            if let InnerState::LatchActive { current_member, last_message } = current_state {
+                if sent_member.discord_token == current_member.discord_token && sent_timestamp.as_micros() == last_message.as_micros() {
+                    {*state_arc.lock().await = InnerState::LatchInactive};
+                }
+            }
+        });
+    }
+}
+
 #[async_trait]
 impl<'system> SeancePlugin<'system> for Autoproxy {
     fn get_commands(&self) -> Vec<PluginCommand> {
@@ -76,31 +114,44 @@ impl<'system> SeancePlugin<'system> for Autoproxy {
                 logger.log_line(None, "Deleting source message".to_string()).await;
             }
 
-            *response = Response::Noop { delete_source: message.content == "\\\\" };
+            *response = Response::ExplicitNoop { delete_source: message.content == "\\\\", member: None };
             return
         }
 
-        if let Response::Noop { delete_source: _ } = response {
-            let current_state = {self.current_state.lock().await.clone()};
-            match current_state {
-                InnerState::Off => return,
-                InnerState::LatchInactive => return,
-                InnerState::Member { current_member } => {
-                    logger.log_line(Some(current_member.discord_token.clone()), "Proxying via member mode autoproxy".to_string()).await;
-                    *response = Response::Proxy {
-                        member: current_member.clone(),
-                        content: message.content.clone(),
-                    }
-                },
-                InnerState::LatchActive { current_member, last_message: _ } => {
-                    logger.log_line(Some(current_member.discord_token.clone()), "Proxying via autoproxy latch".to_string()).await;
-                    *response = Response::Proxy {
-                        member: current_member.clone(),
-                        content: message.content.clone(),
-                    }
-                },
-            }
+        match response {
+            Response::DefaultNoop => {
+                match starting_state {
+                    InnerState::Member { current_member } => {
+                        logger.log_line(Some(current_member.discord_token.clone()), "Proxying via member mode autoproxy".to_string()).await;
+                        *response = Response::Proxy {
+                            member: current_member.clone(),
+                            content: message.content.clone(),
+                        }
+                    },
+                    InnerState::LatchActive { current_member, last_message: _ } => {
+                        logger.log_line(Some(current_member.discord_token.clone()), "Proxying via autoproxy latch".to_string()).await;
+                        *response = Response::Proxy {
+                            member: current_member.clone(),
+                            content: message.content.clone(),
+                        }
+                    },
+                    _ => (),
+                }
+            },
 
+            // This gets set by reproxy, so update our autoproxy for it
+            Response::ExplicitNoop { delete_source: _, member } => {
+                if let Some(member) = member {
+                    match starting_state {
+                        InnerState::LatchInactive 
+                        | InnerState::LatchActive { current_member: _, last_message: _ }=> {
+                            self.set_latch(&member, &message.timestamp).await;
+                        },
+                        _ => (),
+                    }
+                }
+            },
+            _ => ()
         }
     }
 
@@ -109,57 +160,12 @@ impl<'system> SeancePlugin<'system> for Autoproxy {
             Response::Proxy { member, content: _ } => {
                 let current_state = {self.current_state.lock().await.clone()};
                 match current_state {
-                    InnerState::Off => return,
-                    InnerState::Member { current_member: _ } => return,
-                    InnerState::LatchInactive => {
-                        logger.log_line(Some(member.discord_token.clone()), "Setting autoproxy latch".to_string()).await;
-                        {*self.current_state.lock().await = InnerState::LatchActive {
-                           current_member: member.clone(),
-                           last_message: message.timestamp,
-                        }};
-
-                        let state_arc = self.current_state.clone();
-                        let sent_member = member.clone();
-                        let sent_timestamp = message.timestamp.clone();
-
-                        tokio::spawn(async move {
-                            sleep(Duration::from_secs(15 * 60)).await;
-                            let current_state = {state_arc.lock().await.clone()};
-
-                            if let InnerState::LatchActive { current_member, last_message } = current_state {
-                                if sent_member.discord_token == current_member.discord_token && sent_timestamp.as_micros() == last_message.as_micros() {
-                                    {*state_arc.lock().await = InnerState::LatchInactive};
-                                }
-                            }
-                        });
-                    },
-                    InnerState::LatchActive { current_member: _, last_message: _ } => {
+                    InnerState::LatchInactive
+                    |InnerState::LatchActive { current_member: _, last_message: _ }=> {
                         logger.log_line(Some(member.discord_token.clone()), "Setting autoproxy latch".to_string()).await;
-                        {*self.current_state.lock().await = InnerState::LatchActive {
-                            current_member: member.clone(),
-                            last_message: message.timestamp,
-                        }};
-
-                        let state_arc = self.current_state.clone();
-                        let sent_member = member.clone();
-                        let sent_timestamp = message.timestamp.clone();
-                        let logger = logger.clone();
-
-                        tokio::spawn(async move {
-                            sleep(Duration::from_secs(15 * 60)).await;
-                            let current_state = {state_arc.lock().await.clone()};
-                            logger.log_line(Some(sent_member.discord_token.clone()), "Latch timeout".to_string()).await;
-
-                            if let InnerState::LatchActive { current_member, last_message } = current_state {
-                                if sent_member.discord_token == current_member.discord_token && sent_timestamp.as_micros() == last_message.as_micros() {
-                                    logger.log_line(Some(sent_member.discord_token.clone()), "Latch expired".to_string()).await;
-                                    {*state_arc.lock().await = InnerState::LatchInactive};
-                                } else {
-                                    logger.log_line(Some(sent_member.discord_token.clone()), "Timeout no longer valid".to_string()).await;
-                                }
-                            }
-                        });
+                        self.set_latch(&member, &message.timestamp).await;
                     },
+                    _ => return,
                 }
             },
             _ => return,