Struct MdnsService 

pub struct MdnsService { /* private fields */ }

A running service that discovers libp2p peers and responds to other libp2p peers’ queries on the local network.

Usage

In order to use mDNS to discover peers on the local network, use the MdnsService. This is done by creating a MdnsService then polling it in the same way as you would poll a stream.

Polling the MdnsService can produce either an MdnsQuery, corresponding to an mDNS query received by another node on the local network, or an MdnsResponse corresponding to a response to a query previously emitted locally. The MdnsService will automatically produce queries, which means that you will receive responses automatically.

When you receive an MdnsQuery, use the respond method to send back an answer to the node that emitted the query.

When you receive an MdnsResponse, use the provided methods to query the information received in the response.

Example

let _future_to_poll = async {
    let (mut service, packet) = service.next().await;

    match packet {
        MdnsPacket::Query(query) => {
            println!("Query from {:?}", query.remote_addr());
            let packets = build_query_response(
                query.query_id(),
                my_peer_id.clone(),
                vec![].into_iter(),
                Duration::from_secs(120),
            );
            for packet in packets {
                service.enqueue_response(packet);
            }
        }
        MdnsPacket::Response(response) => {
            for peer in response.discovered_peers() {
                println!("Discovered peer {:?}", peer.id());
                for addr in peer.addresses() {
                    println!("Address = {:?}", addr);
                }
            }
        }
        MdnsPacket::ServiceDiscovery(disc) => {
            let resp = build_service_discovery_response(
                disc.query_id(),
                Duration::from_secs(120),
            );
            service.enqueue_response(resp);
        }
    }
};

Implementations

impl MdnsService

pub async fn new() -> Result<Self>

Starts a new mDNS service.

pub async fn silent() -> Result<Self>

Same as new, but we don’t automatically send queries on the network.

pub fn enqueue_response(&mut self, rsp: Vec<u8>)

pub async fn next(self) -> (Self, MdnsPacket)

Returns a future resolving to itself and the next received MdnsPacket.

Trait Implementations

impl Debug for MdnsService

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.