Draft: Add resolve feature

Cargo.toml

@@ -12,6 +12,8 @@ js-sys = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde-wasm-bindgen = "0.6"
 log = "^0.4.21"
+console_error_panic_hook = "0.1.7"
+console_log = "1.0.0"
 
 [workspace]
 members = ["src-tauri"]

src-tauri/src/main.rs

@@ -1,10 +1,14 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-use std::sync::{Arc, Mutex};
-
 use log::LevelFilter;
 use mdns_sd::{ServiceDaemon, ServiceEvent};
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::HashSet,
+    net::IpAddr,
+    sync::{Arc, Mutex},
+};
 use tauri::State;
 use tauri_plugin_log::LogTarget;
 
@@ -19,6 +23,48 @@ fn get_shared_daemon() -> SharedServiceDaemon {
     Arc::new(Mutex::new(daemon))
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+struct ResolvedService {
+    instance_name: String,
+    hostname: String,
+    port: u16,
+    addresses: HashSet<IpAddr>,
+}
+
+#[tauri::command]
+fn resolve_service(service_type: String, state: State<Daemon>) -> Vec<ResolvedService> {
+    log::info!("Resolving {}", service_type);
+    let mdns = state.shared.lock().unwrap();
+    let receiver = mdns
+        .browse(service_type.as_str())
+        .expect("Failed to browse");
+    let mut result = vec![];
+    let mut done = false;
+    while let Ok(event) = receiver.recv() {
+        match event {
+            ServiceEvent::ServiceResolved(info) => {
+                result.push(ResolvedService {
+                    instance_name: info.get_fullname().into(),
+                    hostname: info.get_hostname().into(),
+                    port: info.get_port(),
+                    addresses: info.get_addresses().clone(),
+                });
+            }
+            ServiceEvent::SearchStarted(_) => {
+                if done {
+                    let _ = mdns.stop_browse(service_type.as_str());
+                }
+                done = true;
+            }
+            ServiceEvent::SearchStopped(_) => {
+                break;
+            }
+            _ => {}
+        }
+    }
+    result
+}
+
 #[tauri::command]
 fn enum_service_types(state: State<Daemon>) -> Vec<String> {
     let mut found = vec![];
@@ -87,7 +133,10 @@ fn main() {
                 .level(LevelFilter::Info)
                 .build(),
         )
-        .invoke_handler(tauri::generate_handler![enum_service_types])
+        .invoke_handler(tauri::generate_handler![
+            enum_service_types,
+            resolve_service
+        ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }

src/app.rs

@@ -1,21 +1,52 @@
-use leptos::*;
-use serde_wasm_bindgen::from_value;
+use std::{collections::HashSet, net::IpAddr};
+
+use leptos::{html::Input, *};
+use serde::{Deserialize, Serialize};
+use serde_wasm_bindgen::{from_value, to_value};
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 extern "C" {
     #[wasm_bindgen(js_namespace = ["window", "__TAURI__", "tauri"])]
-    async fn invoke(cmd: &str) -> JsValue;
+    async fn invoke(cmd: &str, args: JsValue) -> JsValue;
 }
 
 type ServiceTypes = Vec<String>;
 
 async fn enum_service_types() -> ServiceTypes {
-    let service_types: ServiceTypes = from_value(invoke("enum_service_types").await).unwrap();
-    log::info!("Received {:#?}", service_types);
+    let service_types: ServiceTypes =
+        from_value(invoke("enum_service_types", JsValue::UNDEFINED).await).unwrap();
     service_types
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct ResolvedService {
+    instance_name: String,
+    hostname: String,
+    port: u16,
+    addresses: HashSet<IpAddr>,
+}
+type ResolvedServices = Vec<ResolvedService>;
+
+#[derive(Serialize, Deserialize)]
+#[allow(non_snake_case)]
+struct ResolveServiceArgs<'a> {
+    serviceType: &'a str,
+}
+
+async fn resolve_service(service_type: String) -> ResolvedServices {
+    log::debug!("resolve service: {}", service_type);
+
+    let args = to_value(&ResolveServiceArgs {
+        serviceType: &service_type,
+    })
+    .unwrap();
+    let resolved_services: ResolvedServices =
+        from_value(invoke("resolve_service", args).await).unwrap();
+    log::debug!("Resolved: {:#?}", resolved_services);
+    resolved_services
+}
+
 #[component]
 fn ShowServices(services: ServiceTypes) -> impl IntoView {
     view! {
@@ -52,10 +83,63 @@ fn ServiceTypeList() -> impl IntoView {
     }
 }
 
+#[component]
+fn ShowResolvedServices(services: ResolvedServices) -> impl IntoView {
+    view! {
+        <ul>
+            {services.into_iter()
+                .map(|n|
+                     view! {
+                    <div>Instance name: {n.instance_name}</div>
+                    <div>Hostname: {n.hostname}</div>
+                    <div>Port: {n.port}</div>
+                    <div>IPs: {n.addresses.iter().map(|n|n.to_string()).collect::<Vec<String>>().join(", ")}</div>
+                })
+                .collect::<Vec<_>>()}
+        </ul>
+    }
+}
+
+#[component]
+fn ResolveService() -> impl IntoView {
+    let (service, _) = create_signal("".to_string());
+    let resolve_action = create_action(|input: &String| {
+        let input = input.clone();
+        async move { resolve_service(input.clone()).await }
+    });
+    let input_element: NodeRef<Input> = create_node_ref();
+    let on_submit = move |ev: ev::SubmitEvent| {
+        ev.prevent_default();
+        let value = input_element.get().expect("<input> to exist").value();
+        resolve_action.dispatch(value);
+    };
+
+    let value = resolve_action.value();
+
+    view! {
+        <form on:submit=on_submit>
+            <input type="text"
+                value=service
+                node_ref=input_element
+            />
+            <button type="submit">"Resolve"</button>
+        </form>
+         {move || match value.get() {
+            None => view! { <p>Click on Resolve</p> }.into_view(),
+            Some(services) => {
+                view! {
+                    <ShowResolvedServices services />
+                }.into_view()
+            }
+         }}
+    }
+}
+
 #[component]
 pub fn App() -> impl IntoView {
     view! {
         <main class="container">
+            <ResolveService />
             <ServiceTypeList />
         </main>
     }

src/main.rs

@@ -4,6 +4,8 @@ use app::*;
 use leptos::*;
 
 fn main() {
+    _ = console_log::init_with_level(log::Level::Debug);
+    console_error_panic_hook::set_once();
     mount_to_body(|| {
         view! {
             <App/>