use std::{cmp, mem};
use std::collections::{HashSet, HashMap, hash_map};
-use std::sync::RwLock;
+use std::sync::{Arc, RwLock};
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use std::io::{BufRead, BufReader};
use bitcoin::network::address::Address;
use rand::thread_rng;
-use rand::seq::SliceRandom;
+use rand::seq::{SliceRandom, IteratorRandom};
use tokio::prelude::*;
use tokio::fs::File;
use tokio::io::write_all;
+use regex::Regex;
+
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
pub enum AddressState {
Untested,
}
#[derive(Hash, PartialEq, Eq)]
-pub enum StringSetting {
+pub enum RegexSetting {
SubverRegex,
}
struct Node {
- state: AddressState,
- last_services: u64,
last_update: Instant,
+ last_good: Instant, // Ignored unless state is Good or WasGood
+ last_services: u64,
+ state: AddressState,
}
struct Nodes {
pub struct Store {
u64_settings: RwLock<HashMap<U64Setting, u64>>,
- subver_regex: RwLock<String>,
+ subver_regex: RwLock<Arc<Regex>>,
nodes: RwLock<Nodes>,
store: String,
}
u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest), try_read!(l, u64));
u64s.insert(U64Setting::RescanInterval(AddressState::Good), try_read!(l, u64));
u64s.insert(U64Setting::RescanInterval(AddressState::WasGood), try_read!(l, u64));
- future::ok((u64s, try_read!(l, String)))
- }).or_else(|_| -> future::FutureResult<(HashMap<U64Setting, u64>, String), ()> {
+ future::ok((u64s, try_read!(l, Regex)))
+ }).or_else(|_| -> future::FutureResult<(HashMap<U64Setting, u64>, Regex), ()> {
let mut u64s = HashMap::with_capacity(15);
- u64s.insert(U64Setting::ConnsPerSec, 50);
+ u64s.insert(U64Setting::ConnsPerSec, 10);
u64s.insert(U64Setting::RunTimeout, 120);
u64s.insert(U64Setting::WasGoodTimeout, 21600);
u64s.insert(U64Setting::RescanInterval(AddressState::Untested), 0);
u64s.insert(U64Setting::RescanInterval(AddressState::Good), 1800);
u64s.insert(U64Setting::RescanInterval(AddressState::WasGood), 1800);
u64s.insert(U64Setting::MinProtocolVersion, 10000); //XXX
- future::ok((u64s, ".*".to_string()))
+ future::ok((u64s, Regex::new(".*").unwrap()))
});
macro_rules! nodes_uninitd {
},
last_services,
last_update: Instant::now(),
+ last_good: Instant::now(),
};
if node.state == AddressState::Good {
for i in 0..64 {
settings_future.join(nodes_future).and_then(move |((u64_settings, regex), nodes)| {
future::ok(Store {
u64_settings: RwLock::new(u64_settings),
- subver_regex: RwLock::new(regex),
+ subver_regex: RwLock::new(Arc::new(regex)),
nodes: RwLock::new(nodes),
store,
})
*self.u64_settings.read().unwrap().get(&setting).unwrap()
}
+ pub fn set_u64(&self, setting: U64Setting, value: u64) {
+ *self.u64_settings.write().unwrap().get_mut(&setting).unwrap() = value;
+ }
+
pub fn get_node_count(&self, state: AddressState) -> usize {
self.nodes.read().unwrap().state_next_scan.get(&state).unwrap().len()
}
- pub fn get_string(&self, _setting: StringSetting) -> String {
- self.subver_regex.read().unwrap().clone()
+ pub fn get_regex(&self, _setting: RegexSetting) -> Arc<Regex> {
+ Arc::clone(&*self.subver_regex.read().unwrap())
+ }
+
+ pub fn set_regex(&self, _setting: RegexSetting, value: Regex) {
+ *self.subver_regex.write().unwrap() = Arc::new(value);
}
pub fn add_fresh_nodes(&self, addresses: &Vec<(u32, Address)>) {
state: AddressState::Untested,
last_services: 0,
last_update: cur_time,
+ last_good: Instant::now(),
});
nodes.state_next_scan.get_mut(&AddressState::Untested).unwrap().push((cur_time, socketaddr));
},
let nodes = nodes_lock.borrow_mut();
let state_ref = nodes.nodes_to_state.get_mut(&addr).unwrap();
state_ref.last_update = Instant::now();
- if state_ref.state == AddressState::Good && state != AddressState::Good {
+ if (state_ref.state == AddressState::Good || state_ref.state == AddressState::WasGood)
+ && state != AddressState::Good
+ && state_ref.last_good >= state_ref.last_update + Duration::from_secs(self.get_u64(U64Setting::WasGoodTimeout)) {
state_ref.state = AddressState::WasGood;
for i in 0..64 {
if state_ref.last_services & (1 << i) != 0 {
nodes.good_node_services.get_mut(&i).unwrap().remove(&addr);
}
}
+ state_ref.last_services = services;
+ state_ref.last_good = state_ref.last_update;
}
nodes.state_next_scan.get_mut(&state).unwrap().push((state_ref.last_update, addr));
}
pub fn save_data(&'static self) -> impl Future<Item=(), Error=()> {
let settings_file = self.store.clone() + "/settings";
let settings_future = File::create(settings_file.clone() + ".tmp").and_then(move |f| {
- let settings_string = format!("{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}",
+ let settings_string = format!("{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}",
self.get_u64(U64Setting::ConnsPerSec),
self.get_u64(U64Setting::RunTimeout),
self.get_u64(U64Setting::WasGoodTimeout),
self.get_u64(U64Setting::RescanInterval(AddressState::Timeout)),
self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest)),
self.get_u64(U64Setting::RescanInterval(AddressState::Good)),
- self.get_u64(U64Setting::RescanInterval(AddressState::WasGood)));
+ self.get_u64(U64Setting::RescanInterval(AddressState::WasGood)),
+ self.get_regex(RegexSetting::SubverRegex).as_str());
write_all(f, settings_string).and_then(|(mut f, _)| {
f.poll_sync_all()
}).and_then(|_| {
AddressState::Good => 9u8,
AddressState::WasGood => 10u8,
}.to_string();
+ nodes_buff += ",";
nodes_buff += &node.last_services.to_string();
nodes_buff += "\n";
}
}
write_all(f, nodes_buff)
}).and_then(|(mut f, _)| {
- f.poll_sync_all()
+ f.poll_sync_all()
}).and_then(|_| {
tokio::fs::rename(nodes_file.clone() + ".tmp", nodes_file)
});
- settings_future.join(nodes_future).then(|_| { future::ok(()) })
+
+ let dns_file = self.store.clone() + "/nodes.dump";
+ let dns_future = File::create(dns_file.clone() + ".tmp").and_then(move |f| {
+ let mut dns_buff = String::new();
+ {
+ let nodes = self.nodes.read().unwrap();
+ let mut rng = thread_rng();
+ for i in &[1u64, 4, 5, 8, 9, 12, 13, 1024, 1025, 1028, 1029, 1032, 1033, 1036, 1037] {
+ let mut v6_set = Vec::new();
+ let mut v4_set = Vec::new();
+ if i.count_ones() == 1 {
+ for j in 0..64 {
+ if i & (1 << j) != 0 {
+ let set_ref = nodes.good_node_services.get(&j).unwrap();
+ v4_set = set_ref.iter().filter(|e| e.is_ipv4() && e.port() == 8333)
+ .choose_multiple(&mut rng, 21).iter().map(|e| e.ip()).collect();
+ v6_set = set_ref.iter().filter(|e| e.is_ipv6() && e.port() == 8333)
+ .choose_multiple(&mut rng, 12).iter().map(|e| e.ip()).collect();
+ break;
+ }
+ }
+ } else if i.count_ones() == 2 {
+ let mut first_set = None;
+ let mut second_set = None;
+ for j in 0..64 {
+ if i & (1 << j) != 0 {
+ if first_set == None {
+ first_set = Some(nodes.good_node_services.get(&j).unwrap());
+ } else {
+ second_set = Some(nodes.good_node_services.get(&j).unwrap());
+ break;
+ }
+ }
+ }
+ v4_set = first_set.unwrap().intersection(second_set.unwrap())
+ .filter(|e| e.is_ipv4() && e.port() == 8333)
+ .choose_multiple(&mut rng, 21).iter().map(|e| e.ip()).collect();
+ v6_set = first_set.unwrap().intersection(second_set.unwrap())
+ .filter(|e| e.is_ipv6() && e.port() == 8333)
+ .choose_multiple(&mut rng, 12).iter().map(|e| e.ip()).collect();
+ } else {
+ //TODO: Could optimize this one a bit
+ let mut intersection;
+ let mut intersection_set_ref = None;
+ for j in 0..64 {
+ if i & (1 << j) != 0 {
+ if intersection_set_ref == None {
+ intersection_set_ref = Some(nodes.good_node_services.get(&j).unwrap());
+ } else {
+ let new_intersection = intersection_set_ref.unwrap()
+ .intersection(nodes.good_node_services.get(&j).unwrap()).map(|e| (*e).clone()).collect();
+ intersection = Some(new_intersection);
+ intersection_set_ref = Some(intersection.as_ref().unwrap());
+ }
+ }
+ }
+ v4_set = intersection_set_ref.unwrap().iter()
+ .filter(|e| e.is_ipv4() && e.port() == 8333)
+ .choose_multiple(&mut rng, 21).iter().map(|e| e.ip()).collect();
+ v6_set = intersection_set_ref.unwrap().iter()
+ .filter(|e| e.is_ipv6() && e.port() == 8333)
+ .choose_multiple(&mut rng, 12).iter().map(|e| e.ip()).collect();
+ }
+ for a in v4_set {
+ dns_buff += &format!("x{:x}.dnsseed\tIN\tA\t{}\n", i, a);
+ }
+ for a in v6_set {
+ dns_buff += &format!("x{:x}.dnsseed\tIN\tAAAA\t{}\n", i, a);
+ }
+ }
+ }
+ write_all(f, dns_buff)
+ }).and_then(|(mut f, _)| {
+ f.poll_sync_all()
+ }).and_then(|_| {
+ tokio::fs::rename(dns_file.clone() + ".tmp", dns_file)
+ });
+
+ settings_future.join3(nodes_future, dns_future).then(|_| { future::ok(()) })
}
pub fn get_next_scan_nodes(&self) -> Vec<SocketAddr> {