Implement (de)serialization for Scorer

Scorer should be serialized to retain penalty data between restarts.
Implement (de)serialization for Scorer by serializing last failure times
as duration since the UNIX epoch. For no-std, the zero-Duration is used.

Author: jkczyz

lightning/src/routing/scorer.rs

@@ -48,11 +48,15 @@
 
 use routing;
 
+use ln::msgs::DecodeError;
 use routing::network_graph::NodeId;
 use routing::router::RouteHop;
+use util::ser::{Readable, Writeable, Writer};
 
 use prelude::*;
+use core::ops::Sub;
 use core::time::Duration;
+use io::{self, Read};
 
 /// [`routing::Score`] implementation that provides reasonable default behavior.
 ///
@@ -75,7 +79,7 @@ pub type DefaultClock = AlwaysPresent;
 /// [`routing::Score`] implementation parameterized by a [`Clock`].
 ///
 /// See [`Scorer`] for details.
-pub struct ScorerUsingClock<C: Clock> {
+pub struct ScorerUsingClock<C: Clock + Sub<Duration, Output = C>> {
 	params: ScoringParameters,
 	channel_failures: HashMap<u64, ChannelFailure<C>>,
 }
@@ -96,10 +100,16 @@ pub struct ScoringParameters {
 	pub failure_penalty_half_life: Duration,
 }
 
+impl_writeable_tlv_based!(ScoringParameters, {
+	(0, base_penalty_msat, required),
+	(2, failure_penalty_msat, required),
+	(4, failure_penalty_half_life, required),
+});
+
 /// Accounting for penalties from channel failures.
 ///
 /// Penalties decay over time, though accumulated as more failures occur.
-struct ChannelFailure<C: Clock> {
+struct ChannelFailure<C: Clock + Sub<Duration, Output = C>> {
 	/// Accumulated penalty in msats for the channel as of `last_failed`.
 	undecayed_penalty_msat: u64,
 
@@ -116,7 +126,7 @@ pub trait Clock {
 	fn elapsed(&self) -> Duration;
 }
 
-impl<C: Clock> ScorerUsingClock<C> {
+impl<C: Clock + Sub<Duration, Output = C>> ScorerUsingClock<C> {
 	/// Creates a new scorer using the given scoring parameters.
 	pub fn new(params: ScoringParameters) -> Self {
 		Self {
@@ -136,7 +146,7 @@ impl<C: Clock> ScorerUsingClock<C> {
 	}
 }
 
-impl<C: Clock> ChannelFailure<C> {
+impl<C: Clock + Sub<Duration, Output = C>> ChannelFailure<C> {
 	fn new(failure_penalty_msat: u64) -> Self {
 		Self {
 			undecayed_penalty_msat: failure_penalty_msat,
@@ -158,7 +168,7 @@ impl<C: Clock> ChannelFailure<C> {
 	}
 }
 
-impl<C: Clock> Default for ScorerUsingClock<C> {
+impl<C: Clock + Sub<Duration, Output = C>> Default for ScorerUsingClock<C> {
 	fn default() -> Self {
 		Self::new(ScoringParameters::default())
 	}
@@ -174,7 +184,7 @@ impl Default for ScoringParameters {
 	}
 }
 
-impl<C: Clock> routing::Score for ScorerUsingClock<C> {
+impl<C: Clock + Sub<Duration, Output = C>> routing::Score for ScorerUsingClock<C> {
 	fn channel_penalty_msat(
 		&self, short_channel_id: u64, _source: &NodeId, _target: &NodeId
 	) -> u64 {
@@ -218,3 +228,57 @@ impl Clock for AlwaysPresent {
 		Duration::from_secs(0)
 	}
 }
+
+impl Sub<Duration> for AlwaysPresent {
+	type Output = Self;
+
+	fn sub(self, _other: Duration) -> Self {
+		self
+	}
+}
+
+impl<C: Clock + Sub<Duration, Output = C>> Writeable for ScorerUsingClock<C> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.params.write(w)?;
+		self.channel_failures.write(w)
+	}
+}
+
+impl<C: Clock + Sub<Duration, Output = C>> Readable for ScorerUsingClock<C> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		Ok(Self {
+			params: Readable::read(r)?,
+			channel_failures: Readable::read(r)?,
+		})
+	}
+}
+
+impl<C: Clock + Sub<Duration, Output = C>> Writeable for ChannelFailure<C> {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.undecayed_penalty_msat.write(w)?;
+		(duration_since_epoch() - self.last_failed.elapsed()).write(w)
+	}
+}
+
+impl<C: Clock + Sub<Duration, Output = C>> Readable for ChannelFailure<C> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		Ok(Self {
+			undecayed_penalty_msat: Readable::read(r)?,
+			last_failed: C::now() - (duration_since_epoch() - Readable::read(r)?),
+		})
+	}
+}
+
+fn duration_since_epoch() -> Duration {
+	#[cfg(not(feature = "no-std"))]
+	{
+		use std::time::SystemTime;
+		SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()
+	}
+	#[cfg(feature = "no-std")]
+	return Duration::from_secs(0);
+}

lightning/src/util/ser.rs

@@ -27,6 +27,7 @@ use bitcoin::consensus::Encodable;
 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 use bitcoin::hash_types::{Txid, BlockHash};
 use core::marker::Sized;
+use core::time::Duration;
 use ln::msgs::DecodeError;
 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 
@@ -911,3 +912,19 @@ impl Readable for String {
 		Ok(ret)
 	}
 }
+
+impl Writeable for Duration {
+	#[inline]
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+		self.as_secs().write(w)?;
+		self.subsec_nanos().write(w)
+	}
+}
+impl Readable for Duration {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let secs = Readable::read(r)?;
+		let nanos = Readable::read(r)?;
+		Ok(Duration::new(secs, nanos))
+	}
+}