discovery 0.1.5

Service discovery via dns and vlan
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use discovery::{dns::discover, vlan};
use std::collections::HashSet;
use std::net::{Shutdown, SocketAddr};
use structopt::StructOpt;

#[derive(Debug, StructOpt)]
#[structopt(name = "discovery", about = "A tool for discovering services")]
enum Command {
    Dns {
        #[structopt(long)]
        domain: String,

        #[structopt(long)]
        prefix: String,

        #[structopt(long)]
        tags: String,

        #[structopt(long, default_value = "8.8.8.8:53")]
        dns_server: String,
    },
    Vlan {
        #[structopt(long, default_value = "12345")]
        broadcast_port: u16,
    },
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let args = Command::from_args();

    match args {
        Command::Vlan { broadcast_port } => {
            let (_up, _fin, _shutodwn_tx, nodes) = vlan::discover(broadcast_port).await.unwrap();
            while let Ok(ip) = nodes.rx().recv().await {
                dbg!(ip);
            }
        }
        Command::Dns {
            dns_server,
            domain,
            prefix,
            tags,
        } => {
            let dns_server: SocketAddr = dns_server.parse()?;
            let tags: Vec<String> = tags.split(',').map(|s| s.to_string()).collect();
            let mut uniq_ips = HashSet::new();

            let (up_rx, fin_rx, shutdown_rx, nodes) =
                discover(vec![], dns_server, domain, prefix, tags)
                    .await
                    .unwrap();

            let _ = up_rx.await;

            for node in &nodes.all() {
                uniq_ips.insert(node.ip());
            }

            let all_ips: Vec<_> = uniq_ips.into_iter().collect();
            println!(
                "{}",
                all_ips
                    .into_iter()
                    .map(|a| a.to_string())
                    .collect::<Vec<String>>()
                    .join(" ")
            );

            let _ = shutdown_rx.send(());
        }
    }

    Ok(())
}