feat: Initial mDNS-SD discovery

Author: lu-zero

Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "wot-discovery"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+description = "Web of Things (WoT) Discovery"
+repository = "https://github.com/sifis-home/wot-discovery"
+keywords = ["wot", "WebofThings"]
+
+[dependencies]
+serde_json = "1.0"
+mdns-sd = "0.7.3"
+thiserror = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+wot-td = "0.3.1"
+futures-core = "0.3"
+futures-util = "0.3.21"
+tracing = "0.1.35"
+
+[dev-dependencies]
+tokio = { version = "1.19.2", features = ["macros", "rt-multi-thread"] }
+tracing-subscriber = "0.3.11"
+wot-serve = "0.3.1"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Luca Barbato
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -2,6 +2,11 @@
 
 Tiny implementation of WoT [Discovery](https://www.w3.org/TR/wot-discovery/).
 
+## Supported Introduction Mechanisms
+
+- [x] mDNS-SD (HTTP/HTTPS)
+- [ ] CoRE Resource Directory
+
 ## Acknowledgements
 
 This software has been developed in the scope of the H2020 project SIFIS-Home with GA n. 952652.

examples/list.rs

@@ -0,0 +1,24 @@
+use std::future::ready;
+
+use futures_util::StreamExt;
+use tracing::{info, warn};
+use wot_discovery::Discoverer;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt().init();
+
+    let d = Discoverer::new()?;
+
+    d.stream()?
+        .for_each(|thing| {
+            match thing {
+                Ok(t) => info!("found {:?} {:?}", t.title, t.id),
+                Err(e) => warn!("something went wrong {:?}", e),
+            }
+            ready(())
+        })
+        .await;
+
+    Ok(())
+}

src/lib.rs

@@ -0,0 +1,81 @@
+//! Web of Things Discovery
+//!
+//! Discover [Web Of Things](https://www.w3.org/WoT/) that advertise themselves in the network.
+//!
+//! ## Supported Introduction Mechanisms
+//!
+//! - [x] [mDNS-SD (HTTP)](https://www.w3.org/TR/wot-discovery/#introduction-dns-sd-sec)
+
+use futures_core::Stream;
+use futures_util::StreamExt;
+use mdns_sd::{ServiceDaemon, ServiceEvent, ServiceInfo};
+use tracing::debug;
+
+use wot_td::thing::Thing;
+
+/// The error type for Discovery operation
+#[derive(thiserror::Error, Debug)]
+#[non_exhaustive]
+pub enum Error {
+    #[error("mdns cannot be accessed {0}")]
+    Mdns(#[from] mdns_sd::Error),
+    #[error("reqwest error {0}")]
+    Reqwest(#[from] reqwest::Error),
+    #[error("Missing address")]
+    NoAddress,
+}
+
+/// A specialized [`Result`] type
+pub type Result<T> = std::result::Result<T, Error>;
+
+const WELL_KNOWN: &str = "/.well-known/wot";
+
+/// Discover [Web Of Things](https://www.w3.org/WoT/) via a supported Introduction Mechanism.
+pub struct Discoverer {
+    mdns: ServiceDaemon,
+    service_type: String,
+}
+
+async fn get_thing(info: ServiceInfo) -> Result<Thing> {
+    let host = info.get_addresses().iter().next().ok_or(Error::NoAddress)?;
+    let port = info.get_port();
+    let props = info.get_properties();
+    let path = props.get_property_val_str("td").unwrap_or(WELL_KNOWN);
+    let proto = match props.get_property_val_str("tls") {
+        Some(x) if x == "1" => "https",
+        _ => "http",
+    };
+
+    debug!("Got {proto} {host} {port} {path}");
+
+    let r = reqwest::get(format!("{proto}://{host}:{port}{path}")).await?;
+
+    let t = r.json().await?;
+
+    Ok(t)
+}
+
+impl Discoverer {
+    /// Creates a new Discoverer
+    pub fn new() -> Result<Self> {
+        let mdns = ServiceDaemon::new()?;
+        let service_type = "_wot._tcp.local.".to_owned();
+        Ok(Self { mdns, service_type })
+    }
+
+    /// Returns an Stream of discovered things
+    pub fn stream(&self) -> Result<impl Stream<Item = Result<Thing>>> {
+        let receiver = self.mdns.browse(&self.service_type)?;
+
+        let s = receiver.into_stream().filter_map(|v| async move {
+            if let ServiceEvent::ServiceResolved(info) = v {
+                let t = get_thing(info).await;
+                Some(t)
+            } else {
+                None
+            }
+        });
+
+        Ok(s)
+    }
+}

tests/mdns.rs

@@ -0,0 +1,50 @@
+use std::time::Duration;
+
+use futures_util::StreamExt;
+
+use wot_discovery::Discoverer;
+use wot_serve::servient::*;
+
+use tokio::task;
+
+async fn run_servient() {
+    let servient = Servient::builder("TestThing")
+        .finish_extend()
+        .http_bind("127.0.0.1:8080".parse().unwrap())
+        .build_servient()
+        .unwrap();
+
+    eprintln!("Listening to 127.0.0.1:8080");
+
+    let _ = tokio::time::timeout(Duration::from_secs(30), async {
+        servient.serve().await.unwrap()
+    })
+    .await;
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn discoverer() -> Result<(), Box<dyn std::error::Error>> {
+    let local = task::LocalSet::new();
+
+    local
+        .run_until(async {
+            task::spawn_local(async {
+                run_servient().await;
+            });
+
+            task::spawn_local(async {
+                let d = Discoverer::new().unwrap();
+
+                let t = std::pin::pin!(d.stream().unwrap())
+                    .next()
+                    .await
+                    .unwrap()
+                    .unwrap();
+
+                assert_eq!("TestThing", t.title);
+            });
+        })
+        .await;
+
+    Ok(())
+}