datadot 0.0.1

A Data Dot is a micro executable that acts on its specified data point that is defined at start up, join a cluster, and interact with the colony.
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
76
77
78
79

extern crate dotlib;
extern crate clap;

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::io::BufRead;
use dotlib::dot::{Dot};
use clap::{App, Arg};

pub fn main() {
    let args = App::new("DataDot")
                        // Regular App configuration goes here...
                        .arg(Arg::with_name("data")
                                    .help("The data that the dot represents") 
                                    .takes_value(true)             
                                    .short("d")
                                    .long("data")
                                    .multiple(false)
                                    .required(true)
                        )
                        .arg(Arg::with_name("bind")
                                    .help("The multicast address to bind to (e.g.: 224.0.1.255")
                                    .takes_value(true)            
                                    .short("b")                    
                                    .long("bind")                 
                                    .multiple(false)                
                                    .required(true)                
                        )
                        .arg(Arg::with_name("plugin_dir")
                                    .help("[Optional] The path to the directory where the plugins are located.")
                                    .takes_value(true)            
                                    .short("x")                    
                                    .long("plg_dir")                 
                                    .multiple(false)                
                                    .required(false)                
                        )
                        .arg(Arg::with_name("port")
                                    .help("[Optional] The port number to use for multicasting, (default 7645).")
                                    .takes_value(true)            
                                    .short("p")                    
                                    .long("port")                 
                                    .multiple(false)                
                                    .required(false)                
                        )
                        .get_matches();

    let datapoint = args.value_of("data").unwrap().to_owned();
    let bind = args.value_of("bind").unwrap().to_owned();
    let bnd: Vec<u8> = bind.split(".").map(|b|{b.parse::<u8>().unwrap()}).collect();
    let a: IpAddr = Ipv4Addr::new(bnd[0], bnd[1], bnd[2], bnd[3]).into();
    let plg_dir = args.value_of("plugin_dir").to_owned();
    let p = args.value_of("port").unwrap_or_else(||"7645").to_owned().parse::<u16>().unwrap();
    let mut dot = Dot::new(a, p, datapoint.as_bytes(), plg_dir);

    assert!(dot.start_listener().is_ok());

    let stdin = ::std::io::stdin();
    for line in stdin.lock().lines() {
        let line = line.unwrap();
        if line == "stop" {
            assert!(dot.stop_listener().is_ok());
            assert!(dot.drop_plugins().is_ok());
            break;
        } else {
            //println!("processed: {}", dot.process_command(line.as_bytes()).is_ok());
            
            match dot.process_command(line.as_bytes()){
                Ok(v) => {
                    println!("{:?}",*v.downcast_ref::<String>().unwrap());
                }
                Err(e) => {
                    println!("{}", e);
                }
            }
            
        };
    }
    
    println!("Bye!");
}