Zeroconf

https://github.com/windy1/zeroconf-rs
Admin
A cross-platform Rust library that wraps ZeroConf/mDNS implementations to easily register and browse...
Tokens:5,348
Snippets:27
Trust Score:8.6
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Manage TXT Records for mDNS Services in Rust

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

This example shows how to create, insert, retrieve, and manage key-value pairs within a `TxtRecord` for mDNS services. It covers checking for keys, iterating over entries, removing entries, and converting to/from HashMaps. Cloning is also demonstrated. Dependencies include `zeroconf::TxtRecord` and `std::collections::HashMap`.

```rust
use zeroconf::TxtRecord;
use std::collections::HashMap;

fn main() -> zeroconf::Result<()> {
    // Create new TXT record
    let mut txt_record = TxtRecord::new();

    // Insert key-value pairs
    txt_record.insert("version", "2.1.0")?;
    txt_record.insert("api", "v1")?;
    txt_record.insert("secure", "true")?;

    // Retrieve values
    if let Some(version) = txt_record.get("version") {
        println!("Version: {}", version);
    }

    // Check for keys
    assert!(txt_record.contains_key("api"));
    assert!(!txt_record.contains_key("missing"));

    // Get record size
    println!("Record has {} entries", txt_record.len());

    // Iterate over all entries
    for (key, value) in txt_record.iter() {
        println!("{} = {}", key, value);
    }

    // Iterate over keys only
    for key in txt_record.keys() {
        println!("Key: {}", key);
    }

    // Remove entries
    if let Some(old_value) = txt_record.remove("api") {
        println!("Removed: {}", old_value);
    }

    // Convert to HashMap
    let map: HashMap<String, String> = txt_record.to_map();

    // Create from HashMap
    let mut initial_data = HashMap::new();
    initial_data.insert("foo".to_string(), "bar".to_string());
    let record: TxtRecord = initial_data.into();

    // Clone records
    let cloned = txt_record.clone();
    assert_eq!(txt_record, cloned);

    Ok(())
}

```

--------------------------------

### Share Context Data in Rust Callbacks with zeroconf-rs

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

This Rust code snippet shows how to share custom context data, like startup time and registration count, across callbacks using `zeroconf-rs`. It utilizes `Arc` and `Mutex` for thread-safe sharing of mutable state. The context is set during service setup and accessed within the registration callback to manage service state.

```rust
use std::any::Any;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use zeroconf::prelude::*;
use zeroconf::{MdnsService, ServiceRegistration, ServiceType};

#[derive(Debug)]
struct ServiceContext {
    startup_time: std::time::Instant,
    registration_count: u32,
}

fn main() -> zeroconf::Result<()> {
    let service_type = ServiceType::new("http", "tcp")?;
    let mut service = MdnsService::new(service_type, 8080);

    // Create shared context
    let context = Arc::new(Mutex::new(ServiceContext {
        startup_time: std::time::Instant::now(),
        registration_count: 0,
    }));

    service.set_name("context_example");
    service.set_context(Box::new(context));
    service.set_registered_callback(Box::new(handle_registration));

    let event_loop = service.register()?;

    loop {
        event_loop.poll(Duration::from_secs(1))?;
    }
}

fn handle_registration(
    result: zeroconf::Result<ServiceRegistration>,
    context: Option<Arc<dyn Any + Send + Sync>>,
) {
    if let Ok(service) = result {
        println!("Registered: {}", service.name());

        // Extract and use context
        if let Some(ctx) = context {
            if let Some(service_ctx) = ctx.downcast_ref::<Arc<Mutex<ServiceContext>>>() {
                let mut ctx = service_ctx.lock().unwrap();
                ctx.registration_count += 1;

                let elapsed = ctx.startup_time.elapsed();
                println!("Registration #{} after {:?}", ctx.registration_count, elapsed);
            }
        }
    }
}
```

--------------------------------

### Register mDNS Service with Rust (zeroconf-rs)

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

Demonstrates how to register an mDNS service on the local network using the `zeroconf-rs` library. This involves creating a `MdnsService`, configuring its type, port, name, and TXT records, and setting up a callback for registration confirmation. The service is kept alive through a polling event loop.

```rust
use std::any::Any;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use zeroconf::prelude::*;
use zeroconf::{MdnsService, ServiceRegistration, ServiceType, TxtRecord};

#[derive(Default, Debug)]
pub struct Context {
    service_name: String,
}

fn main() -> zeroconf::Result<()> {
    // Create service type for HTTP over TCP
    let service_type = ServiceType::new("http", "tcp")?;

    // Create service on port 8080
    let mut service = MdnsService::new(service_type, 8080);

    // Create TXT record with metadata
    let mut txt_record = TxtRecord::new();
    txt_record.insert("version", "1.0")?;
    txt_record.insert("api", "rest")?;

    // Configure service
    service.set_name("my_web_service");
    service.set_txt_record(txt_record);

    // Set up context for state sharing
    let context: Arc<Mutex<Context>> = Arc::default();
    service.set_context(Box::new(context));

    // Set callback for when service is registered
    service.set_registered_callback(Box::new(on_service_registered));

    // Register service and get event loop
    let event_loop = service.register()?;

    // Keep service alive by polling
    loop {
        event_loop.poll(Duration::from_secs(1))?;
    }
}

fn on_service_registered(
    result: zeroconf::Result<ServiceRegistration>,
    context: Option<Arc<dyn Any + Send + Sync>>,
) {
    match result {
        Ok(service) => {
            println!("Service registered: {}", service.name());
            println!("Type: {}", service.service_type().name());
            println!("Domain: {}", service.domain());

            // Access shared context
            if let Some(ctx) = context {
                if let Some(context) = ctx.downcast_ref::<Arc<Mutex<Context>>>() {
                    context.lock().unwrap().service_name = service.name().to_string();
                }
            }
        }
        Err(e) => eprintln!("Registration failed: {}", e),
    }
}

```

--------------------------------

### Register Service with zeroconf-rs

Source: https://github.com/windy1/zeroconf-rs/blob/master/README.md

Demonstrates how to register a network service using the zeroconf-rs library. It includes setting service details, a text record, and a callback for registration confirmation. Requires the 'log' and 'clap' crates.

```rust
#[macro_use]
extern crate log;

use clap::Parser;

use std::any::Any;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use zeroconf::prelude::*;
use zeroconf::{MdnsService, ServiceRegistration, ServiceType, TxtRecord};

#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    /// Name of the service type to register
    #[clap(short, long, default_value = "http")]
    name: String,

    /// Protocol of the service type to register
    #[clap(short, long, default_value = "tcp")]
    protocol: String,

    /// Sub-types of the service type to register
    #[clap(short, long)]
    sub_types: Vec<String>,
}

#[derive(Default, Debug)]
pub struct Context {
    service_name: String,
}

fn main() -> zeroconf::Result<()> {
    env_logger::init();

    let Args {
        name,
        protocol,
        sub_types,
    } = Args::parse();

    let sub_types = sub_types.iter().map(|s| s.as_str()).collect::<Vec<_>>();
    let service_type = ServiceType::with_sub_types(&name, &protocol, sub_types)?;
    let mut service = MdnsService::new(service_type, 8080);
    let mut txt_record = TxtRecord::new();
    let context: Arc<Mutex<Context>> = Arc::default();

    txt_record.insert("foo", "bar")?;

    service.set_name("zeroconf_example_service");
    service.set_registered_callback(Box::new(on_service_registered));
    service.set_context(Box::new(context));
    service.set_txt_record(txt_record);

    let event_loop = service.register()?;

    loop {
        // calling `poll()` will keep this service alive
        event_loop.poll(Duration::from_secs(0))?;
    }
}

fn on_service_registered(
    result: zeroconf::Result<ServiceRegistration>,
    context: Option<Arc<dyn Any>>,
) {
    let service = result.expect("failed to register service");

    info!("Service registered: {:?}", service);

    let context = context
        .as_ref()
        .expect("could not get context")
        .downcast_ref::<Arc<Mutex<Context>>>()
        .expect("error down-casting context")
        .clone();

    context
        .lock()
        .expect("failed to obtain context lock")
        .service_name = service.name().clone();

    info!("Context: {:?}", context);

    // ...
}

```

--------------------------------

### Browse Services with zeroconf-rs

Source: https://github.com/windy1/zeroconf-rs/blob/master/README.md

Illustrates how to discover network services using the zeroconf-rs library. It sets up a browser for a specified service type and protocol, and defines a callback for when services are discovered. Requires 'log' and 'clap' crates.

```rust
#[macro_use]
extern crate log;

use clap::Parser;

use std::any::Any;
use std::sync::Arc;
use std::time::Duration;
use zeroconf::prelude::*;
use zeroconf::{MdnsBrowser, ServiceDiscovery, ServiceType};

/// Example of a simple mDNS browser
#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    /// Name of the service type to browse
    #[clap(short, long, default_value = "http")]
    name: String,

    /// Protocol of the service type to browse
    #[clap(short, long, default_value = "tcp")]
    protocol: String,

    /// Sub-type of the service type to browse
    #[clap(short, long)]
    sub_type: Option<String>,
}

fn main() -> zeroconf::Result<()> {
    env_logger::init();

    let Args {
        name,
        protocol,
        sub_type,
    } = Args::parse();

    let sub_types: Vec<&str> = match sub_type.as_ref() {
        Some(sub_type) => vec![sub_type],
        None => vec![],
    };

    let service_type =
        ServiceType::with_sub_types(&name, &protocol, sub_types).expect("invalid service type");

    let mut browser = MdnsBrowser::new(service_type);

    browser.set_service_discovered_callback(Box::new(on_service_discovered));

    let event_loop = browser.browse_services()?;

    loop {
        // calling `poll()` will keep this browser alive
        event_loop.poll(Duration::from_secs(0))?;
    }
}

fn on_service_discovered(
    result: zeroconf::Result<ServiceDiscovery>,
    _context: Option<Arc<dyn Any>>,
) {
    info!(
        "Service discovered: {:?}",
        result.expect("service discovery failed")
    );

    // ...
}

```

--------------------------------

### Browse mDNS Services with MdnsBrowser in Rust

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

This snippet demonstrates how to use MdnsBrowser to discover mDNS services on the local network. It sets up a callback to handle service additions and removals, and continuously polls for network events. Dependencies include `zeroconf` and `std::time::Duration`.

```rust
use std::any::Any;
use std::sync::Arc;
use std::time::Duration;
use zeroconf::prelude::*;
use zeroconf::{BrowserEvent, MdnsBrowser, ServiceDiscovery, ServiceType};

fn main() -> zeroconf::Result<()> {
    // Create service type to browse for HTTP services
    let service_type = ServiceType::new("http", "tcp")?;

    // Create browser
    let mut browser = MdnsBrowser::new(service_type);

    // Set callback for service events
    browser.set_service_callback(Box::new(on_service_event));

    // Start browsing
    let event_loop = browser.browse_services()?;

    // Keep browser alive by polling
    loop {
        event_loop.poll(Duration::from_secs(1))?;
    }
}

fn on_service_event(
    result: zeroconf::Result<BrowserEvent>,
    _context: Option<Arc<dyn Any + Send + Sync>>,
) {
    match result {
        Ok(BrowserEvent::Add(service)) => {
            println!("Service discovered:");
            println!("  Name: {}", service.name());
            println!("  Type: {}", service.service_type().name());
            println!("  Host: {}", service.host_name());
            println!("  Address: {}", service.address());
            println!("  Port: {}", service.port());
            println!("  Domain: {}", service.domain());

            // Access TXT record data
            if let Some(txt) = service.txt() {
                for (key, value) in txt.iter() {
                    println!("  TXT: {} = {}", key, value);
                }
            }
        }
        Ok(BrowserEvent::Remove(removal)) => {
            println!("Service removed: {} ({}.{})",
                removal.name(), removal.kind(), removal.domain());
        }
        Err(e) => eprintln!("Browser error: {}", e),
    }
}

```

--------------------------------

### Configure Custom Domains and Hostnames for mDNS Services in Rust

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

Customize domain and hostnames for mDNS service registration using zeroconf-rs. Allows setting a custom domain (default 'local.') and a specific hostname for SRV records, overriding auto-assignment. Useful for specialized network environments.

```rust
use zeroconf::{MdnsService, ServiceType};
use std::time::Duration;

fn main() -> zeroconf::Result<()> {
    let service_type = ServiceType::new("http", "tcp")?;
    let mut service = MdnsService::new(service_type, 8080);

    // Set custom domain (default is "local.")
    service.set_domain("custom.local");

    // Set custom hostname for SRV record
    service.set_host("myserver.local");

    // Query configured values
    if let Some(domain) = service.domain() {
        println!("Domain: {}", domain);
    }

    if let Some(host) = service.host() {
        println!("Host: {}", host);
    }

    // Get service name (may be auto-assigned)
    service.set_name("my_service");
    if let Some(name) = service.name() {
        println!("Service name: {}", name);
    }

    // Register with custom settings
    let event_loop = service.register()?;

    loop {
        event_loop.poll(Duration::from_secs(1))?;
    }
}
```

--------------------------------

### Construct and Validate Service Types in Rust

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

This code illustrates how to create and validate mDNS service types using the `ServiceType` struct in Rust. It covers basic construction, construction with sub-types, parsing from strings, and accessing components. Invalid types result in errors. Dependencies include `zeroconf::ServiceType`.

```rust
use zeroconf::ServiceType;

fn main() -> zeroconf::Result<()> {
    // Basic service type
    let http_service = ServiceType::new("http", "tcp")?;

    // Service type with sub-types
    let printer_service = ServiceType::with_sub_types(
        "printer",
        "tcp",
        vec!["color", "duplex"]
    )?;

    // Parse from string format
    let parsed = ServiceType::from_str("_http._tcp")?;

    // Access service type components
    println!("Name: {}", http_service.name());
    println!("Protocol: {}", http_service.protocol());
    println!("Sub-types: {:?}", http_service.sub_types());

    // Invalid service types return errors
    match ServiceType::new("http.invalid", "tcp") {
        Err(e) => println!("Error: {}", e), // "invalid character: ."
        Ok(_) => {} 
    }

    match ServiceType::new("", "tcp") {
        Err(e) => println!("Error: {}", e), // "cannot be empty"
        Ok(_) => {} 
    }

    Ok(())
}

```

--------------------------------

### Serde JSON Serialization/Deserialization for TXT Records in Rust

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

Enable Serde support in zeroconf-rs to serialize and deserialize service discovery data, specifically TXT records, to and from JSON. This feature requires enabling the `serde` flag during compilation. It simplifies data storage and transmission.

```rust
#[cfg(feature = "serde")]
use serde_json;
use zeroconf::TxtRecord;

#[cfg(feature = "serde")]
fn main() -> zeroconf::Result<()> {
    // Create TXT record
    let mut txt = TxtRecord::new();
    txt.insert("version", "1.0")?;
    txt.insert("secure", "true")?;

    // Serialize to JSON
    let json = serde_json::to_string(&txt).unwrap();
    println!("JSON: {}", json);
    // Output: {"version":"1.0","secure":"true"}

    // Deserialize from JSON
    let deserialized: TxtRecord = serde_json::from_str(&json).unwrap();
    assert_eq!(txt, deserialized);

    // ServiceDiscovery also supports serde
    // When browser discovers a service, it can be serialized:
    // let service_json = serde_json::to_string(&service_discovery)?;

    Ok(())
}

#[cfg(not(feature = "serde"))]
fn main() {
    println!("Enable 'serde' feature for serialization support");
}
```

--------------------------------

### Configure Network Interfaces for mDNS Services in Rust

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

Control which network interfaces are used for service registration and browsing with zeroconf-rs. Supports binding to all interfaces (Unspec) or specific interfaces by index. This is useful for multi-homed systems or when network isolation is required.

```rust
use zeroconf::{MdnsService, MdnsBrowser, NetworkInterface, ServiceType};

fn main() -> zeroconf::Result<()> {
    let service_type = ServiceType::new("http", "tcp")?;

    // Service bound to all interfaces (default)
    let mut service_all = MdnsService::new(service_type.clone(), 8080);
    service_all.set_network_interface(NetworkInterface::Unspec);

    // Service bound to specific interface by index
    let mut service_specific = MdnsService::new(service_type.clone(), 8080);
    service_specific.set_network_interface(NetworkInterface::AtIndex(2));

    // Query current interface setting
    match service_specific.network_interface() {
        NetworkInterface::Unspec => println!("Bound to all interfaces"),
        NetworkInterface::AtIndex(idx) => println!("Bound to interface {}", idx),
    }

    // Browser on specific interface
    let mut browser = MdnsBrowser::new(service_type);
    browser.set_network_interface(NetworkInterface::AtIndex(1));

    Ok(())
}
```

--------------------------------

### Handle Errors in mDNS Operations with Rust's Result Type

Source: https://context7.com/windy1/zeroconf-rs/llms.txt

Implement robust error handling for mDNS operations in Rust using zeroconf-rs's Result type. This includes managing errors from ServiceType creation, service registration, and TXT record manipulation. All library functions that can fail return a Result which should be checked.

```rust
use zeroconf::{ServiceType, MdnsService, TxtRecord};

fn main() {
    // Handle ServiceType creation errors
    match ServiceType::new("invalid.name", "tcp") {
        Ok(st) => println!("Created service type: {:?}", st),
        Err(e) => eprintln!("Invalid service type: {}", e),
    }

    // Handle service registration errors
    match register_service() {
        Ok(_) => println!("Service registered successfully"),
        Err(e) => eprintln!("Registration failed: {}", e),
    }

    // Handle TXT record errors
    let mut txt = TxtRecord::new();
    if let Err(e) = txt.insert("key", "value") {
        eprintln!("Failed to insert TXT record: {}", e);
    }
}

fn register_service() -> zeroconf::Result<()> {
    let service_type = ServiceType::new("http", "tcp")?;
    let mut service = MdnsService::new(service_type, 8080);

    service.set_name("test_service");

    // This returns Result<EventLoop>
    let _event_loop = service.register()?;

    Ok(())
}
```
Tokens:
Raw