X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Fscorer.rs;h=8b5fae70abdbffa34e6a365f312eb654f5165d84;hb=e3bdfa0585b9900cd732d568169a3778005be523;hp=26fb05a72e98d1913576f290a45a626d4bacd29a;hpb=1c2b3c244e4273b6471b69e18d977298b4f60d44;p=rust-lightning

diff --git a/lightning/src/routing/scorer.rs b/lightning/src/routing/scorer.rs
index 26fb05a7..8b5fae70 100644
--- a/lightning/src/routing/scorer.rs
+++ b/lightning/src/routing/scorer.rs
@@ -44,18 +44,25 @@
 //! # }
 //! ```
 //!
+//! # Note
+//!
+//! If persisting [`Scorer`], it must be restored using the same [`Time`] parameterization. Using a
+//! different type results in undefined behavior. Specifically, persisting when built with feature
+//! `no-std` and restoring without it, or vice versa, uses different types and thus is undefined.
+//!
 //! [`find_route`]: crate::routing::router::find_route
 
 use routing;
 
+use ln::msgs::DecodeError;
 use routing::network_graph::NodeId;
 use routing::router::RouteHop;
+use util::ser::{Readable, Writeable, Writer};
 
 use prelude::*;
-#[cfg(not(feature = "no-std"))]
+use core::ops::Sub;
 use core::time::Duration;
-#[cfg(not(feature = "no-std"))]
-use std::time::Instant;
+use io::{self, Read};
 
 /// [`routing::Score`] implementation that provides reasonable default behavior.
 ///
@@ -65,12 +72,27 @@ use std::time::Instant;
 /// See [module-level documentation] for usage.
 ///
 /// [module-level documentation]: crate::routing::scorer
-pub struct Scorer {
+pub type Scorer = ScorerUsingTime::<DefaultTime>;
+
+/// Time used by [`Scorer`].
+#[cfg(not(feature = "no-std"))]
+pub type DefaultTime = std::time::Instant;
+
+/// Time used by [`Scorer`].
+#[cfg(feature = "no-std")]
+pub type DefaultTime = Eternity;
+
+/// [`routing::Score`] implementation parameterized by [`Time`].
+///
+/// See [`Scorer`] for details.
+///
+/// # Note
+///
+/// Mixing [`Time`] types between serialization and deserialization results in undefined behavior.
+pub struct ScorerUsingTime<T: Time> {
 	params: ScoringParameters,
-	#[cfg(not(feature = "no-std"))]
-	channel_failures: HashMap<u64, (u64, Instant)>,
-	#[cfg(feature = "no-std")]
-	channel_failures: HashMap<u64, u64>,
+	// TODO: Remove entries of closed channels.
+	channel_failures: HashMap<u64, ChannelFailure<T>>,
 }
 
 /// Parameters for configuring [`Scorer`].
@@ -78,19 +100,58 @@ pub struct ScoringParameters {
 	/// A fixed penalty in msats to apply to each channel.
 	pub base_penalty_msat: u64,
 
-	/// A penalty in msats to apply to a channel upon failure.
+	/// A penalty in msats to apply to a channel upon failing to relay a payment.
 	///
-	/// This may be reduced over time based on [`failure_penalty_half_life`].
+	/// This accumulates for each failure but may be reduced over time based on
+	/// [`failure_penalty_half_life`].
 	///
 	/// [`failure_penalty_half_life`]: Self::failure_penalty_half_life
 	pub failure_penalty_msat: u64,
 
-	/// The time needed before any accumulated channel failure penalties are cut in half.
-	#[cfg(not(feature = "no-std"))]
+	/// The time required to elapse before any accumulated [`failure_penalty_msat`] penalties are
+	/// cut in half.
+	///
+	/// # Note
+	///
+	/// When time is an [`Eternity`], as is default when enabling feature `no-std`, it will never
+	/// elapse. Therefore, this penalty will never decay.
+	///
+	/// [`failure_penalty_msat`]: Self::failure_penalty_msat
 	pub failure_penalty_half_life: Duration,
 }
 
-impl Scorer {
+impl_writeable_tlv_based!(ScoringParameters, {
+	(0, base_penalty_msat, required),
+	(2, failure_penalty_msat, required),
+	(4, failure_penalty_half_life, required),
+});
+
+/// Accounting for penalties against a channel for failing to relay any payments.
+///
+/// Penalties decay over time, though accumulate as more failures occur.
+struct ChannelFailure<T: Time> {
+	/// Accumulated penalty in msats for the channel as of `last_failed`.
+	undecayed_penalty_msat: u64,
+
+	/// Last time the channel failed. Used to decay `undecayed_penalty_msat`.
+	last_failed: T,
+}
+
+/// A measurement of time.
+pub trait Time: Sub<Duration, Output = Self> where Self: Sized {
+	/// Returns an instance corresponding to the current moment.
+	fn now() -> Self;
+
+	/// Returns the amount of time elapsed since `self` was created.
+	fn elapsed(&self) -> Duration;
+
+	/// Returns the amount of time passed since the beginning of [`Time`].
+	///
+	/// Used during (de-)serialization.
+	fn duration_since_epoch() -> Duration;
+}
+
+impl<T: Time> ScorerUsingTime<T> {
 	/// Creates a new scorer using the given scoring parameters.
 	pub fn new(params: ScoringParameters) -> Self {
 		Self {
@@ -105,20 +166,36 @@ impl Scorer {
 		Self::new(ScoringParameters {
 			base_penalty_msat: penalty_msat,
 			failure_penalty_msat: 0,
-			#[cfg(not(feature = "no-std"))]
 			failure_penalty_half_life: Duration::from_secs(0),
 		})
 	}
+}
+
+impl<T: Time> ChannelFailure<T> {
+	fn new(failure_penalty_msat: u64) -> Self {
+		Self {
+			undecayed_penalty_msat: failure_penalty_msat,
+			last_failed: T::now(),
+		}
+	}
+
+	fn add_penalty(&mut self, failure_penalty_msat: u64, half_life: Duration) {
+		self.undecayed_penalty_msat = self.decayed_penalty_msat(half_life) + failure_penalty_msat;
+		self.last_failed = T::now();
+	}
 
-	#[cfg(not(feature = "no-std"))]
-	fn decay_from(&self, penalty_msat: u64, last_failure: &Instant) -> u64 {
-		decay_from(penalty_msat, last_failure, self.params.failure_penalty_half_life)
+	fn decayed_penalty_msat(&self, half_life: Duration) -> u64 {
+		let decays = self.last_failed.elapsed().as_secs().checked_div(half_life.as_secs());
+		match decays {
+			Some(decays) => self.undecayed_penalty_msat >> decays,
+			None => 0,
+		}
 	}
 }
 
-impl Default for Scorer {
+impl<T: Time> Default for ScorerUsingTime<T> {
 	fn default() -> Self {
-		Scorer::new(ScoringParameters::default())
+		Self::new(ScoringParameters::default())
 	}
 }
 
@@ -127,55 +204,119 @@ impl Default for ScoringParameters {
 		Self {
 			base_penalty_msat: 500,
 			failure_penalty_msat: 1024 * 1000,
-			#[cfg(not(feature = "no-std"))]
 			failure_penalty_half_life: Duration::from_secs(3600),
 		}
 	}
 }
 
-impl routing::Score for Scorer {
+impl<T: Time> routing::Score for ScorerUsingTime<T> {
 	fn channel_penalty_msat(
 		&self, short_channel_id: u64, _source: &NodeId, _target: &NodeId
 	) -> u64 {
-		#[cfg(not(feature = "no-std"))]
-		let failure_penalty_msat = match self.channel_failures.get(&short_channel_id) {
-			Some((penalty_msat, last_failure)) => self.decay_from(*penalty_msat, last_failure),
-			None => 0,
-		};
-		#[cfg(feature = "no-std")]
-		let failure_penalty_msat =
-			self.channel_failures.get(&short_channel_id).copied().unwrap_or(0);
+		let failure_penalty_msat = self.channel_failures
+			.get(&short_channel_id)
+			.map_or(0, |value| value.decayed_penalty_msat(self.params.failure_penalty_half_life));
 
 		self.params.base_penalty_msat + failure_penalty_msat
 	}
 
-	fn payment_path_failed(&mut self, _path: &Vec<RouteHop>, short_channel_id: u64) {
+	fn payment_path_failed(&mut self, _path: &[&RouteHop], short_channel_id: u64) {
 		let failure_penalty_msat = self.params.failure_penalty_msat;
-		#[cfg(not(feature = "no-std"))]
-		{
-			let half_life = self.params.failure_penalty_half_life;
-			self.channel_failures
-				.entry(short_channel_id)
-				.and_modify(|(penalty_msat, last_failure)| {
-					let decayed_penalty = decay_from(*penalty_msat, last_failure, half_life);
-					*penalty_msat = decayed_penalty + failure_penalty_msat;
-					*last_failure = Instant::now();
-				})
-				.or_insert_with(|| (failure_penalty_msat, Instant::now()));
-		}
-		#[cfg(feature = "no-std")]
+		let half_life = self.params.failure_penalty_half_life;
 		self.channel_failures
 			.entry(short_channel_id)
-			.and_modify(|penalty_msat| *penalty_msat += failure_penalty_msat)
-			.or_insert(failure_penalty_msat);
+			.and_modify(|failure| failure.add_penalty(failure_penalty_msat, half_life))
+			.or_insert_with(|| ChannelFailure::new(failure_penalty_msat));
 	}
 }
 
 #[cfg(not(feature = "no-std"))]
-fn decay_from(penalty_msat: u64, last_failure: &Instant, half_life: Duration) -> u64 {
-	let decays = last_failure.elapsed().as_secs().checked_div(half_life.as_secs());
-	match decays {
-		Some(decays) => penalty_msat >> decays,
-		None => 0,
+impl Time for std::time::Instant {
+	fn now() -> Self {
+		std::time::Instant::now()
+	}
+
+	fn duration_since_epoch() -> Duration {
+		use std::time::SystemTime;
+		SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()
+	}
+
+	fn elapsed(&self) -> Duration {
+		std::time::Instant::elapsed(self)
+	}
+}
+
+/// A state in which time has no meaning.
+pub struct Eternity;
+
+impl Time for Eternity {
+	fn now() -> Self {
+		Self
+	}
+
+	fn duration_since_epoch() -> Duration {
+		Duration::from_secs(0)
+	}
+
+	fn elapsed(&self) -> Duration {
+		Duration::from_secs(0)
+	}
+}
+
+impl Sub<Duration> for Eternity {
+	type Output = Self;
+
+	fn sub(self, _other: Duration) -> Self {
+		self
+	}
+}
+
+impl<T: Time> Writeable for ScorerUsingTime<T> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.params.write(w)?;
+		self.channel_failures.write(w)?;
+		write_tlv_fields!(w, {});
+		Ok(())
+	}
+}
+
+impl<T: Time> Readable for ScorerUsingTime<T> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let res = Ok(Self {
+			params: Readable::read(r)?,
+			channel_failures: Readable::read(r)?,
+		});
+		read_tlv_fields!(r, {});
+		res
+	}
+}
+
+impl<T: Time> Writeable for ChannelFailure<T> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		let duration_since_epoch = T::duration_since_epoch() - self.last_failed.elapsed();
+		write_tlv_fields!(w, {
+			(0, self.undecayed_penalty_msat, required),
+			(2, duration_since_epoch, required),
+		});
+		Ok(())
+	}
+}
+
+impl<T: Time> Readable for ChannelFailure<T> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let mut undecayed_penalty_msat = 0;
+		let mut duration_since_epoch = Duration::from_secs(0);
+		read_tlv_fields!(r, {
+			(0, undecayed_penalty_msat, required),
+			(2, duration_since_epoch, required),
+		});
+		Ok(Self {
+			undecayed_penalty_msat,
+			last_failed: T::now() - (T::duration_since_epoch() - duration_since_epoch),
+		})
 	}
 }