[refactor] Event manager: Support triggering new events in event handle, Solve the problem of multiple borrowing

1 files changed, 41 insertions, 84 deletions

diff --git a/src/plugin/example.rs b/src/plugin/example.rs
index bce1724..b453660 100644
--- a/src/plugin/example.rs
+++ b/src/plugin/example.rs
@@ -1,8 +1,9 @@
-use crate::event::event::*;
+use crate::event::event::Event;
 use crate::event::manager::EventHandle;
+use crate::event::manager::EventManager;
+use crate::event::manager::EventQueue;
 use crate::packet::packet::Packet;
 use crate::session::session::Session;
-use crate::thread::thread::ThreadContex;
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -10,116 +11,72 @@ use std::rc::Rc;
 pub struct ExamplePulgin {
     plugin_name: &'static str,
     plugin_ctx: Rc<RefCell<String>>,
-    thread_ctx: Rc<RefCell<ThreadContex>>,
-    tcp_opening_event: usize,
-    tcp_active_event: usize,
-    tcp_expire_event: usize,
-    tcp_closed_event: usize,
-    http_opening_event: usize,
 }
 
 impl ExamplePulgin {
-    pub fn new(plugin_name: &'static str, thread_ctx: Rc<RefCell<ThreadContex>>) -> ExamplePulgin {
+    pub fn new(plugin_name: &'static str) -> ExamplePulgin {
         ExamplePulgin {
             plugin_name,
             plugin_ctx: Rc::new(RefCell::new(String::new())),
-            thread_ctx: thread_ctx,
-            tcp_opening_event: 0,
-            tcp_active_event: 0,
-            tcp_expire_event: 0,
-            tcp_closed_event: 0,
-            http_opening_event: 0,
         }
     }
-
-    pub fn get_thread_ctx(&self) -> Rc<RefCell<ThreadContex>> {
-        self.thread_ctx.clone()
-    }
 }
 
 impl EventHandle for ExamplePulgin {
-    fn init(&mut self) {
-        let thread_ctx = self.get_thread_ctx();
-        let event_mgr = thread_ctx.borrow().get_event_mgr();
-
-        self.tcp_opening_event = event_mgr
-            .borrow_mut()
-            .event2index(BUILTIN_TCP_OPENING_EVENT);
-        event_mgr
-            .borrow_mut()
-            .register(self.tcp_opening_event, Box::new(self.clone()));
-
-        self.tcp_active_event = event_mgr.borrow_mut().event2index(BUILTIN_TCP_ACTIVE_EVENT);
-        event_mgr
-            .borrow_mut()
-            .register(self.tcp_active_event, Box::new(self.clone()));
-
-        self.tcp_expire_event = event_mgr.borrow_mut().event2index(BUILTIN_TCP_EXPIRE_EVENT);
-        event_mgr
-            .borrow_mut()
-            .register(self.tcp_expire_event, Box::new(self.clone()));
-
-        self.tcp_closed_event = event_mgr.borrow_mut().event2index(BUILTIN_TCP_CLOSED_EVENT);
-        event_mgr
-            .borrow_mut()
-            .register(self.tcp_closed_event, Box::new(self.clone()));
-
-        self.http_opening_event = event_mgr
-            .borrow_mut()
-            .event2index("USERDEF_HTTP_OPENING_EVENT");
-        event_mgr
-            .borrow_mut()
-            .register(self.http_opening_event, Box::new(self.clone()));
+    fn init(&mut self, event_mgr: &mut EventManager) {
+        event_mgr.register(Event::TcpOpeningEvent, Box::new(self.clone()));
+        event_mgr.register(Event::TcpActiveEvent, Box::new(self.clone()));
+        event_mgr.register(Event::TcpExpireEvent, Box::new(self.clone()));
+        event_mgr.register(Event::TcpClosedEvent, Box::new(self.clone()));
+        event_mgr.register(Event::HttpRequestEvent, Box::new(self.clone()));
     }
 
     fn handle(
         &mut self,
-        index: usize,
+        event: Event,
+        queue: &mut EventQueue,
         packet: Option<&Packet>,
         session: Option<Rc<RefCell<Session>>>,
     ) {
-        self.plugin_ctx.borrow_mut().clear();
         self.plugin_ctx.borrow_mut().push_str("1");
 
         if session.is_none() {
             return;
         }
 
-        if packet.is_some() {
-            let flow_id = packet.unwrap().get_flow_id();
-            println!("{} handle Packet: {:?}", self.plugin_name, flow_id);
-        } else {
+        if packet.is_none() {
             println!("{} handle Packet: None", self.plugin_name);
         }
 
         let session = session.unwrap();
-        if index == self.tcp_opening_event {
-            println!(
-                "{} handle BUILTIN_TCP_OPENING_EVENT: {:?}",
-                self.plugin_name, session
-            );
-        } else if index == self.tcp_active_event {
-            println!(
-                "{} handle BUILTIN_TCP_ACTIVE_EVENT: {:?}",
-                self.plugin_name, session
-            );
-        } else if index == self.tcp_expire_event {
-            println!(
-                "{} handle BUILTIN_TCP_EXPIRE_EVENT: {:?}",
-                self.plugin_name, session
-            );
-        } else if index == self.tcp_closed_event {
-            println!(
-                "{} handle BUILTIN_TCP_CLOSED_EVENT: {:?}",
-                self.plugin_name, session
-            );
-        } else if index == self.http_opening_event {
-            println!(
-                "{} handle USERDEF_HTTP_OPENING_EVENT: {:?}",
-                self.plugin_name, session
-            );
-        } else {
-            println!("{} handle UNKNOWN_EVENT: {:?}", self.plugin_name, session);
+        session.borrow_mut().inc_session_c2s_metrics(0, 0, 1, 1);
+        match event {
+            Event::TcpOpeningEvent => {
+                println!("{} handle TcpOpeningEvent: {:?}", self.plugin_name, session);
+                let (src_port, dst_port) = packet.unwrap().get_inner_port().unwrap();
+                if src_port == 80 || dst_port == 80 {
+                    println!("{} add HttpRequestEvent", self.plugin_name);
+                    queue.add(Event::HttpRequestEvent, Some(session));
+                }
+            }
+            Event::TcpActiveEvent => {
+                println!("{} handle TcpActiveEvent: {:?}", self.plugin_name, session);
+            }
+            Event::TcpExpireEvent => {
+                println!("{} handle TcpExpireEvent: {:?}", self.plugin_name, session);
+            }
+            Event::TcpClosedEvent => {
+                println!("{} handle TcpClosedEvent: {:?}", self.plugin_name, session);
+            }
+            Event::HttpRequestEvent => {
+                println!(
+                    "{} handle HttpRequestEvent: {:?}",
+                    self.plugin_name, session
+                );
+            }
+            _ => {
+                println!("{} handle UnknownEvent: {:?}", self.plugin_name, session);
+            }
         }
     }
 }