Merge pull request #19 from Sympatron/channel-rework

sidcha · web-flow · commit 2c104245e2ee · 2024-10-29T13:57:04.000+01:00
Allow for Channels to be easily shared between PDs
diff --git a/libosdp/examples/cp.rs b/libosdp/examples/cp.rs
@@ -57,10 +57,10 @@ fn main() -> Result<(), OsdpError> {
         .address(101)?
         .baud_rate(115200)?
         .flag(OsdpFlag::EnforceSecure)
-        .channel(Box::new(channel))
-        .secure_channel_key(pd_0_key)
-        .build();
-    let mut cp = libosdp::ControlPanel::new(vec![pd_0])?;
+        .secure_channel_key(pd_0_key);
+    let mut cp = libosdp::ControlPanelBuilder::new()
+        .add_channel(Box::new(channel), vec![pd_0])
+        .build()?;
     loop {
         cp.refresh();
         thread::sleep(Duration::from_millis(50));
diff --git a/libosdp/examples/pd.rs b/libosdp/examples/pd.rs
@@ -60,10 +60,8 @@ fn main() -> Result<(), OsdpError> {
         .baud_rate(115200)?
         .flag(OsdpFlag::EnforceSecure)
         .capability(PdCapability::CommunicationSecurity(PdCapEntity::new(1, 1)))
-        .channel(Box::new(channel))
-        .secure_channel_key(key)
-        .build();
-    let mut pd = libosdp::PeripheralDevice::new(pd_info)?;
+        .secure_channel_key(key);
+    let mut pd = libosdp::PeripheralDevice::new(pd_info, Box::new(channel))?;
     pd.set_command_callback(|_| {
         println!("Received command!");
         0
diff --git a/libosdp/src/channel.rs b/libosdp/src/channel.rs
@@ -51,7 +51,7 @@ impl<E: embedded_io::Error + Sized> From<E> for ChannelError {
 
 /// The Channel trait acts as an interface for all channel implementors. See
 /// module description for the definition of a "channel" in LibOSDP.
-pub trait Channel: Send + Sync {
+pub trait Channel: Send {
     /// Since OSDP channels can be multi-drop (more than one PD can talk to a
     /// CP on the same channel) and LibOSDP supports mixing multi-drop
     /// connections among PDs it needs a way to identify each unique channel by
diff --git a/libosdp/src/cp.rs b/libosdp/src/cp.rs
@@ -7,7 +7,8 @@
 //! (PD) on the OSDP bus. It can send commands to and receive events from PDs.
 
 use crate::{
-    file::OsdpFileOps, OsdpCommand, OsdpError, OsdpEvent, OsdpFlag, PdCapability, PdId, PdInfo,
+    file::OsdpFileOps, Channel, OsdpCommand, OsdpError, OsdpEvent, OsdpFlag, PdCapability, PdId,
+    PdInfoBuilder,
 };
 use alloc::{boxed::Box, vec::Vec};
 use core::ffi::c_void;
@@ -64,27 +65,58 @@ fn cp_setup(info: Vec<crate::OsdpPdInfoHandle>) -> Result<*mut c_void> {
     }
 }
 
-/// OSDP CP device context.
-#[derive(Debug)]
-pub struct ControlPanel {
-    ctx: *mut core::ffi::c_void,
+/// Builder for creating a new `ControlPanel`.
+#[derive(Debug, Default)]
+pub struct ControlPanelBuilder {
+    channel_pds: Vec<(Box<dyn Channel>, Vec<PdInfoBuilder>)>,
 }
 
-unsafe impl Send for ControlPanel {}
+impl ControlPanelBuilder {
+    /// Create a new instance of [`ControlPanelBuilder`].
+    pub const fn new() -> Self {
+        Self {
+            channel_pds: Vec::new(),
+        }
+    }
 
-impl ControlPanel {
-    /// Create a new CP context for the list of PDs described by the [`PdInfo`] vector.
-    pub fn new(pd_info: Vec<PdInfo>) -> Result<Self> {
-        if pd_info.len() > 126 {
+    /// Add a new PDs and their shared channel to the CP.
+    pub fn add_channel(mut self, channel: Box<dyn Channel>, pd_info: Vec<PdInfoBuilder>) -> Self {
+        self.channel_pds.push((channel, pd_info));
+        self
+    }
+
+    /// Build the [`ControlPanel`] instance.
+    pub fn build(self) -> Result<ControlPanel> {
+        if self.channel_pds.len() > 126 {
             return Err(OsdpError::PdInfo("max PD count exceeded"));
         }
-        let info: Vec<crate::OsdpPdInfoHandle> = pd_info.into_iter().map(|i| i.into()).collect();
+        let info: Vec<crate::OsdpPdInfoHandle> = self
+            .channel_pds
+            .into_iter()
+            .map(|(channel, pd_info)| {
+                let channel: libosdp_sys::osdp_channel = channel.into();
+                pd_info
+                    .into_iter()
+                    .map(move |pd| pd.channel(channel).build().into())
+            })
+            .flatten()
+            .collect();
         unsafe { libosdp_sys::osdp_set_log_callback(Some(log_handler)) };
-        Ok(Self {
+        Ok(ControlPanel {
             ctx: cp_setup(info)?,
         })
     }
+}
+
+/// OSDP CP device context.
+#[derive(Debug)]
+pub struct ControlPanel {
+    ctx: *mut core::ffi::c_void,
+}
 
+unsafe impl Send for ControlPanel {}
+
+impl ControlPanel {
     /// The application must call this method periodically to refresh the
     /// underlying LibOSDP state. To meet the OSDP timing guarantees, this
     /// function must be called at least once every 50ms. This method does not
diff --git a/libosdp/src/lib.rs b/libosdp/src/lib.rs
@@ -88,7 +88,7 @@ use alloc::{borrow::ToOwned, boxed::Box, format, string::String};
 #[cfg(feature = "std")]
 use thiserror::Error;
 
-pub use cp::ControlPanel;
+pub use cp::{ControlPanel, ControlPanelBuilder};
 pub use pd::PeripheralDevice;
 
 /// OSDP public errors
diff --git a/libosdp/src/pd.rs b/libosdp/src/pd.rs
@@ -12,8 +12,10 @@
 //! happens on the PD itself (such as card read, key press, etc.,) snd sends it
 //! to the CP.
 
-use crate::{OsdpCommand, OsdpError, OsdpEvent, OsdpFileOps, PdCapability, PdInfo};
-use alloc::{boxed::Box, vec::Vec};
+use crate::{
+    Box, Channel, OsdpCommand, OsdpError, OsdpEvent, OsdpFileOps, PdCapability, PdInfo,
+    PdInfoBuilder,
+};
 use core::ffi::c_void;
 use log::{debug, error, info, warn};
 
@@ -77,10 +79,10 @@ pub struct PeripheralDevice {
 unsafe impl Send for PeripheralDevice {}
 
 impl PeripheralDevice {
-    /// Create a new Peripheral panel object for the list of PDs described by the
-    /// corresponding PdInfo struct.
-    pub fn new(info: PdInfo) -> Result<Self> {
+    /// Create a new Peripheral panel object for the PD described by the corresponding PdInfo struct.
+    pub fn new(info: PdInfoBuilder, channel: Box<dyn Channel>) -> Result<Self> {
         unsafe { libosdp_sys::osdp_set_log_callback(Some(log_handler)) };
+        let info = info.channel(channel.into()).build();
         Ok(Self {
             ctx: pd_setup(info)?,
         })
diff --git a/libosdp/src/pdinfo.rs b/libosdp/src/pdinfo.rs
@@ -3,9 +3,9 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use core::ops::Deref;
+use crate::{OsdpError, OsdpFlag, PdCapability, PdId};
 use alloc::{boxed::Box, ffi::CString, format, string::String, vec::Vec};
-use crate::{Channel, OsdpError, OsdpFlag, PdCapability, PdId};
+use core::ops::Deref;
 
 /// OSDP PD Information. This struct is used to describe a PD to LibOSDP
 #[derive(Debug, Default)]
@@ -16,7 +16,7 @@ pub struct PdInfo {
     flags: OsdpFlag,
     id: PdId,
     cap: Vec<libosdp_sys::osdp_pd_cap>,
-    channel: Option<Box<dyn Channel>>,
+    channel: Option<libosdp_sys::osdp_channel>,
     scbk: Option<[u8; 16]>,
 }
 impl PdInfo {
@@ -142,7 +142,7 @@ pub struct PdInfoBuilder {
     flags: OsdpFlag,
     id: PdId,
     cap: Vec<libosdp_sys::osdp_pd_cap>,
-    channel: Option<Box<dyn Channel>>,
+    channel: Option<libosdp_sys::osdp_channel>,
     scbk: Option<[u8; 16]>,
 }
 
@@ -217,7 +217,7 @@ impl PdInfoBuilder {
     }
 
     /// Set Osdp communication channel
-    pub fn channel(mut self, channel: Box<dyn Channel>) -> PdInfoBuilder {
+    pub fn channel(mut self, channel: libosdp_sys::osdp_channel) -> PdInfoBuilder {
         self.channel = Some(channel);
         self
     }
@@ -284,7 +284,7 @@ impl From<PdInfo> for OsdpPdInfoHandle {
             flags: info.flags.bits() as i32,
             id: info.id.into(),
             cap: cap as *mut _,
-            channel: info.channel.unwrap().into(),
+            channel: info.channel.expect("no channel provided"),
             scbk,
         })
     }
diff --git a/libosdp/tests/common/device.rs b/libosdp/tests/common/device.rs
@@ -9,8 +9,8 @@ use std::{
 };
 
 use libosdp::{
-    ControlPanel, OsdpCommand, OsdpEvent, PdCapEntity, PdCapability, PdInfoBuilder,
-    PeripheralDevice,
+    ControlPanel, ControlPanelBuilder, OsdpCommand, OsdpEvent, PdCapEntity, PdCapability,
+    PdInfoBuilder, PeripheralDevice,
 };
 type Result<T> = core::result::Result<T, libosdp::OsdpError>;
 
@@ -32,10 +32,10 @@ impl CpDevice {
             .name("PD 101")?
             .address(101)?
             .baud_rate(115200)?
-            .channel(bus)
-            .secure_channel_key(pd_0_key)
-            .build();
-        let mut cp = ControlPanel::new(vec![pd_0])?;
+            .secure_channel_key(pd_0_key);
+        let mut cp = ControlPanelBuilder::new()
+            .add_channel(bus, vec![pd_0])
+            .build()?;
         let (event_tx, event_rx) = std::sync::mpsc::channel::<(i32, OsdpEvent)>();
 
         cp.set_event_callback(|pd, event| {
@@ -90,10 +90,8 @@ impl PdDevice {
             .capability(PdCapability::CommunicationSecurity(PdCapEntity::new(1, 1)))
             .capability(PdCapability::AudibleOutput(PdCapEntity::new(1, 1)))
             .capability(PdCapability::LedControl(PdCapEntity::new(1, 1)))
-            .channel(bus)
-            .secure_channel_key(key)
-            .build();
-        let mut pd = PeripheralDevice::new(pd_info)?;
+            .secure_channel_key(key);
+        let mut pd = PeripheralDevice::new(pd_info, bus)?;
         let (cmd_tx, cmd_rx) = std::sync::mpsc::channel::<OsdpCommand>();
         pd.set_command_callback(|command| {
             cmd_tx.send(command).unwrap();
diff --git a/osdpctl/src/config.rs b/osdpctl/src/config.rs
@@ -6,8 +6,7 @@
 use anyhow::bail;
 use anyhow::Context;
 use configparser::ini::Ini;
-use libosdp::PdInfoBuilder;
-use libosdp::{OsdpFlag, PdCapability, PdId, PdInfo};
+use libosdp::{ControlPanelBuilder, OsdpFlag, PdCapability, PdId, PdInfoBuilder};
 use rand::Rng;
 use std::{
     fmt::Write,
@@ -134,30 +133,26 @@ impl CpConfig {
         })
     }
 
-    pub fn pd_info(&self) -> Result<Vec<PdInfo>> {
+    pub fn pd_info(&self) -> Result<ControlPanelBuilder> {
         let mut runtime_dir = self.runtime_dir.clone();
         runtime_dir.pop();
-        self.pd_data
-            .iter()
-            .map(|d| {
-                let parts: Vec<&str> = d.channel.split("::").collect();
-                if parts[0] != "unix" {
-                    bail!("Only unix channel is supported for now")
-                }
-                let path = runtime_dir.join(format!("{}/{}.sock", d.name, parts[1]).as_str());
-                let channel =
-                    UnixChannel::connect(&path).context("Unable to connect to PD channel")?;
-                let pd_info = PdInfoBuilder::new()
-                    .name(&self.name)?
-                    .address(d.address)?
-                    .baud_rate(115200)?
-                    .flag(d.flags)
-                    .channel(Box::new(channel))
-                    .secure_channel_key(d.key_store.load()?)
-                    .build();
-                Ok(pd_info)
-            })
-            .collect()
+        let mut cp = ControlPanelBuilder::new();
+        for d in self.pd_data.iter() {
+            let parts: Vec<&str> = d.channel.split("::").collect();
+            if parts[0] != "unix" {
+                bail!("Only unix channel is supported for now")
+            }
+            let path = runtime_dir.join(format!("{}/{}.sock", d.name, parts[1]).as_str());
+            let channel = UnixChannel::connect(&path).context("Unable to connect to PD channel")?;
+            let pd_info = PdInfoBuilder::new()
+                .name(&self.name)?
+                .address(d.address)?
+                .baud_rate(115200)?
+                .flag(d.flags)
+                .secure_channel_key(d.key_store.load()?);
+            cp = cp.add_channel(Box::new(channel), vec![pd_info]);
+        }
+        Ok(cp)
     }
 }
 
@@ -238,7 +233,7 @@ impl PdConfig {
         })
     }
 
-    pub fn pd_info(&self) -> Result<PdInfo> {
+    pub fn pd_info(&self) -> Result<(Box<dyn libosdp::Channel>, PdInfoBuilder)> {
         let parts: Vec<&str> = self.channel.split("::").collect();
         if parts[0] != "unix" {
             bail!("Only unix channel is supported for now")
@@ -252,10 +247,8 @@ impl PdConfig {
             .flag(self.flags)
             .capabilities(&self.pd_cap)
             .id(&self.pd_id)
-            .channel(Box::new(channel))
-            .secure_channel_key(self.key_store.load()?)
-            .build();
-        Ok(pd_info)
+            .secure_channel_key(self.key_store.load()?);
+        Ok((Box::new(channel), pd_info))
     }
 }
 
diff --git a/osdpctl/src/cp.rs b/osdpctl/src/cp.rs
@@ -7,7 +7,7 @@ use std::{thread, time::Duration};
 
 use crate::config::CpConfig;
 use anyhow::Context;
-use libosdp::{ControlPanel, OsdpEvent};
+use libosdp::OsdpEvent;
 use std::io::Write;
 
 type Result<T> = anyhow::Result<T, anyhow::Error>;
@@ -29,8 +29,8 @@ fn setup(dev: &CpConfig, daemonize: bool) -> Result<()> {
 
 pub fn main(dev: CpConfig, daemonize: bool) -> Result<()> {
     setup(&dev, daemonize)?;
-    let pd_info = dev.pd_info().context("Failed to create PD info list")?;
-    let mut cp = ControlPanel::new(pd_info)?;
+    let cp = dev.pd_info().context("Failed to create PD info list")?;
+    let mut cp = cp.build()?;
     cp.set_event_callback(|pd, event| {
         match event {
             OsdpEvent::CardRead(e) => {
diff --git a/osdpctl/src/pd.rs b/osdpctl/src/pd.rs
@@ -29,8 +29,8 @@ fn setup(dev: &PdConfig, daemonize: bool) -> Result<()> {
 
 pub fn main(dev: PdConfig, daemonize: bool) -> Result<()> {
     setup(&dev, daemonize)?;
-    let pd_info = dev.pd_info().context("Failed to create PD info")?;
-    let mut pd = PeripheralDevice::new(pd_info)?;
+    let (channel, pd_info) = dev.pd_info().context("Failed to create PD info")?;
+    let mut pd = PeripheralDevice::new(pd_info, channel)?;
     pd.set_command_callback(|command| {
         match command {
             OsdpCommand::Led(c) => {
