add Transport::delivery_limit

2 files changed, 18 insertions, 13 deletions

diff --git a/src/state/peer.rs b/src/state/peer.rs
index 344bcdb..92329b2 100644
--- a/src/state/peer.rs
+++ b/src/state/peer.rs
@@ -382,7 +382,7 @@ mod tests {
     /// probes back off meanwhile.
     #[test]
     fn unreachable_until_heard_from() {
-        let timing = Timing::from_keepalive(Duration::from_secs(60));
+        let timing = Timing::from_keepalive(Duration::from_secs(60), Duration::from_secs(300));
         let mut peer = PeerState::new(true, &timing);
         let start = Instant::now();
         for _ in 0..UNREACHABLE_AFTER_HELLOS {
diff --git a/src/state/timing.rs b/src/state/timing.rs
index 3c4afe1..0dab3da 100644
--- a/src/state/timing.rs
+++ b/src/state/timing.rs
@@ -4,18 +4,16 @@ use std::time::Duration;
 
 use crate::backoff::Backoff;
 
-/// First wait for a sync answer; generous, since Mycelium delivers large messages in
-/// many small packets.
+/// First wait for a sync answer; generous, since a transport may take a while with large
+/// messages (Mycelium sends them in many small packets).
 const SYNC_REPLY_TIMEOUT: Duration = Duration::from_secs(10);
-/// Upper bound, as a multiple of the first wait: 5 minutes (Mycelium gives up on a
-/// message after five minutes).
+/// Upper bound, as a multiple of the first wait: 5 minutes, about as long as a transport
+/// tries to deliver a message (`Transport::delivery_limit`).
 const SYNC_REPLY_TIMEOUT_MAX_FACTOR: u32 = 30;
 /// Upper bound on the wait between probes of an unreachable peer, as a multiple of
 /// `dormant_probe`: an hour at the default keepalive (1m). A returning node HELLOs its own
 /// neighbours, so this only bounds how long one we never hear from stays out.
 const PROBE_MAX_FACTOR: u32 = 6;
-/// How long Mycelium tries to deliver a message before dropping it.
-const MYCELIUM_DELIVERY_LIMIT: Duration = Duration::from_secs(300);
 
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct Timing {
@@ -28,8 +26,9 @@ pub(crate) struct Timing {
     /// First wait for an answer to a sync message before sending again; doubles while
     /// answers stay out (`SyncSession::reply_backoff`).
     pub(crate) sync_reply_timeout: Duration,
-    /// How long the transport tries to deliver a message before dropping it (Mycelium:
-    /// five minutes): a peer silent for longer has nothing on the way to us any more.
+    /// How long the transport tries to deliver a message before dropping it
+    /// (`Transport::delivery_limit`): a peer silent for longer has nothing on the way to
+    /// us any more.
     pub(crate) delivery_limit: Duration,
 }
 
@@ -54,13 +53,19 @@ impl Timing {
     /// | Tests | 250 ms – 2 s | dormancy within seconds keeps tests short |
     /// | LAN, servers | 15–30 s | a returning or silent peer is noticed within a minute or two |
     /// | WAN, mobile, metered (the default, 1m) | 60–120 s | about 0.4 messages per second per node at `k` = 12 and 1m |
-    pub(crate) fn from_keepalive(keepalive: Duration) -> Self {
-        Self::new(keepalive, SYNC_REPLY_TIMEOUT)
+    ///
+    /// `delivery_limit`: the transport's (`Transport::delivery_limit`).
+    pub(crate) fn from_keepalive(keepalive: Duration, delivery_limit: Duration) -> Self {
+        Self::new(keepalive, SYNC_REPLY_TIMEOUT, delivery_limit)
     }
 
     /// [`from_keepalive`](Self::from_keepalive) with another first sync reply timeout:
     /// for tests, whose messages don't travel for seconds.
-    pub(crate) fn new(keepalive: Duration, sync_reply_timeout: Duration) -> Self {
+    pub(crate) fn new(
+        keepalive: Duration,
+        sync_reply_timeout: Duration,
+        delivery_limit: Duration,
+    ) -> Self {
         Self {
             keepalive,
             dormant_after: keepalive * 4, // dormant_after >= 4* keepalive to tolerate three lost PINGs in a row
@@ -72,7 +77,7 @@ impl Timing {
             // Only the source gets these, and only while catching up.
             catch_up_probe: (keepalive / 30).clamp(Duration::from_secs(1), Duration::from_secs(5)),
             sync_reply_timeout,
-            delivery_limit: MYCELIUM_DELIVERY_LIMIT,
+            delivery_limit,
         }
     }