rbn 0.1.4

A small CLI interface to the Reverse Beacon Network, displaying all global network spots in real time as a formatted feed in a terminal
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use clap::{App, Arg};
use colored::*;
use hambands::band::types::{Band, Hertz};
use hambands::search::get_band_by_name;
use pad::{Alignment, PadStr};
use rbn_lib::RbnClient;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;

fn main() {
    let matches = App::new("Reverse Beacon Network Client")
        .version("0.1.2")
        .author("Evan Pratten <ewpratten@gmail.com>")
        .arg(
            Arg::with_name("callsign")
                .short("c")
                .long("callsign")
                .takes_value(true)
                .help("Your callsign (used to authenticate with RBN)")
                .required(true),
        )
        .arg(
            Arg::with_name("filtercall")
                .short("f")
                .long("filtercall")
                .takes_value(true)
                .help("Callsign to filter by")
                .required(false),
        )
        .arg(
            Arg::with_name("band")
                .short("b")
                .long("band")
                .takes_value(true)
                .help("Band name to filter by. This can be used multiple times to filter multiple bands")
                .required(false)
                .multiple(true),
        )
        .get_matches();

    // Get the callsign
    let callsign = matches.value_of("callsign").unwrap().to_uppercase();
    println!("Welcome {}!", callsign.italic().bright_blue());

    // Get the filtercall
    let has_filtercall = matches.is_present("filtercall");
    let mut filtercall = "".to_string();
    if has_filtercall {
        filtercall = matches.value_of("filtercall").unwrap().to_uppercase();
        println!(
            "Filtering by callsign: {}",
            filtercall.italic().bright_blue()
        );
    }

    // Get all bands to filter by
    let has_band_filter = matches.is_present("band");
    let mut band_filter: Vec<&Band> = Vec::new();
    if has_band_filter {
        for band_name in matches.values_of("band").unwrap().collect::<Vec<_>>() {
            // Get reference to actual band definition
            let band = get_band_by_name(band_name);

            // If this band is valid, add it to the filter
            if band.is_ok() {
                let band = band.unwrap();
                band_filter.push(band);
                println!("Adding band filter for: {}", band.name.white().italic());
            }
        }
    }

    // Set up exit handler
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = running.clone();
    ctrlc::set_handler(move || {
        running_clone.store(false, Ordering::SeqCst);
    })
    .expect("Error setting Ctrl-C handler");

    // Begin input loop
    println!("{}", "Press CTRL+C to stop".bright_black());

    // Connect to Rbn
    let mut rbn = RbnClient::new_default_addr(callsign);
    let _thread = rbn.start(Arc::new(move |data| {
        // Skip if callsign is being filtered
        if has_filtercall && (data.spotter != filtercall && data.spotted != filtercall) {
            return;
        }

        // Skip if there is a band filter
        let frequency: Hertz = (data.frequency * 1000.0) as Hertz;
        if has_band_filter {
            let mut valid = false;
            for band in band_filter.iter() {
                if band.low_frequency <= frequency && frequency <= band.high_frequency {
                    valid = true;
                    break;
                }
            }
            if !valid {
                return;
            }
        }

        // Print the entry
        println!(
            "{} spotted {} on {} KHz",
            &data
                .spotter
                .pad_to_width_with_alignment(8, Alignment::Right)
                .green()
                .bold(),
            &data
                .spotted
                .pad_to_width_with_alignment(8, Alignment::Right)
                .bright_blue()
                .bold(),
            &data
                .frequency
                .to_string()
                .pad_to_width_with_alignment(10, Alignment::Right)
                .white()
                .bold()
        )
    }));

    // Wait for kill
    loop {
        if !running.load(Ordering::SeqCst) {
            break;
        }
    }

    println!("{}", "\nExiting..".bright_black());
}