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.

diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs
index ea24ef85e9b519461c9839fda30f5be571032e53..e93139bf0c2b0bf51fceeed432236d84a504498c 100644 (file)
--- a/lightning-background-processor/src/lib.rs
+++ b/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) }
        }