Add a category for timedout pong

[dnsseed-rust] / src / datastore.rs

diff --git a/src/datastore.rs b/src/datastore.rs
index 827726e9aae9dae21a1d8c71840c7e8dc2325881..4f59305b30f5cf17e634b493f8742700b75a411f 100644 (file)
--- a/src/datastore.rs
+++ b/src/datastore.rs
@@ -27,6 +27,9 @@ pub enum AddressState {
        ProtocolViolation,
        Timeout,
        TimeoutDuringRequest,
+       TimeoutAwaitingPong,
+       TimeoutAwaitingAddr,
+       TimeoutAwaitingBlock,
        Good,
        WasGood,
 }
@@ -43,8 +46,11 @@ impl AddressState {
                        0x6 => Some(AddressState::ProtocolViolation),
                        0x7 => Some(AddressState::Timeout),
                        0x8 => Some(AddressState::TimeoutDuringRequest),
-                       0x9 => Some(AddressState::Good),
-                       0xa => Some(AddressState::WasGood),
+                       0x9 => Some(AddressState::TimeoutAwaitingPong),
+                       0xa => Some(AddressState::TimeoutAwaitingAddr),
+                       0xb => Some(AddressState::TimeoutAwaitingBlock),
+                       0xc => Some(AddressState::Good),
+                       0xd => Some(AddressState::WasGood),
                        _   => None,
                }
        }
@@ -60,8 +66,11 @@ impl AddressState {
                        AddressState::ProtocolViolation => 6,
                        AddressState::Timeout => 7,
                        AddressState::TimeoutDuringRequest => 8,
-                       AddressState::Good => 9,
-                       AddressState::WasGood => 10,
+                       AddressState::TimeoutAwaitingPong => 9,
+                       AddressState::TimeoutAwaitingAddr => 10,
+                       AddressState::TimeoutAwaitingBlock => 11,
+                       AddressState::Good => 12,
+                       AddressState::WasGood => 13,
                }
        }
 
@@ -76,13 +85,16 @@ impl AddressState {
                        AddressState::ProtocolViolation => "Protocol Violation",
                        AddressState::Timeout => "Timeout",
                        AddressState::TimeoutDuringRequest => "Timeout During Request",
+                       AddressState::TimeoutAwaitingPong => "Timeout Awaiting Pong",
+                       AddressState::TimeoutAwaitingAddr => "Timeout Awaiting Addr",
+                       AddressState::TimeoutAwaitingBlock => "Timeout Awaiting Block",
                        AddressState::Good => "Good",
                        AddressState::WasGood => "Was Good",
                }
        }
 
-       pub fn get_count() -> u8 {
-               11
+       pub const fn get_count() -> u8 {
+               14
        }
 }
 
@@ -153,7 +165,7 @@ impl Store {
                                        }
                                } }
                        }
-                       let mut u64s = HashMap::with_capacity(15);
+                       let mut u64s = HashMap::with_capacity(AddressState::get_count() as usize + 4);
                        u64s.insert(U64Setting::ConnsPerSec, try_read!(l, u64));
                        u64s.insert(U64Setting::RunTimeout, try_read!(l, u64));
                        u64s.insert(U64Setting::WasGoodTimeout, try_read!(l, u64));
@@ -167,6 +179,9 @@ impl Store {
                        u64s.insert(U64Setting::RescanInterval(AddressState::ProtocolViolation), try_read!(l, u64));
                        u64s.insert(U64Setting::RescanInterval(AddressState::Timeout), try_read!(l, u64));
                        u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest), try_read!(l, u64));
+                       u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingPong), try_read!(l, u64));
+                       u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingAddr), try_read!(l, u64));
+                       u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingBlock), 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, Regex)))
@@ -184,9 +199,12 @@ impl Store {
                        u64s.insert(U64Setting::RescanInterval(AddressState::ProtocolViolation), 86400);
                        u64s.insert(U64Setting::RescanInterval(AddressState::Timeout), 86400);
                        u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest), 21600);
+                       u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingPong), 3600);
+                       u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingAddr), 1800);
+                       u64s.insert(U64Setting::RescanInterval(AddressState::TimeoutAwaitingBlock), 3600);
                        u64s.insert(U64Setting::RescanInterval(AddressState::Good), 1800);
                        u64s.insert(U64Setting::RescanInterval(AddressState::WasGood), 1800);
-                       u64s.insert(U64Setting::MinProtocolVersion, 10000); //XXX
+                       u64s.insert(U64Setting::MinProtocolVersion, 70002);
                        future::ok((u64s, Regex::new(".*").unwrap()))
                });
 
@@ -360,7 +378,7 @@ impl Store {
        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{}\n{}",
+                       let settings_string = format!("{}\n{}\n{}\n{}\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),
@@ -374,6 +392,9 @@ impl Store {
                                self.get_u64(U64Setting::RescanInterval(AddressState::ProtocolViolation)),
                                self.get_u64(U64Setting::RescanInterval(AddressState::Timeout)),
                                self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutDuringRequest)),
+                               self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutAwaitingPong)),
+                               self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutAwaitingAddr)),
+                               self.get_u64(U64Setting::RescanInterval(AddressState::TimeoutAwaitingBlock)),
                                self.get_u64(U64Setting::RescanInterval(AddressState::Good)),
                                self.get_u64(U64Setting::RescanInterval(AddressState::WasGood)),
                                self.get_regex(RegexSetting::SubverRegex).as_str());
@@ -496,7 +517,7 @@ impl Store {
                        let mut nodes = self.nodes.write().unwrap();
                        for (idx, state_nodes) in nodes.state_next_scan.iter_mut().enumerate() {
                                let cmp_time = cur_time - Duration::from_secs(self.get_u64(U64Setting::RescanInterval(AddressState::from_num(idx as u8).unwrap())));
-                               let split_point = cmp::min(cmp::min(results - res.len(), results - (per_bucket_results * (AddressState::get_count() as usize - idx))),
+                               let split_point = cmp::min(cmp::min(results - res.len(), (per_bucket_results * (idx + 1)) - res.len()),
                                                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);