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

@@ -46,11 +46,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.
 ///
@@ -60,7 +64,7 @@ use core::time::Duration;
 /// See [module-level documentation] for usage.
 ///
 /// [module-level documentation]: crate::routing::scorer
-pub struct Scorer<C: Clock> {
+pub struct Scorer<C: Clock + Sub<Duration, Output = C>> {
 	params: ScoringParameters,
 	channel_failures: HashMap<u64, ChannelFailure<C>>,
 }
@@ -81,10 +85,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,
 
@@ -101,7 +111,7 @@ pub trait Clock {
 	fn elapsed(&self) -> Duration;
 }
 
-impl<C: Clock> Scorer<C> {
+impl<C: Clock + Sub<Duration, Output = C>> Scorer<C> {
 	/// Creates a new scorer using the given scoring parameters.
 	pub fn new(params: ScoringParameters) -> Self {
 		Self {
@@ -121,7 +131,7 @@ impl<C: Clock> Scorer<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,
@@ -143,7 +153,7 @@ impl<C: Clock> ChannelFailure<C> {
 	}
 }
 
-impl<C: Clock> Default for Scorer<C> {
+impl<C: Clock + Sub<Duration, Output = C>> Default for Scorer<C> {
 	fn default() -> Self {
 		Scorer::new(ScoringParameters::default())
 	}
@@ -159,7 +169,7 @@ impl Default for ScoringParameters {
 	}
 }
 
-impl<C: Clock> routing::Score for Scorer<C> {
+impl<C: Clock + Sub<Duration, Output = C>> routing::Score for Scorer<C> {
 	fn channel_penalty_msat(
 		&self, short_channel_id: u64, _source: &NodeId, _target: &NodeId
 	) -> u64 {
@@ -203,3 +213,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 Scorer<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 Scorer<C> {
+	#[inline]
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		Ok(Scorer {
+			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(ChannelFailure {
+			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))
+	}
+}