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 DefaultTime = Eternity;
 /// [`routing::Score`] implementation parameterized by [`Time`].
 ///
 /// See [`Scorer`] for details.
-pub struct ScorerUsingTime<T: Time> {
+pub struct ScorerUsingTime<T: Time + Sub<Duration, Output = T>> {
 	params: ScoringParameters,
 	// TODO: Remove entries of closed channels.
 	channel_failures: HashMap<u64, ChannelFailure<T>>,
@@ -103,10 +107,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 accumulate as more failures occur.
-struct ChannelFailure<T: Time> {
+struct ChannelFailure<T: Time + Sub<Duration, Output = T>> {
 	/// Accumulated penalty in msats for the channel as of `last_failed`.
 	undecayed_penalty_msat: u64,
 
@@ -123,7 +133,7 @@ pub trait Time {
 	fn elapsed(&self) -> Duration;
 }
 
-impl<T: Time> ScorerUsingTime<T> {
+impl<T: Time + Sub<Duration, Output = T>> ScorerUsingTime<T> {
 	/// Creates a new scorer using the given scoring parameters.
 	pub fn new(params: ScoringParameters) -> Self {
 		Self {
@@ -143,7 +153,7 @@ impl<T: Time> ScorerUsingTime<T> {
 	}
 }
 
-impl<T: Time> ChannelFailure<T> {
+impl<T: Time + Sub<Duration, Output = T>> ChannelFailure<T> {
 	fn new(failure_penalty_msat: u64) -> Self {
 		Self {
 			undecayed_penalty_msat: failure_penalty_msat,
@@ -165,7 +175,7 @@ impl<T: Time> ChannelFailure<T> {
 	}
 }
 
-impl<T: Time> Default for ScorerUsingTime<T> {
+impl<T: Time + Sub<Duration, Output = T>> Default for ScorerUsingTime<T> {
 	fn default() -> Self {
 		Self::new(ScoringParameters::default())
 	}
@@ -181,7 +191,7 @@ impl Default for ScoringParameters {
 	}
 }
 
-impl<T: Time> routing::Score for ScorerUsingTime<T> {
+impl<T: Time + Sub<Duration, Output = T>> routing::Score for ScorerUsingTime<T> {
 	fn channel_penalty_msat(
 		&self, short_channel_id: u64, _source: &NodeId, _target: &NodeId
 	) -> u64 {
@@ -225,3 +235,57 @@ impl Time for Eternity {
 		Duration::from_secs(0)
 	}
 }
+
+impl Sub<Duration> for Eternity {
+	type Output = Self;
+
+	fn sub(self, _other: Duration) -> Self {
+		self
+	}
+}
+
+impl<T: Time + Sub<Duration, Output = T>> 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)
+	}
+}
+
+impl<T: Time + Sub<Duration, Output = T>> Readable for ScorerUsingTime<T> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		Ok(Self {
+			params: Readable::read(r)?,
+			channel_failures: Readable::read(r)?,
+		})
+	}
+}
+
+impl<T: Time + Sub<Duration, Output = T>> Writeable for ChannelFailure<T> {
+	#[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<T: Time + Sub<Duration, Output = T>> Readable for ChannelFailure<T> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		Ok(Self {
+			undecayed_penalty_msat: Readable::read(r)?,
+			last_failed: T::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))
+	}
+}