ledcat 0.0.1

Ledcat is simple utility that aims to provide a standard interface for driving LED-strips and such
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

use std::borrow::Cow;
use std::fs;
use std::io::{self, BufRead};
use std::net;
use std::path;
use std::sync::{Arc, RwLock};
use std::thread;
use std::time;


pub trait Target {
    fn addresses<'a>(&'a self) -> Cow<'a, [net::SocketAddr]>;
}


impl Target for Vec<net::SocketAddr> {
    fn addresses<'a>(&'a self) -> Cow<'a, [net::SocketAddr]> {
        Cow::Borrowed(&self)
    }
}


pub struct Broadcast {}

impl Target for Broadcast {
    fn addresses<'a>(&'a self) -> Cow<'a, [net::SocketAddr]> {
        let ip = net::Ipv4Addr::new(255, 255, 255, 255);
        let addrs = vec![net::SocketAddrV4::new(ip, super::PORT).into()];
        Cow::Owned(addrs)
    }
}


pub struct ListFile {
    cache: Arc<RwLock<Vec<net::SocketAddr>>>,
}

impl ListFile {
    pub fn new<T: Into<path::PathBuf>>(p: T) -> ListFile {
        let path = p.into();
        let cache = Arc::new(RwLock::new(Vec::new()));

        let cache_weak = Arc::downgrade(&cache);
        thread::spawn(move || {
            macro_rules! try_or_continue {
                ($expr:expr) => {{
                    match $expr {
                        Ok(t) => t,
                        Err(_) => continue,
                    }
                }}
            }

            let mut prev_mod_time = None;
            loop {
                let meta = try_or_continue!(fs::metadata(&path));
                let mod_time = try_or_continue!(meta.modified());
                let reload = prev_mod_time != Some(mod_time);
                prev_mod_time = Some(mod_time);

                if reload {
                    let cache = match cache_weak.upgrade() {
                        Some(c) => c,
                        None => return,
                    };
                    let mut v = cache.write().unwrap();
                    v.clear();

                    let file = try_or_continue!(fs::File::open(&path));
                    let addrs = io::BufReader::new(file).lines()
                        .filter_map(|rs| {
                            rs.ok()
                        })
                        .filter_map(|line| {
                            line.parse().ok()
                                .or_else(|| {
                                    line.parse().ok()
                                        .map(|ip| net::SocketAddr::new(ip, super::PORT))
                                })
                        });
                    v.extend(addrs);
                    v.dedup();
                }

                thread::sleep(time::Duration::new(1, 0));
            }
        });

        ListFile { cache }
    }
}

impl Target for ListFile {
    fn addresses<'a>(&'a self) -> Cow<'a, [net::SocketAddr]> {
        Cow::Owned(self.cache.read().unwrap().clone())
    }
}