X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fdatastore.rs;h=18aa0e68d067509a71ed992ca791b7b533c656db;hb=b2521170a57b654f8df69aacf8ccdfdb744d5172;hp=53f03edb24fdd664a5de2583764e9222d172380d;hpb=8ab30993f7a927d615a96b15425140e2edb3de70;p=dnsseed-rust

diff --git a/src/datastore.rs b/src/datastore.rs
index 53f03ed..18aa0e6 100644
--- a/src/datastore.rs
+++ b/src/datastore.rs
@@ -31,6 +31,61 @@ pub enum AddressState {
 	WasGood,
 }
 
+impl AddressState {
+	pub fn from_num(num: u8) -> Option<AddressState> {
+		match num {
+			0x0 => Some(AddressState::Untested),
+			0x1 => Some(AddressState::LowBlockCount),
+			0x2 => Some(AddressState::HighBlockCount),
+			0x3 => Some(AddressState::LowVersion),
+			0x4 => Some(AddressState::BadVersion),
+			0x5 => Some(AddressState::NotFullNode),
+			0x6 => Some(AddressState::ProtocolViolation),
+			0x7 => Some(AddressState::Timeout),
+			0x8 => Some(AddressState::TimeoutDuringRequest),
+			0x9 => Some(AddressState::Good),
+			0xa => Some(AddressState::WasGood),
+			_   => None,
+		}
+	}
+
+	pub fn to_num(&self) -> u8 {
+		match *self {
+			AddressState::Untested => 0,
+			AddressState::LowBlockCount => 1,
+			AddressState::HighBlockCount => 2,
+			AddressState::LowVersion => 3,
+			AddressState::BadVersion => 4,
+			AddressState::NotFullNode => 5,
+			AddressState::ProtocolViolation => 6,
+			AddressState::Timeout => 7,
+			AddressState::TimeoutDuringRequest => 8,
+			AddressState::Good => 9,
+			AddressState::WasGood => 10,
+		}
+	}
+
+	pub fn to_str(&self) -> &'static str {
+		match *self {
+			AddressState::Untested => "Untested",
+			AddressState::LowBlockCount => "Low Block Count",
+			AddressState::HighBlockCount => "High Block Count",
+			AddressState::LowVersion => "Low Version",
+			AddressState::BadVersion => "Bad Version",
+			AddressState::NotFullNode => "Not Full Node",
+			AddressState::ProtocolViolation => "Protocol Violation",
+			AddressState::Timeout => "Timeout",
+			AddressState::TimeoutDuringRequest => "Timeout During Request",
+			AddressState::Good => "Good",
+			AddressState::WasGood => "Was Good",
+		}
+	}
+
+	pub fn get_count() -> u8 {
+		11
+	}
+}
+
 #[derive(Hash, PartialEq, Eq)]
 pub enum U64Setting {
 	ConnsPerSec,
@@ -185,19 +240,9 @@ impl Store {
 				let state = try_read!(line_iter, u8);
 				let last_services = try_read!(line_iter, u64);
 				let node = Node {
-					state: match state {
-						0x0 => AddressState::Untested,
-						0x1 => AddressState::LowBlockCount,
-						0x2 => AddressState::HighBlockCount,
-						0x3 => AddressState::LowVersion,
-						0x4 => AddressState::BadVersion,
-						0x5 => AddressState::NotFullNode,
-						0x6 => AddressState::ProtocolViolation,
-						0x7 => AddressState::Timeout,
-						0x8 => AddressState::TimeoutDuringRequest,
-						0x9 => AddressState::Good,
-						0xa => AddressState::WasGood,
-						_   => return future::ok(res),
+					state: match AddressState::from_num(state) {
+						Some(v) => v,
+						None => return future::ok(res),
 					},
 					last_services,
 					last_update: Instant::now(),
@@ -270,11 +315,11 @@ impl Store {
 		}
 	}
 
-	pub fn set_node_state(&self, addr: SocketAddr, state: AddressState, services: u64) -> bool {
+	pub fn set_node_state(&self, addr: SocketAddr, state: AddressState, services: u64) -> AddressState {
 		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();
-		let ret = state != state_ref.state;
+		let ret = state_ref.state;
 		let now = Instant::now();
 		if (state_ref.state == AddressState::Good || state_ref.state == AddressState::WasGood)
 				&& state != AddressState::Good
@@ -342,19 +387,7 @@ impl Store {
 				for (ref sockaddr, ref node) in nodes.nodes_to_state.iter() {
 					nodes_buff += &sockaddr.to_string();
 					nodes_buff += ",";
-					nodes_buff += &match node.state {
-						AddressState::Untested => 0u8,
-						AddressState::LowBlockCount => 1u8,
-						AddressState::HighBlockCount => 2u8,
-						AddressState::LowVersion => 3u8,
-						AddressState::BadVersion => 4u8,
-						AddressState::NotFullNode => 5u8,
-						AddressState::ProtocolViolation => 6u8,
-						AddressState::Timeout => 7u8,
-						AddressState::TimeoutDuringRequest => 8u8,
-						AddressState::Good => 9u8,
-						AddressState::WasGood => 10u8,
-					}.to_string();
+					nodes_buff += &node.state.to_num().to_string();
 					nodes_buff += ",";
 					nodes_buff += &node.last_services.to_string();
 					nodes_buff += "\n";
@@ -448,12 +481,15 @@ impl Store {
 	}
 
 	pub fn get_next_scan_nodes(&self) -> Vec<SocketAddr> {
-		let mut res = Vec::with_capacity(600);
+		let results = 30 * self.get_u64(U64Setting::ConnsPerSec) as usize;
+		let per_bucket_results = results / (AddressState::get_count() as usize);
+		let mut res = Vec::with_capacity(results);
 		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(600 - res.len(), 60),
+			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);