Fix was_good timer check

[dnsseed-rust] / src / datastore.rs

diff --git a/src/datastore.rs b/src/datastore.rs
index c8638181163e612eae57ff7f04bcc1f589af9ef6..53f03edb24fdd664a5de2583764e9222d172380d 100644 (file)
--- a/src/datastore.rs
+++ b/src/datastore.rs
@@ -46,9 +46,10 @@ pub enum RegexSetting {
 }
 
 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 {
@@ -200,6 +201,7 @@ impl Store {
                                        },
                                        last_services,
                                        last_update: Instant::now(),
+                                       last_good: Instant::now(),
                                };
                                if node.state == AddressState::Good {
                                        for i in 0..64 {
@@ -256,6 +258,7 @@ impl Store {
                                                        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));
                                        },
@@ -267,12 +270,15 @@ impl Store {
                }
        }
 
-       pub fn set_node_state(&self, addr: SocketAddr, state: AddressState, services: u64) {
+       pub fn set_node_state(&self, addr: SocketAddr, state: AddressState, services: u64) -> bool {
                let mut nodes_lock = self.nodes.write().unwrap();
                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 {
+               let ret = state != state_ref.state;
+               let now = Instant::now();
+               if (state_ref.state == AddressState::Good || state_ref.state == AddressState::WasGood)
+                               && state != AddressState::Good
+                               && state_ref.last_good >= now - 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 {
@@ -280,7 +286,7 @@ impl Store {
                                }
                        }
                        state_ref.last_services = 0;
-                       nodes.state_next_scan.get_mut(&AddressState::WasGood).unwrap().push((state_ref.last_update, addr));
+                       nodes.state_next_scan.get_mut(&AddressState::WasGood).unwrap().push((now, addr));
                } else {
                        state_ref.state = state;
                        if state == AddressState::Good {
@@ -291,9 +297,13 @@ impl Store {
                                                nodes.good_node_services.get_mut(&i).unwrap().remove(&addr);
                                        }
                                }
+                               state_ref.last_services = services;
+                               state_ref.last_good = now;
                        }
-                       nodes.state_next_scan.get_mut(&state).unwrap().push((state_ref.last_update, addr));
+                       nodes.state_next_scan.get_mut(&state).unwrap().push((now, addr));
                }
+               state_ref.last_update = now;
+               ret
        }
 
        pub fn save_data(&'static self) -> impl Future<Item=(), Error=()> {
@@ -363,15 +373,17 @@ impl Store {
                        {
                                let nodes = self.nodes.read().unwrap();
                                let mut rng = thread_rng();
-                               for i in 1u64..10u64 {
+                               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()).choose_multiple(&mut rng, 21).iter().map(|e| (*e).clone()).collect();
-                                                               v6_set = set_ref.iter().filter(|e| e.is_ipv6()).choose_multiple(&mut rng, 12).iter().map(|e| (*e).clone()).collect();
+                                                               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;
                                                        }
                                                }
@@ -388,8 +400,12 @@ impl Store {
                                                                }
                                                        }
                                                }
-                                               v4_set = first_set.unwrap().intersection(second_set.unwrap()).filter(|e| e.is_ipv4()).choose_multiple(&mut rng, 21).iter().map(|e| (*e).clone()).collect();
-                                               v6_set = first_set.unwrap().intersection(second_set.unwrap()).filter(|e| e.is_ipv6()).choose_multiple(&mut rng, 12).iter().map(|e| (*e).clone()).collect();
+                                               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;
@@ -399,20 +415,25 @@ impl Store {
                                                                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();
+                                                                       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()).choose_multiple(&mut rng, 21).iter().map(|e| (*e).clone()).collect();
-                                               v6_set = intersection_set_ref.unwrap().iter().filter(|e| e.is_ipv6()).choose_multiple(&mut rng, 12).iter().map(|e| (*e).clone()).collect();
+                                               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.bluematt.me\tIN\tA\t{}\n", i, a);
+                                               dns_buff += &format!("x{:x}.dnsseed\tIN\tA\t{}\n", i, a);
                                        }
                                        for a in v6_set {
-                                               dns_buff += &format!("x{:x}.dnsseed.bluematt.me\tIN\tAAAA\t{}\n", i, a);
+                                               dns_buff += &format!("x{:x}.dnsseed\tIN\tAAAA\t{}\n", i, a);
                                        }
                                }
                        }