X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=dnsseed-rust;a=blobdiff_plain;f=src%2Fdatastore.rs;h=26ed96bcb4feff30017a9942933d4c7c36485cee;hp=c56a86d7b84eebf927c1ad6126dd19f8eda780bf;hb=b161100d1919c1d4c678d91a1f49ecca1747327e;hpb=fd183ff08fa0b416e256a438f06fdbb1f589e61b

diff --git a/src/datastore.rs b/src/datastore.rs
index c56a86d..26ed96b 100644
--- a/src/datastore.rs
+++ b/src/datastore.rs
@@ -80,6 +80,10 @@ impl AddressState {
 			AddressState::WasGood => "Was Good",
 		}
 	}
+
+	pub fn get_count() -> u8 {
+		11
+	}
 }
 
 #[derive(Hash, PartialEq, Eq)]
@@ -288,34 +292,42 @@ 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 set_node_state(&self, addr: SocketAddr, state: AddressState, services: u64) -> bool {
+	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 {
 		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
@@ -477,12 +489,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);