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

8 files changed, 314 insertions, 468 deletions

diff --git a/src/event/event.rs b/src/event/event.rs
index 8a4ddee..deb8b6f 100644
--- a/src/event/event.rs
+++ b/src/event/event.rs
@@ -1,159 +1,52 @@
-use crate::event::manager::EventManager;
-use crate::session::session::Session;
-use std::cell::RefCell;
-use std::rc::Rc;
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+pub enum Event {
+    L2Event,
+    L3Event,
+    L4EVENT,
 
-// L2 Event
-pub const BUILTIN_L2_EVENT: &str = "BUILTIN_L2_EVENT";
+    Ipv4Event,
+    Ipv6Event,
 
-// L3 Event
-pub const BUILTIN_L3_EVENT: &str = "BUILTIN_L3_EVENT";
-pub const BUILTIN_IPV4_EVENT: &str = "BUILTIN_IPV4_EVENT";
-pub const BUILTIN_IPV6_EVENT: &str = "BUILTIN_IPV6_EVENT";
+    TcpEvent,
+    UdpEvent,
 
-// L4 Event
-pub const BUILTIN_L4_EVENT: &str = "BUILTIN_L4_EVENT";
+    TcpOpeningEvent,
+    TcpActiveEvent,
+    TcpExpireEvent,
+    TcpClosedEvent,
 
-pub const BUILTIN_TCP_EVENT: &str = "BUILTIN_TCP_EVENT";
-pub const BUILTIN_TCP_OPENING_EVENT: &str = "BUILTIN_TCP_OPENING_EVENT";
-pub const BUILTIN_TCP_ACTIVE_EVENT: &str = "BUILTIN_TCP_ACTIVE_EVENT";
-pub const BUILTIN_TCP_EXPIRE_EVENT: &str = "BUILTIN_TCP_EXPIRE_EVENT";
-pub const BUILTIN_TCP_CLOSED_EVENT: &str = "BUILTIN_TCP_CLOSED_EVENT";
+    UdpOpeningEvent,
+    UdpActiveEvent,
+    UdpExpireEvent,
 
-pub const BUILTIN_UDP_EVENT: &str = "BUILTIN_UDP_EVENT";
-pub const BUILTIN_UDP_OPENING_EVENT: &str = "BUILTIN_UDP_OPENING_EVENT";
-pub const BUILTIN_UDP_ACTIVE_EVENT: &str = "BUILTIN_UDP_ACTIVE_EVENT";
-pub const BUILTIN_UDP_EXPIRE_EVENT: &str = "BUILTIN_UDP_EXPIRE_EVENT";
-
-// L7 Event
-pub const BUILTIN_L7_EVENT: &str = "BUILTIN_L7_EVENT";
-pub const BUILTIN_DNS_EVENT: &str = "BUILTIN_DNS_EVENT";
-pub const BUILTIN_HTTP_EVENT: &str = "BUILTIN_HTTP_EVENT";
-
-pub struct BuiltInEvent {}
-
-impl BuiltInEvent {
-    pub fn trigger_l2_event(mgr: Rc<RefCell<EventManager>>, session: Option<Rc<RefCell<Session>>>) {
-        let builtin_l2_event = mgr.borrow_mut().event2index(BUILTIN_L2_EVENT);
-        mgr.borrow_mut().trigger(builtin_l2_event, session);
-    }
-
-    pub fn trigger_l3_event(mgr: Rc<RefCell<EventManager>>, session: Option<Rc<RefCell<Session>>>) {
-        let builtin_l3_event = mgr.borrow_mut().event2index(BUILTIN_L3_EVENT);
-        mgr.borrow_mut().trigger(builtin_l3_event, session);
-    }
-
-    pub fn trigger_ipv4_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_ipv4_event = mgr.borrow_mut().event2index(BUILTIN_IPV4_EVENT);
-        mgr.borrow_mut().trigger(builtin_ipv4_event, session);
-    }
-
-    pub fn trigger_ipv6_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_ipv6_event = mgr.borrow_mut().event2index(BUILTIN_IPV6_EVENT);
-        mgr.borrow_mut().trigger(builtin_ipv6_event, session);
-    }
-
-    pub fn trigger_l4_event(mgr: Rc<RefCell<EventManager>>, session: Option<Rc<RefCell<Session>>>) {
-        let builtin_l4_event = mgr.borrow_mut().event2index(BUILTIN_L4_EVENT);
-        mgr.borrow_mut().trigger(builtin_l4_event, session);
-    }
-
-    pub fn trigger_tcp_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_tcp_event = mgr.borrow_mut().event2index(BUILTIN_TCP_EVENT);
-        mgr.borrow_mut().trigger(builtin_tcp_event, session);
-    }
-
-    pub fn trigger_tcp_opening_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_tcp_opening_event = mgr.borrow_mut().event2index(BUILTIN_TCP_OPENING_EVENT);
-        mgr.borrow_mut().trigger(builtin_tcp_opening_event, session);
-    }
-
-    pub fn trigger_tcp_active_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_tcp_active_event = mgr.borrow_mut().event2index(BUILTIN_TCP_ACTIVE_EVENT);
-        mgr.borrow_mut().trigger(builtin_tcp_active_event, session);
-    }
-
-    pub fn trigger_tcp_expire_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_tcp_expire_event = mgr.borrow_mut().event2index(BUILTIN_TCP_EXPIRE_EVENT);
-        mgr.borrow_mut().trigger(builtin_tcp_expire_event, session);
-    }
-
-    pub fn trigger_tcp_closed_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_tcp_closed_event = mgr.borrow_mut().event2index(BUILTIN_TCP_CLOSED_EVENT);
-        mgr.borrow_mut().trigger(builtin_tcp_closed_event, session);
-    }
-
-    pub fn trigger_udp_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_udp_event = mgr.borrow_mut().event2index(BUILTIN_UDP_EVENT);
-        mgr.borrow_mut().trigger(builtin_udp_event, session);
-    }
+    HttpRequestEvent,
+    HttpResponseEvent,
+}
 
-    pub fn trigger_udp_opening_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_udp_opening_event = mgr.borrow_mut().event2index(BUILTIN_UDP_OPENING_EVENT);
-        mgr.borrow_mut().trigger(builtin_udp_opening_event, session);
-    }
+impl core::fmt::Display for Event {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        match *self {
+            Event::L2Event => write!(f, "L2Event"),
+            Event::L3Event => write!(f, "L3Event"),
+            Event::L4EVENT => write!(f, "L4EVENT"),
 
-    pub fn trigger_udp_active_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_udp_active_event = mgr.borrow_mut().event2index(BUILTIN_UDP_ACTIVE_EVENT);
-        mgr.borrow_mut().trigger(builtin_udp_active_event, session);
-    }
+            Event::Ipv4Event => write!(f, "Ipv4Event"),
+            Event::Ipv6Event => write!(f, "Ipv6Event"),
 
-    pub fn trigger_udp_expire_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_udp_expire_event = mgr.borrow_mut().event2index(BUILTIN_UDP_EXPIRE_EVENT);
-        mgr.borrow_mut().trigger(builtin_udp_expire_event, session);
-    }
+            Event::TcpEvent => write!(f, "TcpEvent"),
+            Event::UdpEvent => write!(f, "UdpEvent"),
 
-    pub fn trigger_l7_event(mgr: Rc<RefCell<EventManager>>, session: Option<Rc<RefCell<Session>>>) {
-        let builtin_l7_event = mgr.borrow_mut().event2index(BUILTIN_L7_EVENT);
-        mgr.borrow_mut().trigger(builtin_l7_event, session);
-    }
+            Event::TcpOpeningEvent => write!(f, "TcpOpeningEvent"),
+            Event::TcpActiveEvent => write!(f, "TcpActiveEvent"),
+            Event::TcpExpireEvent => write!(f, "TcpExpireEvent"),
+            Event::TcpClosedEvent => write!(f, "TcpClosedEvent"),
 
-    pub fn trigger_dns_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_dns_event = mgr.borrow_mut().event2index(BUILTIN_DNS_EVENT);
-        mgr.borrow_mut().trigger(builtin_dns_event, session);
-    }
+            Event::UdpOpeningEvent => write!(f, "UdpOpeningEvent"),
+            Event::UdpActiveEvent => write!(f, "UdpActiveEvent"),
+            Event::UdpExpireEvent => write!(f, "UdpExpireEvent"),
 
-    pub fn trigger_http_event(
-        mgr: Rc<RefCell<EventManager>>,
-        session: Option<Rc<RefCell<Session>>>,
-    ) {
-        let builtin_http_event = mgr.borrow_mut().event2index(BUILTIN_HTTP_EVENT);
-        mgr.borrow_mut().trigger(builtin_http_event, session);
+            Event::HttpRequestEvent => write!(f, "HttpRequestEvent"),
+            Event::HttpResponseEvent => write!(f, "HttpResponseEvent"),
+        }
     }
 }
diff --git a/src/event/manager.rs b/src/event/manager.rs
index 867a77f..66a56ab 100644
--- a/src/event/manager.rs
+++ b/src/event/manager.rs
@@ -1,3 +1,4 @@
+use crate::event::event::Event;
 use crate::packet::packet::Packet;
 use crate::session::session::Session;
 use std::cell::RefCell;
@@ -5,75 +6,76 @@ use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::rc::Rc;
 
+/******************************************************************************
+ * Event Queue
+ ******************************************************************************/
+
+pub struct EventQueue {
+    queue: VecDeque<(Event, Option<Rc<RefCell<Session>>>)>,
+}
+
+impl EventQueue {
+    pub fn new() -> EventQueue {
+        EventQueue {
+            queue: VecDeque::new(),
+        }
+    }
+
+    pub fn add(&mut self, event: Event, session: Option<Rc<RefCell<Session>>>) {
+        self.queue.push_back((event, session));
+    }
+
+    fn pop(&mut self) -> Option<(Event, Option<Rc<RefCell<Session>>>)> {
+        self.queue.pop_front()
+    }
+}
+
+/******************************************************************************
+ * Event Manager
+ ******************************************************************************/
+
 pub trait EventHandle {
-    fn init(&mut self);
+    fn init(&mut self, event_mgr: &mut EventManager);
     fn handle(
         &mut self,
-        index: usize,
+        event: Event,
+        queue: &mut EventQueue,
         packet: Option<&Packet>,
         session: Option<Rc<RefCell<Session>>>,
     );
 }
 
 pub struct EventManager {
-    index2event: HashMap<usize, &'static str>, // event index -> event name
-    event2index: HashMap<&'static str, usize>, // event name -> event index
-    ready_event: VecDeque<(usize, Option<Rc<RefCell<Session>>>)>, // ready event index
-    cared_event: HashMap<usize, RefCell<Vec<Box<dyn EventHandle>>>>, // event index -> event handle
+    map: HashMap<Event, RefCell<Vec<Box<dyn EventHandle>>>>,
 }
 
 impl EventManager {
     pub fn new() -> EventManager {
         EventManager {
-            index2event: HashMap::new(),
-            event2index: HashMap::new(),
-            ready_event: VecDeque::new(),
-            cared_event: HashMap::new(),
-        }
-    }
-
-    pub fn event2index(&mut self, event: &'static str) -> usize {
-        if let Some(index) = self.event2index.get(event) {
-            *index
-        } else {
-            let index = self.event2index.len();
-            self.event2index.insert(event, index);
-            self.index2event.insert(index, event);
-            index
+            map: HashMap::new(),
         }
     }
 
-    pub fn index2event(&self, index: usize) -> Option<&'static str> {
-        if let Some(event) = self.index2event.get(&index) {
-            Some(*event)
-        } else {
-            None
-        }
-    }
-
-    pub fn register(&mut self, index: usize, handle: Box<dyn EventHandle>) {
-        if let Some(vec) = self.cared_event.get(&index) {
+    pub fn register(&mut self, event: Event, handle: Box<dyn EventHandle>) {
+        if let Some(vec) = self.map.get(&event) {
             let mut vec = vec.borrow_mut();
             vec.push(handle);
         } else {
             let mut vec = Vec::with_capacity(1024);
             vec.push(handle);
-            self.cared_event.insert(index, RefCell::new(vec));
+            self.map.insert(event, RefCell::new(vec));
         }
     }
 
-    pub fn trigger(&mut self, index: usize, session: Option<Rc<RefCell<Session>>>) {
-        self.ready_event.push_back((index, session));
-    }
-
-    pub fn dispatch(&mut self, packet: Option<&Packet>) {
+    pub fn dispatch(&mut self, packet: Option<&Packet>, queue: &mut EventQueue) {
         loop {
-            if let Some(event) = self.ready_event.pop_front() {
-                println!("Dispatch event: {:?}", self.index2event.get(&event.0));
-                if let Some(vec) = self.cared_event.get(&event.0) {
+            let result = queue.pop();
+            if let Some((event, session)) = result {
+                println!("Dispatch Event: {}", event);
+                if let Some(vec) = self.map.get(&event) {
                     let mut vec = vec.borrow_mut();
                     for callback in vec.iter_mut() {
-                        callback.handle(event.0, packet, event.1.clone());
+                        callback.handle(event, queue, packet, session.clone());
                     }
                 }
             } else {
@@ -89,12 +91,11 @@ impl EventManager {
 
 #[cfg(test)]
 mod tests {
+    use super::EventManager;
     use crate::event::manager::EventHandle;
+    use crate::event::manager::EventQueue;
     use crate::packet::packet::Packet;
     use crate::plugin::example::ExamplePulgin;
-    use crate::thread::thread::ThreadContex;
-    use std::cell::RefCell;
-    use std::rc::Rc;
 
     /*
      * Frame 217: 131 bytes on wire (1048 bits), 131 bytes captured (1048 bits) on interface en0, id 0
@@ -220,12 +221,11 @@ mod tests {
             0x2a, 0x0d, 0x0a, 0x0d, 0x0a, /* HTTP END */
         ];
 
-        // Create plugin
-        let thread_ctx = Rc::new(RefCell::new(ThreadContex::new()));
-        let mut plugin = ExamplePulgin::new("Example Plugin", thread_ctx.clone());
-        plugin.init();
+        let mut event_mgr = EventManager::new();
+        let mut plugin = ExamplePulgin::new("Example Plugin");
+        plugin.init(&mut event_mgr);
 
-        // Handle packet
+        let mut queue = EventQueue::new();
         let mut packet = Packet::new(&bytes, bytes.len() as u32);
         let result = packet.handle();
         match result {
@@ -242,12 +242,7 @@ mod tests {
             }
         }
 
-        // Dispatch event
-        thread_ctx
-            .borrow_mut()
-            .get_event_mgr()
-            .borrow_mut()
-            .dispatch(Some(&packet));
+        event_mgr.dispatch(Some(&packet), &mut queue);
 
         // assert_eq!(1, 0);
     }
diff --git a/src/main.rs b/src/main.rs
index 49a0728..81ef6f4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,8 +1,9 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-use stellar_rs::event::event::BuiltInEvent;
+use stellar_rs::event::event::Event;
 use stellar_rs::event::manager::EventHandle;
 use stellar_rs::event::manager::EventManager;
+use stellar_rs::event::manager::EventQueue;
 use stellar_rs::packet::capture::PacketCapture;
 use stellar_rs::packet::packet::Encapsulation;
 use stellar_rs::packet::packet::Packet;
@@ -12,61 +13,55 @@ use stellar_rs::session::session::SessionProto;
 use stellar_rs::session::session::SessionState;
 use stellar_rs::thread::thread::ThreadContex;
 
-fn trigger_event_by_packet(
+fn trigger_packet_event(
     packet: &Packet,
     session: Option<Rc<RefCell<Session>>>,
-    event_mgr: Rc<RefCell<EventManager>>,
+    queue: &mut EventQueue,
 ) {
     let num = packet.encapsulation.len();
     for i in 0..num {
         match packet.encapsulation[i] {
-            Encapsulation::L2_ETH(_, _) => {
+            Encapsulation::Eth(_, _) => {
                 // TODO
             }
-            Encapsulation::L2_VLAN(_, _) => {
+            Encapsulation::Vlan(_, _) => {
                 // TODO
             }
-            Encapsulation::L2_MPLS(_, _) => {
+            Encapsulation::Mpls(_, _) => {
                 // TODO
             }
-            Encapsulation::L2_PWETH(_, _) => {
+            Encapsulation::PwEth(_, _) => {
                 // TODO
             }
-            Encapsulation::L3_IPV4(_, _) => {
-                BuiltInEvent::trigger_ipv4_event(event_mgr.clone(), session.clone());
+            Encapsulation::Ipv4(_, _) => {
+                queue.add(Event::Ipv4Event, session.clone());
             }
-            Encapsulation::L3_IPV6(_, _) => {
-                BuiltInEvent::trigger_ipv6_event(event_mgr.clone(), session.clone());
+            Encapsulation::Ipv6(_, _) => {
+                queue.add(Event::Ipv6Event, session.clone());
             }
-            Encapsulation::L4_TCP(_, _) => {
-                BuiltInEvent::trigger_tcp_event(event_mgr.clone(), session.clone());
+            Encapsulation::Tcp(_, _) => {
+                queue.add(Event::TcpEvent, session.clone());
             }
-            Encapsulation::L4_UDP(_, _) => {
-                BuiltInEvent::trigger_udp_event(event_mgr.clone(), session.clone());
+            Encapsulation::Udp(_, _) => {
+                queue.add(Event::UdpEvent, session.clone());
             }
-            Encapsulation::L4_ICMP(_, _) => {
+            Encapsulation::Icmp(_, _) => {
                 // TODO
             }
-            Encapsulation::L4_ICMPV6(_, _) => {
+            Encapsulation::Icmpv6(_, _) => {
                 // TODO
             }
-            Encapsulation::LTUN_GTPV1_C(_, _) => {
+            Encapsulation::Gtpv1(_, _) => {
                 // TODO
             }
-            Encapsulation::LTUN_L2TP(_, _) => {
-                // TODO
-            }
-            Encapsulation::UNSUPPORTED(_) => {
+            Encapsulation::L2tp(_, _) => {
                 // TODO
             }
         }
     }
 }
 
-fn trigger_event_by_session(
-    session: Option<Rc<RefCell<Session>>>,
-    event_mgr: Rc<RefCell<EventManager>>,
-) {
+fn trigger_session_event(session: Option<Rc<RefCell<Session>>>, queue: &mut EventQueue) {
     if session.is_none() {
         return;
     }
@@ -76,31 +71,47 @@ fn trigger_event_by_session(
 
     match session_state {
         SessionState::New => match session_proto {
-            SessionProto::TCP => BuiltInEvent::trigger_tcp_opening_event(event_mgr, session),
-            SessionProto::UDP => BuiltInEvent::trigger_udp_opening_event(event_mgr, session),
+            SessionProto::TCP => {
+                queue.add(Event::TcpOpeningEvent, session);
+            }
+            SessionProto::UDP => {
+                queue.add(Event::UdpOpeningEvent, session);
+            }
         },
         SessionState::Active => match session_proto {
-            SessionProto::TCP => BuiltInEvent::trigger_tcp_active_event(event_mgr, session),
-            SessionProto::UDP => BuiltInEvent::trigger_udp_active_event(event_mgr, session),
+            SessionProto::TCP => {
+                queue.add(Event::TcpActiveEvent, session);
+            }
+            SessionProto::UDP => {
+                queue.add(Event::UdpActiveEvent, session);
+            }
         },
         SessionState::Inactive => match session_proto {
-            SessionProto::TCP => BuiltInEvent::trigger_tcp_closed_event(event_mgr, session),
-            SessionProto::UDP => BuiltInEvent::trigger_udp_expire_event(event_mgr, session),
+            SessionProto::TCP => {
+                queue.add(Event::TcpClosedEvent, session);
+            }
+            SessionProto::UDP => {
+                queue.add(Event::UdpExpireEvent, session);
+            }
         },
         SessionState::Expired => match session_proto {
-            SessionProto::TCP => BuiltInEvent::trigger_tcp_expire_event(event_mgr, session),
-            SessionProto::UDP => BuiltInEvent::trigger_udp_expire_event(event_mgr, session),
+            SessionProto::TCP => {
+                queue.add(Event::TcpExpireEvent, session);
+            }
+            SessionProto::UDP => {
+                queue.add(Event::UdpExpireEvent, session);
+            }
         },
     }
 }
 
 fn handle_one_packet(data: &[u8], len: u32, ctx: Rc<RefCell<ThreadContex>>) {
-    let event_mgr = ctx.borrow_mut().get_event_mgr();
-    let session_mgr = ctx.borrow_mut().get_session_mgr();
+    let event_mgr = ctx.borrow().get_event_mgr();
+    let session_mgr = ctx.borrow().get_session_mgr();
 
+    let mut queue = EventQueue::new();
     let mut packet = Packet::new(data, len);
 
-    // Handle Packet
     let result = packet.handle();
     match result {
         Ok(_left) => {
@@ -116,30 +127,30 @@ fn handle_one_packet(data: &[u8], len: u32, ctx: Rc<RefCell<ThreadContex>>) {
         }
     }
 
-    // Packets have sessions, triggering both packet events and session events
     if packet.get_inner_tuple().is_some() {
         let flow_id = packet.get_flow_id().unwrap();
         let session = session_mgr.borrow_mut().update(flow_id);
-        trigger_event_by_packet(&packet, Some(session.clone()), event_mgr.clone());
-        trigger_event_by_session(Some(session.clone()), event_mgr.clone());
-    // Packets have no sessions, only packet events are triggered
+        trigger_packet_event(&packet, Some(session.clone()), &mut queue);
+        trigger_session_event(Some(session.clone()), &mut queue);
     } else {
-        trigger_event_by_packet(&packet, None, event_mgr.clone());
+        trigger_packet_event(&packet, None, &mut queue);
     }
+    event_mgr.borrow_mut().dispatch(Some(&packet), &mut queue);
 
-    // Handle packet events and session events on the current package
-    event_mgr.borrow_mut().dispatch(Some(&packet));
-
-    // Handle expire events without packets
     let session = session_mgr.borrow_mut().expire_oldest_session();
-    trigger_event_by_session(session, event_mgr.clone());
-    event_mgr.borrow_mut().dispatch(None);
+    trigger_session_event(session, &mut queue);
+    event_mgr.borrow_mut().dispatch(None, &mut queue);
 }
 
 fn main() {
-    let thread_ctx = Rc::new(RefCell::new(ThreadContex::new()));
-    let mut plugin = ExamplePulgin::new("Example Plugin", thread_ctx.clone());
-    plugin.init();
+    let mut event_mgr = EventManager::new();
+    let mut plugin1 = ExamplePulgin::new("Plugin1");
+    let mut plugin2 = ExamplePulgin::new("Plugin2");
+    plugin1.init(&mut event_mgr);
+    plugin2.init(&mut event_mgr);
+
+    let event_mgr = Rc::new(RefCell::new(event_mgr));
+    let thread_ctx = Rc::new(RefCell::new(ThreadContex::new(event_mgr)));
 
     PacketCapture::show_devices();
     let mut cap = PacketCapture::new("en0");
diff --git a/src/packet/capture.rs b/src/packet/capture.rs
index fbbf6d7..6ba8144 100644
--- a/src/packet/capture.rs
+++ b/src/packet/capture.rs
@@ -35,14 +35,8 @@ impl PacketCapture {
     }
 
     pub fn show_devices() {
-        let mut device_num = 0;
         for device in pcap::Device::list().expect("device list failed") {
-            device_num += 1;
-            println!(
-                "======================== Available Device [{}]========================",
-                device_num
-            );
-            println!("{:#?}", device);
+            println!("{:?}", device);
         }
     }
 }
diff --git a/src/packet/packet.rs b/src/packet/packet.rs
index ce7456b..6ab0a71 100644
--- a/src/packet/packet.rs
+++ b/src/packet/packet.rs
@@ -17,26 +17,23 @@ use crate::protocol::udp::UdpHeader;
 use crate::protocol::vlan::VlanHeader;
 use nom::Err::Incomplete;
 
-#[allow(non_camel_case_types)]
 #[derive(Clone, Debug, PartialEq)]
 pub enum Encapsulation<'a> {
-    L2_ETH(EthernetFrame, &'a [u8]),
-    L2_VLAN(VlanHeader, &'a [u8]),
-    L2_MPLS(MplsHeader, &'a [u8]),
-    L2_PWETH(PwEthHeader, &'a [u8]),
+    Eth(EthernetFrame, &'a [u8]),
+    Vlan(VlanHeader, &'a [u8]),
+    Mpls(MplsHeader, &'a [u8]),
+    PwEth(PwEthHeader, &'a [u8]),
 
-    L3_IPV4(Ipv4Header, &'a [u8]),
-    L3_IPV6(Ipv6Header, &'a [u8]),
+    Ipv4(Ipv4Header, &'a [u8]),
+    Ipv6(Ipv6Header, &'a [u8]),
 
-    L4_TCP(TcpHeader, &'a [u8]),
-    L4_UDP(UdpHeader, &'a [u8]),
-    L4_ICMP(IcmpHeader, &'a [u8]),
-    L4_ICMPV6(Icmpv6Header, &'a [u8]),
+    Tcp(TcpHeader, &'a [u8]),
+    Udp(UdpHeader, &'a [u8]),
+    Icmp(IcmpHeader, &'a [u8]),
+    Icmpv6(Icmpv6Header, &'a [u8]),
 
-    LTUN_GTPV1_C(Gtpv1Header, &'a [u8]),
-    LTUN_L2TP(L2tpHeader, &'a [u8]),
-
-    UNSUPPORTED(&'a [u8]),
+    Gtpv1(Gtpv1Header, &'a [u8]),
+    L2tp(L2tpHeader, &'a [u8]),
 }
 
 #[derive(Debug)]
@@ -66,10 +63,10 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in 0..num {
             match self.encapsulation[i] {
-                Encapsulation::L3_IPV4(_, _) => {
+                Encapsulation::Ipv4(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
-                Encapsulation::L3_IPV6(_, _) => {
+                Encapsulation::Ipv6(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
                 _ => continue,
@@ -83,10 +80,10 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in (0..num).rev() {
             match self.encapsulation[i] {
-                Encapsulation::L3_IPV4(_, _) => {
+                Encapsulation::Ipv4(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
-                Encapsulation::L3_IPV6(_, _) => {
+                Encapsulation::Ipv6(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
                 _ => continue,
@@ -100,10 +97,10 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in 0..num {
             match self.encapsulation[i] {
-                Encapsulation::L4_TCP(_, _) => {
+                Encapsulation::Tcp(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
-                Encapsulation::L4_UDP(_, _) => {
+                Encapsulation::Udp(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
                 _ => continue,
@@ -117,10 +114,10 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in (0..num).rev() {
             match self.encapsulation[i] {
-                Encapsulation::L4_TCP(_, _) => {
+                Encapsulation::Tcp(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
-                Encapsulation::L4_UDP(_, _) => {
+                Encapsulation::Udp(_, _) => {
                     return Some(self.encapsulation[i].clone());
                 }
                 _ => continue,
@@ -134,13 +131,13 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in 0..num {
             match self.encapsulation[i] {
-                Encapsulation::L3_IPV4(ref header, _) => {
+                Encapsulation::Ipv4(ref header, _) => {
                     return Some((
                         header.source_address.to_string(),
                         header.dest_address.to_string(),
                     ));
                 }
-                Encapsulation::L3_IPV6(ref header, _) => {
+                Encapsulation::Ipv6(ref header, _) => {
                     return Some((
                         header.source_address.to_string(),
                         header.dest_address.to_string(),
@@ -157,13 +154,13 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in (0..num).rev() {
             match self.encapsulation[i] {
-                Encapsulation::L3_IPV4(ref header, _) => {
+                Encapsulation::Ipv4(ref header, _) => {
                     return Some((
                         header.source_address.to_string(),
                         header.dest_address.to_string(),
                     ));
                 }
-                Encapsulation::L3_IPV6(ref header, _) => {
+                Encapsulation::Ipv6(ref header, _) => {
                     return Some((
                         header.source_address.to_string(),
                         header.dest_address.to_string(),
@@ -180,10 +177,10 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in 0..num {
             match self.encapsulation[i] {
-                Encapsulation::L4_TCP(ref header, _) => {
+                Encapsulation::Tcp(ref header, _) => {
                     return Some((header.source_port, header.dest_port));
                 }
-                Encapsulation::L4_UDP(ref header, _) => {
+                Encapsulation::Udp(ref header, _) => {
                     return Some((header.source_port, header.dest_port));
                 }
                 _ => continue,
@@ -197,10 +194,10 @@ impl Packet<'_> {
         let num = self.encapsulation.len();
         for i in (0..num).rev() {
             match self.encapsulation[i] {
-                Encapsulation::L4_TCP(ref header, _) => {
+                Encapsulation::Tcp(ref header, _) => {
                     return Some((header.source_port, header.dest_port));
                 }
-                Encapsulation::L4_UDP(ref header, _) => {
+                Encapsulation::Udp(ref header, _) => {
                     return Some((header.source_port, header.dest_port));
                 }
                 _ => continue,
@@ -217,8 +214,8 @@ impl Packet<'_> {
         }
         for i in 0..num - 1 {
             match self.encapsulation[i] {
-                Encapsulation::L3_IPV4(ref l3_header, _) => match self.encapsulation[i + 1] {
-                    Encapsulation::L4_TCP(ref l4_header, _) => {
+                Encapsulation::Ipv4(ref l3_header, _) => match self.encapsulation[i + 1] {
+                    Encapsulation::Tcp(ref l4_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -226,7 +223,7 @@ impl Packet<'_> {
                             l4_header.dest_port,
                         ));
                     }
-                    Encapsulation::L4_UDP(ref l4_header, _) => {
+                    Encapsulation::Udp(ref l4_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -236,8 +233,8 @@ impl Packet<'_> {
                     }
                     _ => continue,
                 },
-                Encapsulation::L3_IPV6(ref l3_header, _) => match self.encapsulation[i + 1] {
-                    Encapsulation::L4_TCP(ref l4_header, _) => {
+                Encapsulation::Ipv6(ref l3_header, _) => match self.encapsulation[i + 1] {
+                    Encapsulation::Tcp(ref l4_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -245,7 +242,7 @@ impl Packet<'_> {
                             l4_header.dest_port,
                         ));
                     }
-                    Encapsulation::L4_UDP(ref l4_header, _) => {
+                    Encapsulation::Udp(ref l4_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -269,8 +266,8 @@ impl Packet<'_> {
         }
         for i in (1..num).rev() {
             match self.encapsulation[i] {
-                Encapsulation::L4_TCP(ref l4_header, _) => match self.encapsulation[i - 1] {
-                    Encapsulation::L3_IPV4(ref l3_header, _) => {
+                Encapsulation::Tcp(ref l4_header, _) => match self.encapsulation[i - 1] {
+                    Encapsulation::Ipv4(ref l3_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -278,7 +275,7 @@ impl Packet<'_> {
                             l4_header.dest_port,
                         ));
                     }
-                    Encapsulation::L3_IPV6(ref l3_header, _) => {
+                    Encapsulation::Ipv6(ref l3_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -288,8 +285,8 @@ impl Packet<'_> {
                     }
                     _ => continue,
                 },
-                Encapsulation::L4_UDP(ref l4_header, _) => match self.encapsulation[i - 1] {
-                    Encapsulation::L3_IPV4(ref l3_header, _) => {
+                Encapsulation::Udp(ref l4_header, _) => match self.encapsulation[i - 1] {
+                    Encapsulation::Ipv4(ref l3_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -297,7 +294,7 @@ impl Packet<'_> {
                             l4_header.dest_port,
                         ));
                     }
-                    Encapsulation::L3_IPV6(ref l3_header, _) => {
+                    Encapsulation::Ipv6(ref l3_header, _) => {
                         return Some((
                             l3_header.source_address.to_string(),
                             l4_header.source_port,
@@ -319,26 +316,26 @@ impl Packet<'_> {
         let mut flow_id = String::new();
         for i in 0..num {
             match self.encapsulation[i] {
-                Encapsulation::L3_IPV4(ref l3_header, _) => {
+                Encapsulation::Ipv4(ref l3_header, _) => {
                     flow_id.push_str(&l3_header.source_address.to_string());
                     flow_id.push_str("->");
                     flow_id.push_str(&l3_header.dest_address.to_string());
                     flow_id.push_str(";");
                 }
-                Encapsulation::L3_IPV6(ref l3_header, _) => {
+                Encapsulation::Ipv6(ref l3_header, _) => {
                     flow_id.push_str(&l3_header.source_address.to_string());
                     flow_id.push_str("->");
                     flow_id.push_str(&l3_header.dest_address.to_string());
                     flow_id.push_str(";");
                 }
-                Encapsulation::L4_TCP(ref l4_header, _) => {
+                Encapsulation::Tcp(ref l4_header, _) => {
                     flow_id.push_str("TCP->TCP;");
                     flow_id.push_str(&l4_header.source_port.to_string());
                     flow_id.push_str("->");
                     flow_id.push_str(&l4_header.dest_port.to_string());
                     flow_id.push_str(";");
                 }
-                Encapsulation::L4_UDP(ref l4_header, _) => {
+                Encapsulation::Udp(ref l4_header, _) => {
                     flow_id.push_str("UDP->UDP;");
                     flow_id.push_str(&l4_header.source_port.to_string());
                     flow_id.push_str("->");
@@ -361,7 +358,7 @@ fn handle_eth<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packet
         let next_proto = header.ether_type;
         packet
             .encapsulation
-            .push(Encapsulation::L2_ETH(header, payload));
+            .push(Encapsulation::Eth(header, payload));
 
         return handle_l3(packet, payload, next_proto);
     } else {
@@ -377,7 +374,7 @@ fn handle_vlan<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packe
         let next_proto = header.ether_type;
         packet
             .encapsulation
-            .push(Encapsulation::L2_VLAN(header, payload));
+            .push(Encapsulation::Vlan(header, payload));
 
         return handle_l3(packet, payload, next_proto);
     } else {
@@ -393,7 +390,7 @@ fn handle_mpls<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packe
         let bottom_of_stack = header.bottom_of_stack;
         packet
             .encapsulation
-            .push(Encapsulation::L2_MPLS(header, payload));
+            .push(Encapsulation::Mpls(header, payload));
 
         if bottom_of_stack {
             if payload.len() < 1 {
@@ -422,7 +419,7 @@ fn handle_pw_eth<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Pac
 
         packet
             .encapsulation
-            .push(Encapsulation::L2_PWETH(header, payload));
+            .push(Encapsulation::PwEth(header, payload));
 
         return handle_eth(packet, payload);
     } else {
@@ -438,7 +435,7 @@ fn handle_ipv4<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packe
         let next_proto = header.protocol;
         packet
             .encapsulation
-            .push(Encapsulation::L3_IPV4(header, payload));
+            .push(Encapsulation::Ipv4(header, payload));
 
         // TODO IPv4 Fragment
 
@@ -464,7 +461,7 @@ fn handle_ipv6<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packe
 
         packet
             .encapsulation
-            .push(Encapsulation::L3_IPV6(header, payload));
+            .push(Encapsulation::Ipv6(header, payload));
 
         return handle_l4(packet, payload, next_proto);
     } else {
@@ -479,7 +476,7 @@ fn handle_tcp<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packet
 
         packet
             .encapsulation
-            .push(Encapsulation::L4_TCP(header, payload));
+            .push(Encapsulation::Tcp(header, payload));
 
         // TODO TCP Reassembly
 
@@ -497,7 +494,7 @@ fn handle_udp<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packet
         let dest_port = header.dest_port;
         packet
             .encapsulation
-            .push(Encapsulation::L4_UDP(header, payload));
+            .push(Encapsulation::Udp(header, payload));
 
         match dest_port {
             // GTP-U
@@ -518,7 +515,7 @@ fn handle_icmp<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packe
 
         packet
             .encapsulation
-            .push(Encapsulation::L4_ICMP(header, payload));
+            .push(Encapsulation::Icmp(header, payload));
 
         return Ok(());
     } else {
@@ -533,7 +530,7 @@ fn handle_icmpv6<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Pac
 
         packet
             .encapsulation
-            .push(Encapsulation::L4_ICMPV6(header, payload));
+            .push(Encapsulation::Icmpv6(header, payload));
 
         return Ok(());
     } else {
@@ -549,7 +546,7 @@ fn handle_gtpv1<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Pack
 
             packet
                 .encapsulation
-                .push(Encapsulation::LTUN_GTPV1_C(header, payload));
+                .push(Encapsulation::Gtpv1(header, payload));
 
             if payload.len() < 1 {
                 return Ok(());
@@ -580,7 +577,7 @@ fn handle_l2tp<'a>(packet: &mut Packet<'a>, input: &'a [u8]) -> Result<(), Packe
             let l2tp_type = header.flag_type;
             packet
                 .encapsulation
-                .push(Encapsulation::LTUN_L2TP(header, payload));
+                .push(Encapsulation::L2tp(header, payload));
 
             match l2tp_type {
                 L2tpType::Control => {
@@ -724,16 +721,16 @@ mod tests {
 
         packet
             .encapsulation
-            .push(Encapsulation::L3_IPV4(ipv4_hdr.clone(), b"1"));
+            .push(Encapsulation::Ipv4(ipv4_hdr.clone(), b"1"));
         packet
             .encapsulation
-            .push(Encapsulation::L4_TCP(tcp_hdr.clone(), b"2"));
+            .push(Encapsulation::Tcp(tcp_hdr.clone(), b"2"));
         packet
             .encapsulation
-            .push(Encapsulation::L3_IPV6(ipv6_hdr.clone(), b"3"));
+            .push(Encapsulation::Ipv6(ipv6_hdr.clone(), b"3"));
         packet
             .encapsulation
-            .push(Encapsulation::L4_UDP(udp_hdr.clone(), b"4"));
+            .push(Encapsulation::Udp(udp_hdr.clone(), b"4"));
 
         assert_eq!(
             packet.get_outer_address(),
@@ -771,19 +768,19 @@ mod tests {
 
         assert_eq!(
             packet.get_outer_l3_layer(),
-            Some(Encapsulation::L3_IPV4(ipv4_hdr, b"1"))
+            Some(Encapsulation::Ipv4(ipv4_hdr, b"1"))
         );
         assert_eq!(
             packet.get_inner_l3_layer(),
-            Some(Encapsulation::L3_IPV6(ipv6_hdr, b"3"))
+            Some(Encapsulation::Ipv6(ipv6_hdr, b"3"))
         );
         assert_eq!(
             packet.get_outer_l4_layer(),
-            Some(Encapsulation::L4_TCP(tcp_hdr, b"2"))
+            Some(Encapsulation::Tcp(tcp_hdr, b"2"))
         );
         assert_eq!(
             packet.get_inner_l4_layer(),
-            Some(Encapsulation::L4_UDP(udp_hdr, b"4"))
+            Some(Encapsulation::Udp(udp_hdr, b"4"))
         );
 
         assert_eq!(packet.get_flow_id(), Some("192.168.0.101->121.14.154.93;TCP->TCP;50081->443;2409:8034:4025::50:a31->2409:8034:4040:5301::204;UDP->UDP;9993->9994;".to_string()));
@@ -910,7 +907,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 5);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0x00, 0x13, 0xc3, 0xdf, 0xae, 0x18]),
                     dest_mac: MacAddress([0x00, 0x1b, 0xd4, 0x1b, 0xa4, 0xd8]),
@@ -921,7 +918,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L2_VLAN(
+            Encapsulation::Vlan(
                 VlanHeader {
                     priority_code_point: 0,
                     drop_eligible_indicator: false,
@@ -933,7 +930,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L2_VLAN(
+            Encapsulation::Vlan(
                 VlanHeader {
                     priority_code_point: 0,
                     drop_eligible_indicator: false,
@@ -945,7 +942,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -965,7 +962,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[4],
-            Encapsulation::L4_TCP(
+            Encapsulation::Tcp(
                 TcpHeader {
                     source_port: 2048,
                     dest_port: 52912,
@@ -1109,7 +1106,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 5);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0xa2, 0xc1, 0x12, 0x03, 0x02, 0x03]),
                     dest_mac: MacAddress([0xa2, 0xc1, 0x12, 0x03, 0x01, 0x64]),
@@ -1120,7 +1117,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L2_VLAN(
+            Encapsulation::Vlan(
                 VlanHeader {
                     priority_code_point: 0,
                     drop_eligible_indicator: false,
@@ -1132,7 +1129,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L2_VLAN(
+            Encapsulation::Vlan(
                 VlanHeader {
                     priority_code_point: 0,
                     drop_eligible_indicator: false,
@@ -1144,7 +1141,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -1164,7 +1161,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[4],
-            Encapsulation::L4_TCP(
+            Encapsulation::Tcp(
                 TcpHeader {
                     source_port: 10000,
                     dest_port: 80,
@@ -1362,7 +1359,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 4);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0x00, 0x22, 0x46, 0x36, 0x51, 0x3c]),
                     dest_mac: MacAddress([0x00, 0x22, 0x46, 0x36, 0x51, 0x38]),
@@ -1373,7 +1370,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L3_IPV6(
+            Encapsulation::Ipv6(
                 Ipv6Header {
                     version: 6,
                     dsc: 0,
@@ -1391,7 +1388,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -1411,7 +1408,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L4_TCP(
+            Encapsulation::Tcp(
                 TcpHeader {
                     source_port: 57639,
                     dest_port: 22,
@@ -1565,7 +1562,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 4);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0x2c, 0x6b, 0xf5, 0x45, 0x88, 0x29]),
                     dest_mac: MacAddress([0x5c, 0x5e, 0xab, 0x2a, 0xa2, 0x00]),
@@ -1576,7 +1573,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -1596,7 +1593,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L3_IPV6(
+            Encapsulation::Ipv6(
                 Ipv6Header {
                     version: 6,
                     dsc: 0,
@@ -1618,7 +1615,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L4_TCP(
+            Encapsulation::Tcp(
                 TcpHeader {
                     source_port: 52556,
                     dest_port: 80,
@@ -1732,7 +1729,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 4);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
                     dest_mac: MacAddress([0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
@@ -1743,7 +1740,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L3_IPV6(
+            Encapsulation::Ipv6(
                 Ipv6Header {
                     version: 6,
                     dsc: 0,
@@ -1765,7 +1762,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L3_IPV6(
+            Encapsulation::Ipv6(
                 Ipv6Header {
                     version: 6,
                     dsc: 0,
@@ -1787,7 +1784,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L4_UDP(
+            Encapsulation::Udp(
                 UdpHeader {
                     source_port: 30000,
                     dest_port: 13000,
@@ -1920,7 +1917,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 6);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0xa4, 0xc6, 0x4f, 0x3b, 0xb3, 0x9a]),
                     dest_mac: MacAddress([0x00, 0x00, 0x00, 0x00, 0x00, 0x04]),
@@ -1931,7 +1928,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L2_VLAN(
+            Encapsulation::Vlan(
                 VlanHeader {
                     priority_code_point: 3,
                     drop_eligible_indicator: false,
@@ -1943,7 +1940,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L2_VLAN(
+            Encapsulation::Vlan(
                 VlanHeader {
                     priority_code_point: 3,
                     drop_eligible_indicator: false,
@@ -1955,7 +1952,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -1975,7 +1972,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[4],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -1995,7 +1992,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[5],
-            Encapsulation::L4_UDP(
+            Encapsulation::Udp(
                 UdpHeader {
                     source_port: 62367,
                     dest_port: 17000,
@@ -2127,7 +2124,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 5);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0x00, 0x30, 0x96, 0x05, 0x28, 0x38]),
                     dest_mac: MacAddress([0x00, 0x30, 0x96, 0xe6, 0xfc, 0x39]),
@@ -2138,7 +2135,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L2_MPLS(
+            Encapsulation::Mpls(
                 MplsHeader {
                     label: 18,
                     experimental: 5,
@@ -2150,7 +2147,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L2_MPLS(
+            Encapsulation::Mpls(
                 MplsHeader {
                     label: 16,
                     experimental: 5,
@@ -2162,7 +2159,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -2182,7 +2179,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[4],
-            Encapsulation::L4_TCP(
+            Encapsulation::Tcp(
                 TcpHeader {
                     source_port: 11001,
                     dest_port: 23,
@@ -2319,7 +2316,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 7);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0xcc, 0x01, 0x0d, 0x5c, 0x00, 0x10]),
                     dest_mac: MacAddress([0xcc, 0x00, 0x0d, 0x5c, 0x00, 0x10]),
@@ -2330,7 +2327,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L2_MPLS(
+            Encapsulation::Mpls(
                 MplsHeader {
                     label: 19,
                     experimental: 0,
@@ -2342,7 +2339,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L2_MPLS(
+            Encapsulation::Mpls(
                 MplsHeader {
                     label: 16,
                     experimental: 0,
@@ -2354,11 +2351,11 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L2_PWETH(PwEthHeader { control_word: 0 }, &bytes[26..])
+            Encapsulation::PwEth(PwEthHeader { control_word: 0 }, &bytes[26..])
         );
         assert_eq!(
             packet.encapsulation[4],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0x00, 0x50, 0x79, 0x66, 0x68, 0x00]),
                     dest_mac: MacAddress([0x00, 0x50, 0x79, 0x66, 0x68, 0x01]),
@@ -2369,7 +2366,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[5],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -2389,7 +2386,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[6],
-            Encapsulation::L4_ICMP(
+            Encapsulation::Icmp(
                 IcmpHeader {
                     icmp_type: IcmpType::EchoRequest,
                     icmp_code: 0,
@@ -2556,7 +2553,7 @@ mod tests {
         assert_eq!(packet.encapsulation.len(), 7);
         assert_eq!(
             packet.encapsulation[0],
-            Encapsulation::L2_ETH(
+            Encapsulation::Eth(
                 EthernetFrame {
                     source_mac: MacAddress([0xac, 0xb3, 0xb5, 0x40, 0xe9, 0xc3]),
                     dest_mac: MacAddress([0x74, 0x4a, 0xa4, 0x0e, 0xf5, 0x14]),
@@ -2567,7 +2564,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[1],
-            Encapsulation::L2_VLAN(
+            Encapsulation::Vlan(
                 VlanHeader {
                     priority_code_point: 2,
                     drop_eligible_indicator: false,
@@ -2579,7 +2576,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[2],
-            Encapsulation::L3_IPV6(
+            Encapsulation::Ipv6(
                 Ipv6Header {
                     version: 6,
                     dsc: 18,
@@ -2597,7 +2594,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[3],
-            Encapsulation::L4_UDP(
+            Encapsulation::Udp(
                 UdpHeader {
                     source_port: 2152,
                     dest_port: 2152,
@@ -2609,7 +2606,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[4],
-            Encapsulation::LTUN_GTPV1_C(
+            Encapsulation::Gtpv1(
                 Gtpv1Header {
                     version: 1,
                     protocol_type: 1,
@@ -2636,7 +2633,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[5],
-            Encapsulation::L3_IPV4(
+            Encapsulation::Ipv4(
                 Ipv4Header {
                     version: 4,
                     ihl: 20,
@@ -2656,7 +2653,7 @@ mod tests {
         );
         assert_eq!(
             packet.encapsulation[6],
-            Encapsulation::L4_TCP(
+            Encapsulation::Tcp(
                 TcpHeader {
                     source_port: 47892,
                     dest_port: 80,
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);
+            }
         }
     }
 }
diff --git a/src/protocol/http.rs b/src/protocol/http.rs
index 289b915..e8d33f0 100644
--- a/src/protocol/http.rs
+++ b/src/protocol/http.rs
@@ -1,24 +1,23 @@
 use crate::protocol::codec::Decode;
 use nom::IResult;
 
-#[allow(non_camel_case_types)]
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct HTTP_MESSAGE {
+pub struct HttpMessage {
     // TODO
 }
 
-impl HTTP_MESSAGE {
-    pub fn new() -> HTTP_MESSAGE {
-        HTTP_MESSAGE {
+impl HttpMessage {
+    pub fn new() -> HttpMessage {
+        HttpMessage {
             // TODO
         }
     }
 }
 
-impl Decode for HTTP_MESSAGE {
-    type Iterm = HTTP_MESSAGE;
-    fn decode(input: &[u8]) -> IResult<&[u8], HTTP_MESSAGE> {
-        let message = HTTP_MESSAGE::new();
+impl Decode for HttpMessage {
+    type Iterm = HttpMessage;
+    fn decode(input: &[u8]) -> IResult<&[u8], HttpMessage> {
+        let message = HttpMessage::new();
         // TODO
         Ok((input, message))
     }
diff --git a/src/thread/thread.rs b/src/thread/thread.rs
index d13c271..75e7ab6 100644
--- a/src/thread/thread.rs
+++ b/src/thread/thread.rs
@@ -9,9 +9,9 @@ pub struct ThreadContex {
 }
 
 impl ThreadContex {
-    pub fn new() -> Self {
+    pub fn new(event_mgr: Rc<RefCell<EventManager>>) -> Self {
         ThreadContex {
-            event_mgr: Rc::new(RefCell::new(EventManager::new())),
+            event_mgr,
             session_mgr: Rc::new(RefCell::new(SessionManager::new(4096))),
         }
     }