Correct the directionality of liquidity non-update messages

[rust-lightning] / lightning / src / routing / scoring.rs

diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs
index 66900f2ba43bce7553bd951754c7684f3b314910..3030c930818e631aae705e785dfa6afdfb56fa70 100644 (file)
--- a/lightning/src/routing/scoring.rs
+++ b/lightning/src/routing/scoring.rs
@@ -189,9 +189,9 @@ pub struct MultiThreadedLockableScore<S: Score> {
 }
 #[cfg(c_bindings)]
 /// A locked `MultiThreadedLockableScore`.
-pub struct MultiThreadedLockableScoreLock<'a, S: Score>(MutexGuard<'a, S>);
+pub struct MultiThreadedScoreLock<'a, S: Score>(MutexGuard<'a, S>);
 #[cfg(c_bindings)]
-impl<'a, T: Score + 'a> Score for MultiThreadedLockableScoreLock<'a, T> {
+impl<'a, T: Score + 'a> Score for MultiThreadedScoreLock<'a, T> {
        fn channel_penalty_msat(&self, scid: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage) -> u64 {
                self.0.channel_penalty_msat(scid, source, target, usage)
        }
@@ -209,7 +209,7 @@ impl<'a, T: Score + 'a> Score for MultiThreadedLockableScoreLock<'a, T> {
        }
 }
 #[cfg(c_bindings)]
-impl<'a, T: Score + 'a> Writeable for MultiThreadedLockableScoreLock<'a, T> {
+impl<'a, T: Score + 'a> Writeable for MultiThreadedScoreLock<'a, T> {
        fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
                self.0.write(writer)
        }
@@ -217,10 +217,10 @@ impl<'a, T: Score + 'a> Writeable for MultiThreadedLockableScoreLock<'a, T> {
 
 #[cfg(c_bindings)]
 impl<'a, T: Score + 'a> LockableScore<'a> for MultiThreadedLockableScore<T> {
-       type Locked = MultiThreadedLockableScoreLock<'a, T>;
+       type Locked = MultiThreadedScoreLock<'a, T>;
 
-       fn lock(&'a self) -> MultiThreadedLockableScoreLock<'a, T> {
-               MultiThreadedLockableScoreLock(Mutex::lock(&self.score).unwrap())
+       fn lock(&'a self) -> MultiThreadedScoreLock<'a, T> {
+               MultiThreadedScoreLock(Mutex::lock(&self.score).unwrap())
        }
 }
 
@@ -753,21 +753,25 @@ impl<L: Deref<Target = u64>, T: Time, U: Deref<Target = T>> DirectedChannelLiqui
 impl<L: DerefMut<Target = u64>, T: Time, U: DerefMut<Target = T>> DirectedChannelLiquidity<L, T, U> {
        /// Adjusts the channel liquidity balance bounds when failing to route `amount_msat`.
        fn failed_at_channel<Log: Deref>(&mut self, amount_msat: u64, chan_descr: fmt::Arguments, logger: &Log) where Log::Target: Logger {
-               if amount_msat < self.max_liquidity_msat() {
-                       log_debug!(logger, "Setting max liquidity of {} to {}", chan_descr, amount_msat);
+               let existing_max_msat = self.max_liquidity_msat();
+               if amount_msat < existing_max_msat {
+                       log_debug!(logger, "Setting max liquidity of {} from {} to {}", chan_descr, existing_max_msat, amount_msat);
                        self.set_max_liquidity_msat(amount_msat);
                } else {
-                       log_trace!(logger, "Max liquidity of {} already more than {}", chan_descr, amount_msat);
+                       log_trace!(logger, "Max liquidity of {} is {} (already less than or equal to {})",
+                               chan_descr, existing_max_msat, amount_msat);
                }
        }
 
        /// Adjusts the channel liquidity balance bounds when failing to route `amount_msat` downstream.
        fn failed_downstream<Log: Deref>(&mut self, amount_msat: u64, chan_descr: fmt::Arguments, logger: &Log) where Log::Target: Logger {
-               if amount_msat > self.min_liquidity_msat() {
-                       log_debug!(logger, "Setting min liquidity of {} to {}", chan_descr, amount_msat);
+               let existing_min_msat = self.min_liquidity_msat();
+               if amount_msat > existing_min_msat {
+                       log_debug!(logger, "Setting min liquidity of {} from {} to {}", existing_min_msat, chan_descr, amount_msat);
                        self.set_min_liquidity_msat(amount_msat);
                } else {
-                       log_trace!(logger, "Min liquidity of {} already less than {}", chan_descr, amount_msat);
+                       log_trace!(logger, "Min liquidity of {} is {} (already greater than or equal to {})",
+                               chan_descr, existing_min_msat, amount_msat);
                }
        }