f Rename PeerInfoStorage to PeerStore

Omit the superfluous `Info`

Author: tnull

src/io/utils.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::WALLET_KEYS_SEED_LEN;
 
-use crate::peer_store::PeerInfoStorage;
+use crate::peer_store::PeerStore;
 use crate::{EventQueue, PaymentDetails};
 
 use lightning::chain::channelmonitor::ChannelMonitor;
@@ -142,17 +142,14 @@ where
 /// Read previously persisted peer info from the store.
 pub(crate) fn read_peer_info<K: Deref, L: Deref>(
 	kv_store: K, logger: L,
-) -> Result<PeerInfoStorage<K, L>, std::io::Error>
+) -> Result<PeerStore<K, L>, std::io::Error>
 where
 	K::Target: KVStore,
 	L::Target: Logger,
 {
 	let mut reader = kv_store.read(PEER_INFO_PERSISTENCE_NAMESPACE, PEER_INFO_PERSISTENCE_KEY)?;
-	let peer_info = PeerInfoStorage::read(&mut reader, (kv_store, logger)).map_err(|_| {
-		std::io::Error::new(
-			std::io::ErrorKind::InvalidData,
-			"Failed to deserialize PeerInfoStorage",
-		)
+	let peer_info = PeerStore::read(&mut reader, (kv_store, logger)).map_err(|_| {
+		std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize PeerStore")
 	})?;
 	Ok(peer_info)
 }

src/lib.rs

@@ -89,7 +89,7 @@ use io::fs_store::FilesystemStore;
 use io::{KVStore, CHANNEL_MANAGER_PERSISTENCE_KEY, CHANNEL_MANAGER_PERSISTENCE_NAMESPACE};
 use payment_store::PaymentStore;
 pub use payment_store::{PaymentDetails, PaymentDirection, PaymentStatus};
-use peer_store::{PeerInfo, PeerInfoStorage};
+use peer_store::{PeerInfo, PeerStore};
 use types::{
 	ChainMonitor, ChannelManager, GossipSync, KeysManager, NetworkGraph, OnionMessenger,
 	PeerManager, Scorer,
@@ -532,7 +532,7 @@ impl Builder {
 			Ok(peer_store) => Arc::new(peer_store),
 			Err(e) => {
 				if e.kind() == std::io::ErrorKind::NotFound {
-					Arc::new(PeerInfoStorage::new(Arc::clone(&kv_store), Arc::clone(&logger)))
+					Arc::new(PeerStore::new(Arc::clone(&kv_store), Arc::clone(&logger)))
 				} else {
 					log_error!(logger, "Failed to read peer store: {}", e.to_string());
 					panic!("Failed to read peer store: {}", e.to_string());
@@ -590,7 +590,7 @@ pub struct Node {
 	kv_store: Arc<FilesystemStore>,
 	logger: Arc<FilesystemLogger>,
 	scorer: Arc<Mutex<Scorer>>,
-	peer_store: Arc<PeerInfoStorage<Arc<FilesystemStore>, Arc<FilesystemLogger>>>,
+	peer_store: Arc<PeerStore<Arc<FilesystemStore>, Arc<FilesystemLogger>>>,
 	payment_store: Arc<PaymentStore<Arc<FilesystemStore>, Arc<FilesystemLogger>>>,
 }
 

src/peer_store.rs

@@ -13,7 +13,7 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
 use std::ops::Deref;
 use std::sync::RwLock;
 
-pub struct PeerInfoStorage<K: Deref, L: Deref>
+pub struct PeerStore<K: Deref, L: Deref>
 where
 	K::Target: KVStore,
 	L::Target: Logger,
@@ -23,7 +23,7 @@ where
 	logger: L,
 }
 
-impl<K: Deref, L: Deref> PeerInfoStorage<K, L>
+impl<K: Deref, L: Deref> PeerStore<K, L>
 where
 	K::Target: KVStore,
 	L::Target: Logger,
@@ -71,7 +71,7 @@ where
 				);
 				Error::PersistenceFailed
 			})?;
-		PeerInfoStorageSerWrapper(&*locked_peers).write(&mut writer).map_err(|e| {
+		PeerStoreSerWrapper(&*locked_peers).write(&mut writer).map_err(|e| {
 			log_error!(
 				self.logger,
 				"Writing peer data to key {}/{} failed due to: {}",
@@ -95,7 +95,7 @@ where
 	}
 }
 
-impl<K: Deref, L: Deref> ReadableArgs<(K, L)> for PeerInfoStorage<K, L>
+impl<K: Deref, L: Deref> ReadableArgs<(K, L)> for PeerStore<K, L>
 where
 	K::Target: KVStore,
 	L::Target: Logger,
@@ -105,16 +105,16 @@ where
 		reader: &mut R, args: (K, L),
 	) -> Result<Self, lightning::ln::msgs::DecodeError> {
 		let (kv_store, logger) = args;
-		let read_peers: PeerInfoStorageDeserWrapper = Readable::read(reader)?;
+		let read_peers: PeerStoreDeserWrapper = Readable::read(reader)?;
 		let peers: RwLock<HashMap<PublicKey, PeerInfo>> = RwLock::new(read_peers.0);
 		Ok(Self { peers, kv_store, logger })
 	}
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct PeerInfoStorageDeserWrapper(HashMap<PublicKey, PeerInfo>);
+pub(crate) struct PeerStoreDeserWrapper(HashMap<PublicKey, PeerInfo>);
 
-impl Readable for PeerInfoStorageDeserWrapper {
+impl Readable for PeerStoreDeserWrapper {
 	fn read<R: lightning::io::Read>(
 		reader: &mut R,
 	) -> Result<Self, lightning::ln::msgs::DecodeError> {
@@ -129,9 +129,9 @@ impl Readable for PeerInfoStorageDeserWrapper {
 	}
 }
 
-pub(crate) struct PeerInfoStorageSerWrapper<'a>(&'a HashMap<PublicKey, PeerInfo>);
+pub(crate) struct PeerStoreSerWrapper<'a>(&'a HashMap<PublicKey, PeerInfo>);
 
-impl Writeable for PeerInfoStorageSerWrapper<'_> {
+impl Writeable for PeerStoreSerWrapper<'_> {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
 		(self.0.len() as u16).write(writer)?;
 		for (k, v) in self.0.iter() {
@@ -224,7 +224,7 @@ mod tests {
 	fn peer_info_persistence() {
 		let store = Arc::new(TestStore::new());
 		let logger = Arc::new(TestLogger::new());
-		let peer_store = PeerInfoStorage::new(Arc::clone(&store), Arc::clone(&logger));
+		let peer_store = PeerStore::new(Arc::clone(&store), Arc::clone(&logger));
 
 		let pubkey = PublicKey::from_str(
 			"0276607124ebe6a6c9338517b6f485825b27c2dcc0b9fc2aa6a4c0df91194e5993",
@@ -240,7 +240,7 @@ mod tests {
 			.get_persisted_bytes(PEER_INFO_PERSISTENCE_NAMESPACE, PEER_INFO_PERSISTENCE_KEY)
 			.unwrap();
 		let deser_peer_store =
-			PeerInfoStorage::read(&mut &persisted_bytes[..], (Arc::clone(&store), logger)).unwrap();
+			PeerStore::read(&mut &persisted_bytes[..], (Arc::clone(&store), logger)).unwrap();
 
 		let peers = deser_peer_store.list_peers();
 		assert_eq!(peers.len(), 1);