Track the time a stale channel was pruned

Author: naumenkogs

lightning/src/routing/gossip.rs

@@ -143,7 +143,7 @@ pub struct NetworkGraph<L: Deref> where L::Target: Logger {
 	/// failure so that we don't resync them from gossip. Each SCID is mapped to the instant when we
 	/// removed it from the network graph so that we can forget we removed it after some time (by
 	/// removing it from this map) and it can be resynced from gossip if it appears again.
-	removed_channels: Mutex<HashMap<u64, Instant>>,
+	removed_channels: Mutex<HashMap<u64, u64>>,
 	#[cfg(feature = "std")]
 	/// Keeps track of [`NodeId`]s we have explicitly removed due to permanent failure so that we
 	/// don't resync them from gossip. Each [`NodeId`] is mapped to the instant when we removed it
@@ -1588,7 +1588,8 @@ impl<L: Deref> NetworkGraph<L> where L::Target: Logger {
 			if let Some(chan) = channels.remove(&short_channel_id) {
 				let mut nodes = self.nodes.write().unwrap();
 				#[cfg(feature = "std")]
-				self.removed_channels.lock().unwrap().insert(short_channel_id, Instant::now());
+				let cur_time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs();
+				self.removed_channels.lock().unwrap().insert(short_channel_id, cur_time);
 				Self::remove_channel_in_nodes(&mut nodes, &chan, short_channel_id);
 			}
 		} else {
@@ -1616,8 +1617,6 @@ impl<L: Deref> NetworkGraph<L> where L::Target: Logger {
 		let mut removed_channels = self.removed_channels.lock().unwrap();
 		#[cfg(feature = "std")]
 		let mut removed_nodes = self.removed_nodes.lock().unwrap();
-		#[cfg(feature = "std")]
-		let time = Instant::now();
 
 		if let Some(node) = nodes.remove(&node_id) {
 			for scid in node.channels.iter() {
@@ -1632,11 +1631,11 @@ impl<L: Deref> NetworkGraph<L> where L::Target: Logger {
 						}
 					}
 					#[cfg(feature = "std")]
-					removed_channels.insert(*scid, time);
+					removed_channels.insert(*scid, SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).expect("Time must be > 1970").as_secs());
 				}
 			}
 			#[cfg(feature = "std")]
-			removed_nodes.insert(node_id, time);
+			removed_nodes.insert(node_id, Instant::now());
 		}
 	}
 
@@ -1702,12 +1701,20 @@ impl<L: Deref> NetworkGraph<L> where L::Target: Logger {
 			for scid in scids_to_remove {
 				let info = channels.remove(&scid).expect("We just accessed this scid, it should be present");
 				Self::remove_channel_in_nodes(&mut nodes, &info, scid);
+				self.removed_channels.lock().unwrap().insert(scid, current_time_unix);
 			}
 		}
 
+		self.removed_channels.lock().unwrap().retain(|_, time| {
+			if current_time_unix > *time {
+				return current_time_unix - *time < REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS;
+			} else {
+				return true;
+			}
+		});
+
 		#[cfg(feature = "std")]
 		{
-			self.removed_channels.lock().unwrap().retain(|_, time| time.elapsed().as_secs() < REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS);
 			self.removed_nodes.lock().unwrap().retain(|_, time| time.elapsed().as_secs() < REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS);
 		}
 	}
@@ -2586,9 +2593,6 @@ use super::STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS;
 
 		#[cfg(feature = "std")]
 		{
-			use std::time::Duration;
-			use util::time::tests::SinceEpoch;
-
 			// Clear tracked nodes and channels for clean slate
 			network_graph.removed_channels.lock().unwrap().clear();
 			network_graph.removed_nodes.lock().unwrap().clear();
@@ -2601,15 +2605,15 @@ use super::STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS;
 			// Mark the channel as permanently failed. This will also remove the two nodes
 			// and all of the entries will be tracked as removed.
 			network_graph.channel_failed(short_channel_id, true);
+			use std::time::{SystemTime, UNIX_EPOCH};
+			let failure_time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs();
 
 			// Should not remove from tracking if insufficient time has passed
-			SinceEpoch::advance(Duration::from_secs(REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS - 1));
-			network_graph.remove_stale_channels_and_tracking();
+			network_graph.remove_stale_channels_and_tracking_with_time(failure_time);
 			assert_eq!(network_graph.removed_channels.lock().unwrap().len(), 1);
 
 			// Advance mock time so the entries are removed on next call
-			SinceEpoch::advance(Duration::from_secs(1));
-			network_graph.remove_stale_channels_and_tracking();
+			network_graph.remove_stale_channels_and_tracking_with_time(failure_time + REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS + 1);
 			assert!(network_graph.removed_channels.lock().unwrap().is_empty());
 			assert!(network_graph.removed_nodes.lock().unwrap().is_empty());
 		}