add another lock to lockable_score

Author: jbesraa

lightning-background-processor/src/lib.rs

@@ -233,7 +233,7 @@ fn handle_network_graph_update<L: Deref>(
 fn update_scorer<'a, S: 'static + Deref<Target = SC> + Send + Sync, SC: 'a + WriteableScore<'a>>(
 	scorer: &'a S, event: &Event
 ) {
-	let mut score = scorer.lock();
+	let mut score = scorer.score_lock();
 	match event {
 		Event::PaymentPathFailed { ref path, short_channel_id: Some(scid), .. } => {
 			let path = path.iter().collect::<Vec<_>>();

lightning/src/routing/router.rs

@@ -68,7 +68,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 
 		find_route(
 			payer, params, &self.network_graph, first_hops, &*self.logger,
-			&ScorerAccountingForInFlightHtlcs::new(self.scorer.lock(), inflight_htlcs),
+			&ScorerAccountingForInFlightHtlcs::new(self.scorer.score_lock(), inflight_htlcs),
 			&random_seed_bytes
 		)
 	}

lightning/src/routing/scoring.rs

@@ -151,10 +151,16 @@ define_score!();
 /// [`find_route`]: crate::routing::router::find_route
 pub trait LockableScore<'a> {
 	/// The locked [`Score`] type.
-	type Locked: 'a + Score;
+	type WriteLocked: 'a + Score;
+
+	/// The locked [`Score`] type.
+	type ScoreLocked: 'a + Score;
 
 	/// Returns the locked scorer.
-	fn lock(&'a self) -> Self::Locked;
+	fn write_lock(&'a self) -> Self::WriteLocked;
+
+	/// Returns the locked scorer.
+	fn score_lock(&'a self) -> Self::ScoreLocked;
 }
 
 /// Refers to a scorer that is accessible under lock and also writeable to disk
@@ -167,17 +173,27 @@ pub trait WriteableScore<'a>: LockableScore<'a> + Writeable {}
 impl<'a, T> WriteableScore<'a> for T where T: LockableScore<'a> + Writeable {}
 /// This is not exported to bindings users
 impl<'a, T: 'a + Score> LockableScore<'a> for Mutex<T> {
-	type Locked = MutexGuard<'a, T>;
+	type WriteLocked = MutexGuard<'a, T>;
+	type ScoreLocked = MutexGuard<'a, T>;
+
+	fn write_lock(&'a self) -> MutexGuard<'a, T> {
+		Mutex::lock(self).unwrap()
+	}
 
-	fn lock(&'a self) -> MutexGuard<'a, T> {
+	fn score_lock(&'a self) -> MutexGuard<'a, T> {
 		Mutex::lock(self).unwrap()
 	}
 }
 
 impl<'a, T: 'a + Score> LockableScore<'a> for RefCell<T> {
-	type Locked = RefMut<'a, T>;
+	type ScoreLocked = RefMut<'a, T>;
+	type WriteLocked = RefMut<'a, T>;
+
+	fn write_lock(&'a self) -> RefMut<'a, T> {
+		self.borrow_mut()
+	}
 
-	fn lock(&'a self) -> RefMut<'a, T> {
+	fn score_lock(&'a self) -> RefMut<'a, T> {
 		self.borrow_mut()
 	}
 }