Use flexible timer types in background processor's regular jobs

`background-processor` does a number of jobs on various timers.
Currently, those are all done by checking the timers every 100ms
by interrogating `std::time::Instant`. This is fine for the
threaded version, but we'd like more flexibility in the `futures`-
based `background-processor`.

Here we swap the `std::time::Instant` interrogation for a lambda
which we will switch out to the user-provided sleeper in the next
commit.

Author: TheBlueMatt

lightning-background-processor/src/lib.rs

@@ -207,15 +207,15 @@ macro_rules! define_run_body {
 	($persister: ident, $chain_monitor: ident, $process_chain_monitor_events: expr,
 	 $channel_manager: ident, $process_channel_manager_events: expr,
 	 $gossip_sync: ident, $peer_manager: ident, $logger: ident, $scorer: ident,
-	 $loop_exit_check: expr, $await: expr)
+	 $loop_exit_check: expr, $await: expr, $get_timer: expr, $timer_elapsed: expr)
 	=> { {
 		log_trace!($logger, "Calling ChannelManager's timer_tick_occurred on startup");
 		$channel_manager.timer_tick_occurred();
 
-		let mut last_freshness_call = Instant::now();
-		let mut last_ping_call = Instant::now();
-		let mut last_prune_call = Instant::now();
-		let mut last_scorer_persist_call = Instant::now();
+		let mut last_freshness_call = $get_timer(FRESHNESS_TIMER);
+		let mut last_ping_call = $get_timer(PING_TIMER);
+		let mut last_prune_call = $get_timer(FIRST_NETWORK_PRUNE_TIMER);
+		let mut last_scorer_persist_call = $get_timer(SCORER_PERSIST_TIMER);
 		let mut have_pruned = false;
 
 		loop {
@@ -237,9 +237,9 @@ macro_rules! define_run_body {
 
 			// We wait up to 100ms, but track how long it takes to detect being put to sleep,
 			// see `await_start`'s use below.
-			let await_start = Instant::now();
+			let mut await_start = $get_timer(1);
 			let updates_available = $await;
-			let await_time = await_start.elapsed();
+			let await_slow = $timer_elapsed(&mut await_start, 1);
 
 			if updates_available {
 				log_trace!($logger, "Persisting ChannelManager...");
@@ -251,12 +251,12 @@ macro_rules! define_run_body {
 				log_trace!($logger, "Terminating background processor.");
 				break;
 			}
-			if last_freshness_call.elapsed().as_secs() > FRESHNESS_TIMER {
+			if $timer_elapsed(&mut last_freshness_call, FRESHNESS_TIMER) {
 				log_trace!($logger, "Calling ChannelManager's timer_tick_occurred");
 				$channel_manager.timer_tick_occurred();
-				last_freshness_call = Instant::now();
+				last_freshness_call = $get_timer(FRESHNESS_TIMER);
 			}
-			if await_time > Duration::from_secs(1) {
+			if await_slow {
 				// On various platforms, we may be starved of CPU cycles for several reasons.
 				// E.g. on iOS, if we've been in the background, we will be entirely paused.
 				// Similarly, if we're on a desktop platform and the device has been asleep, we
@@ -271,18 +271,18 @@ macro_rules! define_run_body {
 				// peers.
 				log_trace!($logger, "100ms sleep took more than a second, disconnecting peers.");
 				$peer_manager.disconnect_all_peers();
-				last_ping_call = Instant::now();
-			} else if last_ping_call.elapsed().as_secs() > PING_TIMER {
+				last_ping_call = $get_timer(PING_TIMER);
+			} else if $timer_elapsed(&mut last_ping_call, PING_TIMER) {
 				log_trace!($logger, "Calling PeerManager's timer_tick_occurred");
 				$peer_manager.timer_tick_occurred();
-				last_ping_call = Instant::now();
+				last_ping_call = $get_timer(PING_TIMER);
 			}
 
 			// Note that we want to run a graph prune once not long after startup before
 			// falling back to our usual hourly prunes. This avoids short-lived clients never
 			// pruning their network graph. We run once 60 seconds after startup before
 			// continuing our normal cadence.
-			if last_prune_call.elapsed().as_secs() > if have_pruned { NETWORK_PRUNE_TIMER } else { FIRST_NETWORK_PRUNE_TIMER } {
+			if $timer_elapsed(&mut last_prune_call, if have_pruned { NETWORK_PRUNE_TIMER } else { FIRST_NETWORK_PRUNE_TIMER }) {
 				// The network graph must not be pruned while rapid sync completion is pending
 				if let Some(network_graph) = $gossip_sync.prunable_network_graph() {
 					log_trace!($logger, "Pruning and persisting network graph.");
@@ -292,19 +292,19 @@ macro_rules! define_run_body {
 						log_error!($logger, "Error: Failed to persist network graph, check your disk and permissions {}", e)
 					}
 
-					last_prune_call = Instant::now();
+					last_prune_call = $get_timer(NETWORK_PRUNE_TIMER);
 					have_pruned = true;
 				}
 			}
 
-			if last_scorer_persist_call.elapsed().as_secs() > SCORER_PERSIST_TIMER {
+			if $timer_elapsed(&mut last_scorer_persist_call, SCORER_PERSIST_TIMER) {
 				if let Some(ref scorer) = $scorer {
 					log_trace!($logger, "Persisting scorer");
 					if let Err(e) = $persister.persist_scorer(&scorer) {
 						log_error!($logger, "Error: Failed to persist scorer, check your disk and permissions {}", e)
 					}
 				}
-				last_scorer_persist_call = Instant::now();
+				last_scorer_persist_call = $get_timer(SCORER_PERSIST_TIMER);
 			}
 		}
 
@@ -411,7 +411,7 @@ where
 					false
 				}
 			}
-		})
+		}, |_| Instant::now(), |time: &Instant, dur| time.elapsed().as_secs() > dur)
 }
 
 impl BackgroundProcessor {
@@ -522,7 +522,8 @@ impl BackgroundProcessor {
 			define_run_body!(persister, chain_monitor, chain_monitor.process_pending_events(&event_handler),
 				channel_manager, channel_manager.process_pending_events(&event_handler),
 				gossip_sync, peer_manager, logger, scorer, stop_thread.load(Ordering::Acquire),
-				channel_manager.await_persistable_update_timeout(Duration::from_millis(100)))
+				channel_manager.await_persistable_update_timeout(Duration::from_millis(100)),
+				|_| Instant::now(), |time: &Instant, dur| time.elapsed().as_secs() > dur)
 		});
 		Self { stop_thread: stop_thread_clone, thread_handle: Some(handle) }
 	}