Correctly call all adapter lifecycle methods, docs and test

[m17rt] / m17app / src / app.rs

diff --git a/m17app/src/app.rs b/m17app/src/app.rs
index ae019768fe97876bf8960c25f0243e42186e1044..d7c3fb2c129ba43b776296f6cacfb7e5b6621d11 100644 (file)
--- a/m17app/src/app.rs
+++ b/m17app/src/app.rs
@@ -1,8 +1,10 @@
 use crate::adapter::{PacketAdapter, StreamAdapter};
+use crate::error::M17Error;
 use crate::link_setup::LinkSetup;
 use crate::tnc::Tnc;
+use crate::{LsfFrame, PacketType, StreamFrame};
 use m17core::kiss::{KissBuffer, KissCommand, KissFrame};
-use m17core::protocol::{EncryptionType, LsfFrame, PacketType, StreamFrame};
+use m17core::protocol::EncryptionType;
 
 use log::debug;
 use std::collections::HashMap;
@@ -69,10 +71,28 @@ impl M17App {
     }
 
     pub fn start(&self) {
+        {
+            let adapters = self.adapters.read().unwrap();
+            for (_, p) in &adapters.packet {
+                p.tnc_started();
+            }
+            for (_, s) in &adapters.stream {
+                s.tnc_started();
+            }
+        }
         let _ = self.event_tx.send(TncControlEvent::Start);
     }
 
     pub fn close(&self) {
+        {
+            let adapters = self.adapters.read().unwrap();
+            for (_, p) in &adapters.packet {
+                p.tnc_closed();
+            }
+            for (_, s) in &adapters.stream {
+                s.tnc_closed();
+            }
+        }
         // TODO: blocking function to indicate TNC has finished closing
         // then we could call this in a signal handler to ensure PTT is dropped before quit
         let _ = self.event_tx.send(TncControlEvent::Close);
@@ -84,11 +104,18 @@ pub struct TxHandle {
 }
 
 impl TxHandle {
-    pub fn transmit_packet(&self, link_setup: &LinkSetup, packet_type: PacketType, payload: &[u8]) {
+    pub fn transmit_packet(
+        &self,
+        link_setup: &LinkSetup,
+        packet_type: PacketType,
+        payload: &[u8],
+    ) -> Result<(), M17Error> {
         let (pack_type, pack_type_len) = packet_type.as_proto();
         if pack_type_len + payload.len() > 823 {
-            // TODO: error for invalid transmission type
-            return;
+            return Err(M17Error::PacketTooLarge {
+                provided: payload.len(),
+                capacity: 823 - pack_type_len,
+            });
         }
         let mut full_payload = vec![];
         full_payload.extend_from_slice(&pack_type[0..pack_type_len]);
@@ -97,6 +124,7 @@ impl TxHandle {
         full_payload.extend_from_slice(&crc.to_be_bytes());
         let kiss_frame = KissFrame::new_full_packet(&link_setup.raw.0, &full_payload).unwrap();
         let _ = self.event_tx.send(TncControlEvent::Kiss(kiss_frame));
+        Ok(())
     }
 
     pub fn transmit_stream_start(&self, link_setup: &LinkSetup) {
@@ -282,3 +310,94 @@ fn spawn_writer<T: Tnc>(mut tnc: T, event_rx: mpsc::Receiver<TncControlEvent>) {
         }
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{link_setup::M17Address, test_util::NullTnc};
+
+    use super::*;
+
+    #[test]
+    fn packet_payload_len() {
+        let app = M17App::new(NullTnc);
+        let res = app.tx().transmit_packet(
+            &LinkSetup::new_packet(&M17Address::new_broadcast(), &M17Address::new_broadcast()),
+            PacketType::Raw,
+            &[0u8; 100],
+        );
+        assert_eq!(res, Ok(()));
+        let res = app.tx().transmit_packet(
+            &LinkSetup::new_packet(&M17Address::new_broadcast(), &M17Address::new_broadcast()),
+            PacketType::Raw,
+            &[0u8; 900],
+        );
+        assert_eq!(
+            res,
+            Err(M17Error::PacketTooLarge {
+                provided: 900,
+                capacity: 822
+            })
+        );
+    }
+
+    #[test]
+    fn adapter_lifecycle() {
+        #[derive(Debug, PartialEq)]
+        enum Event {
+            Registered(usize),
+            Removed,
+            Started,
+            Closed,
+        }
+        macro_rules! event_impl {
+            ($target:ty, $trait:ty) => {
+                impl $trait for $target {
+                    fn adapter_registered(&self, id: usize, _handle: TxHandle) {
+                        self.0.send(Event::Registered(id)).unwrap();
+                    }
+
+                    fn adapter_removed(&self) {
+                        self.0.send(Event::Removed).unwrap();
+                    }
+
+                    fn tnc_started(&self) {
+                        self.0.send(Event::Started).unwrap();
+                    }
+
+                    fn tnc_closed(&self) {
+                        self.0.send(Event::Closed).unwrap();
+                    }
+                }
+            };
+        }
+        struct FakePacket(mpsc::SyncSender<Event>);
+        struct FakeStream(mpsc::SyncSender<Event>);
+        event_impl!(FakePacket, PacketAdapter);
+        event_impl!(FakeStream, StreamAdapter);
+
+        let app = M17App::new(NullTnc);
+        let (tx_p, rx_p) = mpsc::sync_channel(128);
+        let (tx_s, rx_s) = mpsc::sync_channel(128);
+        let packet = FakePacket(tx_p);
+        let stream = FakeStream(tx_s);
+
+        let id_p = app.add_packet_adapter(packet);
+        let id_s = app.add_stream_adapter(stream);
+        app.start();
+        app.close();
+        app.remove_packet_adapter(id_p);
+        app.remove_stream_adapter(id_s);
+
+        assert_eq!(rx_p.try_recv(), Ok(Event::Registered(0)));
+        assert_eq!(rx_p.try_recv(), Ok(Event::Started));
+        assert_eq!(rx_p.try_recv(), Ok(Event::Closed));
+        assert_eq!(rx_p.try_recv(), Ok(Event::Removed));
+        assert_eq!(rx_p.try_recv(), Err(mpsc::TryRecvError::Disconnected));
+
+        assert_eq!(rx_s.try_recv(), Ok(Event::Registered(1)));
+        assert_eq!(rx_s.try_recv(), Ok(Event::Started));
+        assert_eq!(rx_s.try_recv(), Ok(Event::Closed));
+        assert_eq!(rx_s.try_recv(), Ok(Event::Removed));
+        assert_eq!(rx_s.try_recv(), Err(mpsc::TryRecvError::Disconnected));
+    }
+}