Add an mDNS trait to align with the new mDNS responder metaphor in rs-matter

Author: ivmarkov

Cargo.toml

@@ -21,17 +21,19 @@ rs-matter = { git = "https://github.com/ivmarkov/rs-matter", branch = "next" }
 #edge-mdns = { git = "https://github.com/ivmarkov/edge-net" }
 
 [features]
-default = ["examples"]
+default = []
 log = ["dep:log", "rs-matter/log", "embedded-svc/log", "edge-mdns?/log"]
 defmt = ["dep:defmt", "rs-matter/defmt", "embedded-svc/defmt", "heapless/defmt-03", "edge-mdns?/defmt"]
+zbus = ["rs-matter/zbus"]
 zeroconf = ["os", "rs-matter/zeroconf"]
+astro-dnssd = ["os", "rs-matter/astro-dnssd"]
 rustcrypto = ["rs-matter/rustcrypto"]
 os = ["backtrace", "rs-matter/os", "rustcrypto", "embassy-time/std"]
 backtrace = ["std", "rs-matter/backtrace"]
 async-io-mini = ["std", "edge-nal-std/async-io-mini"]
 std = ["alloc", "rs-matter/std", "edge-nal-std"]
 alloc = ["embedded-svc/alloc"]
-examples = ["log", "os", "nix", "embassy-time-queue-utils/generic-queue-64"]
+examples = ["log", "os", "nix", "embassy-time-queue-utils/generic-queue-64", "zeroconf"]
 
 [dependencies]
 log = { version = "0.4", default-features = false, optional = true }

README.md

@@ -83,6 +83,7 @@ use rs_matter_stack::matter::error::Error;
 use rs_matter_stack::matter::utils::init::InitMaybeUninit;
 use rs_matter_stack::matter::utils::select::Coalesce;
 use rs_matter_stack::matter::{clusters, devices};
+use rs_matter_stack::mdns::ZeroconfMdns;
 use rs_matter_stack::persist::DirKvBlobStore;
 
 use static_cell::StaticCell;
@@ -136,6 +137,8 @@ fn main() -> Result<(), Error> {
         edge_nal_std::Stack::new(),
         // Will try to find a default network interface
         UnixNetifs,
+        // Will use the mDNS implementation based on the `zeroconf` crate
+        ZeroconfMdns::new(stack.matter()),
         // Will persist in `<tmp-dir>/rs-matter`
         &store,
         // Our `AsyncHandler` + `AsyncMetadata` impl

examples/light.rs

@@ -30,6 +30,7 @@ use rs_matter_stack::matter::utils::init::InitMaybeUninit;
 use rs_matter_stack::matter::utils::select::Coalesce;
 use rs_matter_stack::matter::utils::sync::blocking::raw::StdRawMutex;
 use rs_matter_stack::matter::{clusters, devices};
+use rs_matter_stack::mdns::ZeroconfMdns;
 use rs_matter_stack::persist::DirKvBlobStore;
 use rs_matter_stack::wireless::PreexistingWireless;
 use rs_matter_stack::wireless::WifiMatterStack;
@@ -78,10 +79,14 @@ fn main() -> Result<(), Error> {
     let store = stack.create_shared_store(DirKvBlobStore::new_default());
     let mut matter = pin!(stack.run(
         PreexistingWireless::new(
+            // The Matter stack needs UDP sockets to communicate with other Matter devices
             edge_nal_std::Stack::new(),
+            // Will try to find a default network interface
             UnixNetifs,
             // A dummy wireless controller that does nothing
             NoopWirelessNetCtl::new(NetworkType::Wifi),
+            // Will use the mDNS implementation based on the `zeroconf` crate
+            ZeroconfMdns::new(stack.matter()),
             BuiltinGattPeripheral::new(None),
         ),
         // Will persist in `<tmp-dir>/rs-matter`

examples/light_eth.rs

@@ -31,6 +31,7 @@ use rs_matter_stack::matter::error::Error;
 use rs_matter_stack::matter::utils::init::InitMaybeUninit;
 use rs_matter_stack::matter::utils::select::Coalesce;
 use rs_matter_stack::matter::{clusters, devices};
+use rs_matter_stack::mdns::ZeroconfMdns;
 use rs_matter_stack::persist::DirKvBlobStore;
 
 use static_cell::StaticCell;
@@ -84,6 +85,8 @@ fn main() -> Result<(), Error> {
         edge_nal_std::Stack::new(),
         // Will try to find a default network interface
         UnixNetifs,
+        // Will use the mDNS implementation based on the `zeroconf` crate
+        ZeroconfMdns::new(stack.matter()),
         // Will persist in `<tmp-dir>/rs-matter`
         &store,
         // Our `AsyncHandler` + `AsyncMetadata` impl

src/eth.rs

@@ -14,6 +14,7 @@ use rs_matter::transport::network::NoNetwork;
 use rs_matter::utils::init::{init, Init};
 use rs_matter::utils::select::Coalesce;
 
+use crate::mdns::Mdns;
 use crate::nal::NetStack;
 use crate::network::{Embedding, Network};
 use crate::persist::{KvBlobStore, SharedKvBlobStore};
@@ -64,23 +65,25 @@ pub type EthMatterStack<'a, E = ()> = MatterStack<'a, Eth<E>>;
 /// A trait representing a task that needs access to the operational Ethernet interface
 /// (Network stack and Netif) to perform its work.
 pub trait EthernetTask {
-    /// Run the task with the given network stack and network interface
-    async fn run<S, N>(&mut self, net_stack: S, netif: N) -> Result<(), Error>
+    /// Run the task with the given network stack, network interface and mDNS
+    async fn run<S, N, M>(&mut self, net_stack: S, netif: N, mdns: M) -> Result<(), Error>
     where
         S: NetStack,
-        N: NetifDiag + NetChangeNotif;
+        N: NetifDiag + NetChangeNotif,
+        M: Mdns;
 }
 
 impl<T> EthernetTask for &mut T
 where
     T: EthernetTask,
 {
-    async fn run<S, N>(&mut self, net_stack: S, netif: N) -> Result<(), Error>
+    async fn run<S, N, M>(&mut self, net_stack: S, netif: N, mdns: M) -> Result<(), Error>
     where
         S: NetStack,
         N: NetifDiag + NetChangeNotif,
+        M: Mdns,
     {
-        (*self).run(net_stack, netif).await
+        (*self).run(net_stack, netif, mdns).await
     }
 }
 
@@ -106,28 +109,30 @@ where
 
 /// A utility type for running an ethernet task with a pre-existing ethernet interface
 /// rather than bringing up / tearing down the ethernet interface for the task.
-pub struct PreexistingEthernet<S, N> {
+pub struct PreexistingEthernet<S, N, M> {
     stack: S,
     netif: N,
+    mdns: M,
 }
 
-impl<S, N> PreexistingEthernet<S, N> {
-    /// Create a new `PreexistingEthernet` instance with the given network interface and UDP stack.
-    pub const fn new(stack: S, netif: N) -> Self {
-        Self { stack, netif }
+impl<S, N, M> PreexistingEthernet<S, N, M> {
+    /// Create a new `PreexistingEthernet` instance with the given network interface, UDP stack and mDNS.
+    pub const fn new(stack: S, netif: N, mdns: M) -> Self {
+        Self { stack, netif, mdns }
     }
 }
 
-impl<S, N> Ethernet for PreexistingEthernet<S, N>
+impl<S, N, M> Ethernet for PreexistingEthernet<S, N, M>
 where
     S: NetStack,
     N: NetifDiag + NetChangeNotif,
+    M: Mdns,
 {
     async fn run<T>(&mut self, mut task: T) -> Result<(), Error>
     where
         T: EthernetTask,
     {
-        task.run(&self.stack, &self.netif).await
+        task.run(&self.stack, &self.netif, &mut self.mdns).await
     }
 }
 
@@ -172,26 +177,29 @@ where
     /// Parameters:
     /// - `netif` - a user-provided `Netif` implementation for the Ethernet network
     /// - `net_stack` - a user-provided network stack implementation
+    /// - `mdns` - a user-provided mDNS implementation
     /// - `persist` - a user-provided `Persist` implementation
     /// - `handler` - a user-provided DM handler implementation
     /// - `user` - a user-provided future that will be polled only when the netif interface is up
-    pub async fn run_preex<U, N, S, H, X>(
+    pub async fn run_preex<U, N, M, S, H, X>(
         &self,
         net_stack: U,
         netif: N,
+        mdns: M,
         store: &SharedKvBlobStore<'_, S>,
         handler: H,
         user: X,
     ) -> Result<(), Error>
     where
         U: NetStack,
         N: NetifDiag + NetChangeNotif,
+        M: Mdns,
         S: KvBlobStore,
         H: AsyncHandler + AsyncMetadata,
         X: UserTask,
     {
         self.run(
-            PreexistingEthernet::new(net_stack, netif),
+            PreexistingEthernet::new(net_stack, netif, mdns),
             store,
             handler,
             user,
@@ -261,16 +269,18 @@ where
     H: AsyncMetadata + AsyncHandler,
     X: UserTask,
 {
-    async fn run<S, C>(&mut self, net_stack: S, netif: C) -> Result<(), Error>
+    async fn run<S, C, M>(&mut self, net_stack: S, netif: C, mut mdns: M) -> Result<(), Error>
     where
         S: NetStack,
         C: NetifDiag + NetChangeNotif,
+        M: Mdns,
     {
         info!("Ethernet driver started");
 
         let mut net_task = pin!(self.0.run_oper_net(
             &net_stack,
             &netif,
+            &mut mdns,
             core::future::pending(),
             Option::<(NoNetwork, NoNetwork)>::None,
         ));