test case work

1 files changed, 179 insertions, 0 deletions

diff --git a/examples/runtime_test.rs b/examples/runtime_test.rs
new file mode 100644
index 0000000..8edcfe7
--- /dev/null
+++ b/examples/runtime_test.rs
@@ -0,0 +1,179 @@
+use std::{cell::RefCell, rc::Rc};
+
+use futures::join;
+use futures_util::StreamExt;
+use stellar_rs::{
+    event::{
+        event::Event,
+        manager::{get_eventmange, EventManager},
+    },
+    get_innermost_special_encapsulation,
+    packet::{
+        capture::{BoxCodec, PacketCapture},
+        packet::{Encapsulation, Packet},
+        status::{PacketMetrics, PacketStatus},
+    },
+    plugin::{example::ExamplePulgin, plugin::PHandleExt},
+    runtime::executor::{Executor, EX},
+    session::{
+        manager::get_sessionmange,
+        session::{Session, SessionProto, SessionState},
+    },
+};
+
+fn main() {
+    let ex = Executor::new();
+    ex.block_on(test1);
+}
+
+async fn test1() {
+    let mut plugin1 = ExamplePulgin::new("Plugin1");
+    let mut plugin2 = ExamplePulgin::new("Plugin2");
+    plugin1.init();
+    plugin2.init();
+
+    let event_mgr = get_eventmange();
+    let session_mgr = get_sessionmange();
+    let mut packet_metrics = PacketMetrics::new();
+
+    let cap = PacketCapture::new("eth0");
+    let mut stream = cap.stream(BoxCodec);
+
+    while let Some(temp) = stream.next().await {
+        let packet_pacp = temp.unwrap();
+        let mut packet = Packet::new(&packet_pacp, packet_pacp.len().try_into().unwrap());
+        let result = packet.handle();
+
+        match result {
+            Ok(_) => {
+                packet_metrics.add(PacketStatus::Normal);
+                // println!("Ok Packet: {:?}", packet);
+            }
+            Err(e) => {
+                packet_metrics.add(e);
+                println!("Unexpected Packet: {:?} {:?}", e, packet);
+                return;
+            }
+        }
+        let mut session: Option<Rc<RefCell<Session>>> = Option::None;
+        match get_innermost_special_encapsulation!(packet, TCP | UDP) {
+            Some(_) => {
+                let flow_id = packet.get_flow_id().unwrap();
+                session = Some(session_mgr.borrow_mut().update(flow_id));
+                trigger_packet_event(&packet, event_mgr.clone());
+                trigger_session_event(session.clone(), event_mgr.clone());
+            }
+            None => {
+                trigger_packet_event(&packet, event_mgr.clone());
+                session = None
+            }
+        }
+        join!(
+            plugin1.handle(Some(&packet), session.clone()),
+            plugin2.handle(Some(&packet), session.clone())
+        );
+    }
+}
+
+fn trigger_packet_event(packet: &Packet, em: Rc<RefCell<EventManager>>) {
+    let num = packet.encapsulation.len();
+    for i in 0..num {
+        match packet.encapsulation[i] {
+            Encapsulation::ETH(_, _) => {
+                // TODO
+            }
+            Encapsulation::VLAN(_, _) => {
+                // TODO
+            }
+            Encapsulation::MPLS(_, _) => {
+                // TODO
+            }
+            Encapsulation::PWETH(_, _) => {
+                // TODO
+            }
+            Encapsulation::IPv4(_, _) => {
+                em.borrow_mut().trigger(Event::IPv4Event);
+            }
+            Encapsulation::IPv6(_, _) => {
+                em.borrow_mut().trigger(Event::IPv6Event);
+            }
+            Encapsulation::GREv0(_, _) => {
+                // TODO
+            }
+            Encapsulation::GREv1(_, _) => {
+                // TODO
+            }
+            Encapsulation::TCP(_, _) => {
+                em.borrow_mut().trigger(Event::TCPEvent);
+            }
+            Encapsulation::UDP(_, _) => {
+                em.borrow_mut().trigger(Event::UDPEvent);
+            }
+            Encapsulation::ICMP(_, _) => {
+                // TODO
+            }
+            Encapsulation::ICMPv6(_, _) => {
+                // TODO
+            }
+            Encapsulation::GTPv1(_, _) => {
+                // TODO
+            }
+            Encapsulation::L2TP(_, _) => {
+                // TODO
+            }
+            Encapsulation::PPTP(_, _) => {
+                // TODO
+            }
+            Encapsulation::PPP(_, _) => {
+                // TODO
+            }
+            Encapsulation::PPPoE(_, _) => {
+                // TODO
+            }
+        }
+    }
+}
+
+fn trigger_session_event(session: Option<Rc<RefCell<Session>>>, em: Rc<RefCell<EventManager>>) {
+    if session.is_none() {
+        return;
+    }
+
+    let session_state = session.clone().unwrap().borrow_mut().get_session_state();
+    let session_proto = session.clone().unwrap().borrow_mut().get_session_proto();
+
+    match session_state {
+        SessionState::New => match session_proto {
+            SessionProto::TCP => {
+                em.borrow_mut().trigger(Event::TCPOpeningEvent);
+            }
+            SessionProto::UDP => {
+                em.borrow_mut().trigger(Event::UDPOpeningEvent);
+            }
+        },
+        SessionState::Active => match session_proto {
+            SessionProto::TCP => {
+                em.borrow_mut().trigger(Event::TCPActiveEvent);
+            }
+            SessionProto::UDP => {
+                em.borrow_mut().trigger(Event::UDPActiveEvent);
+            }
+        },
+        SessionState::Inactive => match session_proto {
+            SessionProto::TCP => {
+                em.borrow_mut().trigger(Event::TCPClosedEvent);
+            }
+            SessionProto::UDP => {
+                em.borrow_mut().trigger(Event::UDPExpireEvent);
+            }
+        },
+        SessionState::Expired => match session_proto {
+            SessionProto::TCP => {
+                em.borrow_mut().trigger(Event::TCPExpireEvent);
+            }
+            SessionProto::UDP => {
+                em.borrow_mut().trigger(Event::UDPExpireEvent);
+            }
+        },
+    }
+}