trait for plug and example plug

2 files changed, 148 insertions, 59 deletions

diff --git a/src/plugin/example.rs b/src/plugin/example.rs
index a7afb5b..a8b5e44 100644
--- a/src/plugin/example.rs
+++ b/src/plugin/example.rs
@@ -1,81 +1,95 @@
-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 std::cell::RefCell;
-use std::rc::Rc;
+use std::{cell::RefCell, collections::LinkedList, rc::Rc};
+
+use crate::{
+    event::{event::Event, manager::PlugEvents},
+    session::session::Session,
+};
+
+use super::plugin::PHandle;
 
-#[derive(Clone)]
 pub struct ExamplePulgin {
     plugin_name: &'static str,
-    plugin_ctx: Rc<RefCell<String>>,
+    // ctx can be a local variable or be given to slab for storage. Only references are retained here.
+    plugin_ctx: Option<Rc<RefCell<Session>>>,
+    plug_events: PlugEvents,
 }
 
 impl ExamplePulgin {
     pub fn new(plugin_name: &'static str) -> ExamplePulgin {
         ExamplePulgin {
             plugin_name,
-            plugin_ctx: Rc::new(RefCell::new(String::new())),
+            plugin_ctx: None,
+            plug_events: PlugEvents::new(),
         }
     }
 }
 
-impl EventHandle for ExamplePulgin {
-    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()));
+impl PHandle<()> for ExamplePulgin {
+    // type ReturnFuture<'a, T> = impl Future<Output = ()> + 'a where Self: 'a, T: 'a;
+    type EventArray = [Event; 5];
+
+    fn get_name(&self) -> &'static str {
+        self.plugin_name
     }
 
-    fn handle(
-        &mut self,
-        event: Event,
-        queue: &mut EventQueue,
-        packet: Option<&Packet>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        self.plugin_ctx.borrow_mut().push_str("1");
+    fn plug_events(&mut self) -> &PlugEvents {
+        &(self.plug_events)
+    }
 
-        if session.is_none() {
-            return;
-        }
+    fn interested_events(&mut self) -> Self::EventArray {
+        [
+            Event::TCPOpeningEvent,
+            Event::TCPActiveEvent,
+            Event::TCPExpireEvent,
+            Event::TCPClosedEvent,
+            Event::HTTPRequestEvent,
+        ]
+    }
 
-        if packet.is_none() {
-            println!("{} handle Packet: None", self.plugin_name);
-        }
+    fn handle_events<'a>(
+        &'a mut self,
+        packet: Option<&'a crate::packet::packet::Packet<'a>>, // packet as a reference, need 'a lifetime
+        session: Option<Rc<RefCell<Session>>>,
+        events: LinkedList<Event>,
+    ) -> () {
+        let bind = session.unwrap();
+        let mut session = bind.try_borrow_mut().unwrap();
+        session.inc_session_c2s_metrics(0, 0, 1, 1);
 
-        let session = session.unwrap();
-        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_innermost_port().unwrap();
-                if src_port == 80 || dst_port == 80 {
-                    println!("{} add HTTPRequestEvent", self.plugin_name);
-                    queue.add(Event::HTTPRequestEvent, Some(session));
+        for event in events {
+            match event {
+                Event::TCPOpeningEvent => {
+                    println!("{} handle TCPOpeningEvent: {:?}", self.plugin_name, session);
+                    let (src_port, dst_port) = packet.unwrap().get_innermost_port().unwrap();
+                    if src_port == 80 || dst_port == 80 {
+                        println!("{} trigger HTTPRequestEvent", self.plugin_name);
+                        self.plugin_ctx = Some(bind.clone());
+                        self.plug_events.trigger(Event::HTTPRequestEvent);
+                    }
+                }
+                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 => {
+                    if self.plugin_ctx.is_none() {
+                        println!("{} handle HTTPRequestEvent: None", self.plugin_name);
+                    } else {
+                        println!(
+                            "{} handle HTTPRequestEvent: {:?}",
+                            self.plugin_name,
+                            self.plugin_ctx.clone().unwrap()
+                        );
+                    }
+                }
+                _ => {
+                    println!("{} handle UnknownEvent: {:?}", self.plugin_name, 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);
             }
         }
     }
diff --git a/src/plugin/plugin.rs b/src/plugin/plugin.rs
new file mode 100644
index 0000000..cdfe8fc
--- /dev/null
+++ b/src/plugin/plugin.rs
@@ -0,0 +1,75 @@
+use std::{cell::RefCell, collections::LinkedList, rc::Rc};
+
+use futures_util::Future;
+
+use crate::{
+    event::{self, event::Event, manager::PlugEvents},
+    packet::packet::Packet,
+    session::session::Session,
+};
+
+pub(crate) trait PHandle<T: Default> {
+    type EventArray: AsRef<[Event]>; // for interested_events() return type
+
+    fn get_name(&self) -> &'static str;
+    fn plug_events(&mut self) -> &PlugEvents;
+
+    fn interested_events(&mut self) -> Self::EventArray;
+
+    fn handle_events<'a>(
+        &'a mut self,
+        packet: Option<&'a Packet<'a>>, // packet as a reference, need 'a lifetime
+        session: Option<Rc<RefCell<Session>>>,
+        events: LinkedList<Event>,
+    ) -> T;
+}
+
+pub trait PHandleExt<T: Default> {
+    type ReturnFuture<'a>: Future<Output = T>
+    where
+        Self: 'a,
+        T: 'a;
+
+    fn init(&mut self); // plugin.init
+
+    // plugin.handle
+    fn handle<'a>(
+        &'a mut self,
+        packet: Option<&'a Packet<'a>>, // packet as a reference, need 'a lifetime
+        session: Option<Rc<RefCell<Session>>>,
+    ) -> <Self as PHandleExt<T>>::ReturnFuture<'_>;
+}
+
+impl<A, T> PHandleExt<T> for A
+where
+    A: PHandle<T>,
+    T: Default, // () already impl Default,so T = '()' is fine
+{
+    type ReturnFuture<'a> = impl Future<Output = T> where A: 'a,T:'a;
+
+    fn init(&mut self) {
+        let events = self.interested_events();
+        let plug_events = self.plug_events();
+        plug_events.registers(events);
+    }
+
+    fn handle<'a>(
+        &'a mut self,
+        packet: Option<&'a Packet<'a>>, // packet as a reference, need 'a lifetime
+        session: Option<Rc<RefCell<Session>>>,
+    ) -> Self::ReturnFuture<'_> {
+        async move {
+            if session.is_none() {
+                return T::default();
+            }
+            if packet.is_none() {
+                println!("{} handle Packet: None", self.get_name());
+            }
+
+            let plug_events = self.plug_events();
+            let events = plug_events.check().await;
+
+            self.handle_events(packet, session, events)
+        }
+    }
+}