Regularly poll other dnsseeds for new addrs

[dnsseed-rust] / src / datastore.rs

diff --git a/src/datastore.rs b/src/datastore.rs
index 6255cd4d033520de3a558b02a9260b90059e451d..26ed96bcb4feff30017a9942933d4c7c36485cee 100644 (file)
--- a/src/datastore.rs
+++ b/src/datastore.rs
@@ -292,27 +292,35 @@ impl Store {
                *self.subver_regex.write().unwrap() = Arc::new(value);
        }
 
-       pub fn add_fresh_nodes(&self, addresses: &Vec<(u32, Address)>) {
+       pub fn add_fresh_addrs<I: Iterator<Item=SocketAddr>>(&self, addresses: I) -> u64 {
+               let mut res = 0;
                let mut nodes = self.nodes.write().unwrap();
                let cur_time = Instant::now();
-               for &(_, ref addr) in addresses {
-                       if let Ok(socketaddr) = addr.socket_addr() {
-                               match nodes.nodes_to_state.entry(socketaddr.clone()) {
-                                       hash_map::Entry::Vacant(e) => {
-                                               e.insert(Node {
-                                                       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));
-                                       },
-                                       hash_map::Entry::Occupied(_) => {},
-                               }
-                       } else {
-                               //TODO: Handle onions
+               for addr in addresses {
+                       match nodes.nodes_to_state.entry(addr.clone()) {
+                               hash_map::Entry::Vacant(e) => {
+                                       e.insert(Node {
+                                               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, addr));
+                                       res += 1;
+                               },
+                               hash_map::Entry::Occupied(_) => {},
                        }
                }
+               res
+       }
+
+       pub fn add_fresh_nodes(&self, addresses: &Vec<(u32, Address)>) {
+               self.add_fresh_addrs(addresses.iter().filter_map(|(_, addr)| {
+                       match addr.socket_addr() {
+                               Ok(socketaddr) => Some(socketaddr),
+                               Err(_) => None, // TODO: Handle onions
+                       }
+               }));
        }
 
        pub fn set_node_state(&self, addr: SocketAddr, state: AddressState, services: u64) -> AddressState {
@@ -487,9 +495,9 @@ impl Store {
                let cur_time = Instant::now();
 
                let mut nodes = self.nodes.write().unwrap();
-               for (state, state_nodes) in nodes.state_next_scan.iter_mut() {
+               for (idx, (state, state_nodes)) in nodes.state_next_scan.iter_mut().enumerate() {
                        let cmp_time = cur_time - Duration::from_secs(self.get_u64(U64Setting::RescanInterval(*state)));
-                       let split_point = cmp::min(cmp::min(results - res.len(), per_bucket_results),
+                       let split_point = cmp::min(cmp::min(results - res.len(), results - (per_bucket_results * (AddressState::get_count() as usize - idx))),
                                        state_nodes.binary_search_by(|a| a.0.cmp(&cmp_time)).unwrap_or_else(|idx| idx));
                        let mut new_nodes = state_nodes.split_off(split_point);
                        mem::swap(&mut new_nodes, state_nodes);