Skip to content

Commit 5d20ab8

Browse files
tnulltnull
committed
Improve logging for de/ser failures and start/stop 
1 parent 461b8c4 commit 5d20ab8

File tree

2 files changed

+62
-34
lines changed

2 files changed

+62
-34
lines changed

‎src/io/utils.rs‎

Lines changed: 36 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,7 @@ where
9292
}
9393

9494
/// Read a previously persisted [`NetworkGraph`] from the store.
95-
pub(crate) fn read_network_graph<K: Deref, L: Deref>(
95+
pub(crate) fn read_network_graph<K: Deref, L: Deref + Clone>(
9696
kv_store: K, logger: L,
9797
) -> Result<NetworkGraph<L>, std::io::Error>
9898
where
@@ -101,14 +101,15 @@ where
101101
{
102102
let mut reader =
103103
kv_store.read(NETWORK_GRAPH_PERSISTENCE_NAMESPACE, NETWORK_GRAPH_PERSISTENCE_KEY)?;
104-
let graph = NetworkGraph::read(&mut reader, logger).map_err(|_| {
105-
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize NetworkGraph")
104+
let graph = NetworkGraph::read(&mut reader, logger.clone()).map_err(|e| {
105+
log_error!(logger, "Failed to deserialize network graph: {}", e);
106+
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize network graph")
106107
})?;
107108
Ok(graph)
108109
}
109110

110111
/// Read a previously persisted [`Scorer`] from the store.
111-
pub(crate) fn read_scorer<K: Deref, G: Deref<Target = NetworkGraph<L>>, L: Deref>(
112+
pub(crate) fn read_scorer<K: Deref, G: Deref<Target = NetworkGraph<L>>, L: Deref + Clone>(
112113
kv_store: K, network_graph: G, logger: L,
113114
) -> Result<ProbabilisticScorer<G, L>, std::io::Error>
114115
where
@@ -117,15 +118,16 @@ where
117118
{
118119
let params = ProbabilisticScoringParameters::default();
119120
let mut reader = kv_store.read(SCORER_PERSISTENCE_NAMESPACE, SCORER_PERSISTENCE_KEY)?;
120-
let args = (params, network_graph, logger);
121-
let scorer = ProbabilisticScorer::read(&mut reader, args).map_err(|_| {
121+
let args = (params, network_graph, logger.clone());
122+
let scorer = ProbabilisticScorer::read(&mut reader, args).map_err(|e| {
123+
log_error!(logger, "Failed to deserialize scorer: {}", e);
122124
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize Scorer")
123125
})?;
124126
Ok(scorer)
125127
}
126128

127129
/// Read previously persisted events from the store.
128-
pub(crate) fn read_event_queue<K: Deref, L: Deref>(
130+
pub(crate) fn read_event_queue<K: Deref, L: Deref + Clone>(
129131
kv_store: K, logger: L,
130132
) -> Result<EventQueue<K, L>, std::io::Error>
131133
where
@@ -134,53 +136,63 @@ where
134136
{
135137
let mut reader =
136138
kv_store.read(EVENT_QUEUE_PERSISTENCE_NAMESPACE, EVENT_QUEUE_PERSISTENCE_KEY)?;
137-
let event_queue = EventQueue::read(&mut reader, (kv_store, logger)).map_err(|_| {
139+
let event_queue = EventQueue::read(&mut reader, (kv_store, logger.clone())).map_err(|e| {
140+
log_error!(logger, "Failed to deserialize event queue: {}", e);
138141
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize EventQueue")
139142
})?;
140143
Ok(event_queue)
141144
}
142145

143146
/// Read previously persisted peer info from the store.
144-
pub(crate) fn read_peer_info<K: Deref, L: Deref>(
147+
pub(crate) fn read_peer_info<K: Deref, L: Deref + Clone>(
145148
kv_store: K, logger: L,
146149
) -> Result<PeerStore<K, L>, std::io::Error>
147150
where
148151
K::Target: KVStore,
149152
L::Target: Logger,
150153
{
151154
let mut reader = kv_store.read(PEER_INFO_PERSISTENCE_NAMESPACE, PEER_INFO_PERSISTENCE_KEY)?;
152-
let peer_info = PeerStore::read(&mut reader, (kv_store, logger)).map_err(|_| {
155+
let peer_info = PeerStore::read(&mut reader, (kv_store, logger.clone())).map_err(|e| {
156+
log_error!(logger, "Failed to deserialize peer store: {}", e);
153157
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize PeerStore")
154158
})?;
155159
Ok(peer_info)
156160
}
157161

158162
/// Read previously persisted payments information from the store.
159-
pub(crate) fn read_payments<K: Deref>(kv_store: K) -> Result<Vec<PaymentDetails>, std::io::Error>
163+
pub(crate) fn read_payments<K: Deref, L: Deref>(
164+
kv_store: K, logger: L,
165+
) -> Result<Vec<PaymentDetails>, std::io::Error>
160166
where
161167
K::Target: KVStore,
168+
L::Target: Logger,
162169
{
163170
let mut res = Vec::new();
164171

165172
for stored_key in kv_store.list(PAYMENT_INFO_PERSISTENCE_NAMESPACE)? {
166173
let payment = PaymentDetails::read(
167174
&mut kv_store.read(PAYMENT_INFO_PERSISTENCE_NAMESPACE, &stored_key)?,
168175
)
169-
.map_err(|_| {
176+
.map_err(|e| {
177+
log_error!(logger, "Failed to deserialize Payment: {}", e);
170178
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize Payment")
171179
})?;
172180
res.push(payment);
173181
}
174182
Ok(res)
175183
}
176184

177-
pub(crate) fn read_latest_rgs_sync_timestamp<K: Deref>(kv_store: K) -> Result<u32, std::io::Error>
185+
pub(crate) fn read_latest_rgs_sync_timestamp<K: Deref, L: Deref>(
186+
kv_store: K, logger: L,
187+
) -> Result<u32, std::io::Error>
178188
where
179189
K::Target: KVStore,
190+
L::Target: Logger,
180191
{
181192
let mut reader =
182193
kv_store.read(LATEST_RGS_SYNC_TIMESTAMP_NAMESPACE, LATEST_RGS_SYNC_TIMESTAMP_KEY)?;
183-
u32::read(&mut reader).map_err(|_| {
194+
u32::read(&mut reader).map_err(|e| {
195+
log_error!(logger, "Failed to deserialize latest RGS sync timestamp: {}", e);
184196
std::io::Error::new(
185197
std::io::ErrorKind::InvalidData,
186198
"Failed to deserialize latest RGS sync timestamp",
@@ -229,18 +241,24 @@ where
229241
})
230242
}
231243

232-
pub(crate) fn read_latest_node_ann_bcast_timestamp<K: Deref>(
233-
kv_store: K,
244+
pub(crate) fn read_latest_node_ann_bcast_timestamp<K: Deref, L: Deref>(
245+
kv_store: K, logger: L,
234246
) -> Result<u64, std::io::Error>
235247
where
236248
K::Target: KVStore,
249+
L::Target: Logger,
237250
{
238251
let mut reader = kv_store
239252
.read(LATEST_NODE_ANN_BCAST_TIMSTAMP_NAMESPACE, LATEST_NODE_ANN_BCAST_TIMSTAMP_KEY)?;
240-
u64::read(&mut reader).map_err(|_| {
253+
u64::read(&mut reader).map_err(|e| {
254+
log_error!(
255+
logger,
256+
"Failed to deserialize latest node announcement broadcast timestamp: {}",
257+
e
258+
);
241259
std::io::Error::new(
242260
std::io::ErrorKind::InvalidData,
243-
"Failed to deserialize latest node announcment broadcast timestamp",
261+
"Failed to deserialize latest node announcement broadcast timestamp",
244262
)
245263
})
246264
}

‎src/lib.rs‎

Lines changed: 26 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -423,7 +423,6 @@ impl Builder {
423423
if e.kind() == std::io::ErrorKind::NotFound {
424424
Arc::new(NetworkGraph::new(config.network, Arc::clone(&logger)))
425425
} else {
426-
log_error!(logger, "Failed to read network graph: {}", e.to_string());
427426
panic!("Failed to read network graph: {}", e.to_string());
428427
}
429428
}
@@ -444,7 +443,6 @@ impl Builder {
444443
Arc::clone(&logger),
445444
)))
446445
} else {
447-
log_error!(logger, "Failed to read scorer: {}", e.to_string());
448446
panic!("Failed to read scorer: {}", e.to_string());
449447
}
450448
}
@@ -562,8 +560,11 @@ impl Builder {
562560
p2p_source
563561
}
564562
GossipSourceConfig::RapidGossipSync(rgs_server) => {
565-
let latest_sync_timestamp =
566-
io::utils::read_latest_rgs_sync_timestamp(Arc::clone(&kv_store)).unwrap_or(0);
563+
let latest_sync_timestamp = io::utils::read_latest_rgs_sync_timestamp(
564+
Arc::clone(&kv_store),
565+
Arc::clone(&logger),
566+
)
567+
.unwrap_or(0);
567568
Arc::new(GossipSource::new_rgs(
568569
rgs_server.clone(),
569570
latest_sync_timestamp,
@@ -601,15 +602,17 @@ impl Builder {
601602
));
602603

603604
// Init payment info storage
604-
let payment_store = match io::utils::read_payments(Arc::clone(&kv_store)) {
605-
Ok(payments) => {
606-
Arc::new(PaymentStore::new(payments, Arc::clone(&kv_store), Arc::clone(&logger)))
607-
}
608-
Err(e) => {
609-
log_error!(logger, "Failed to read payment information: {}", e.to_string());
610-
panic!("Failed to read payment information: {}", e.to_string());
611-
}
612-
};
605+
let payment_store =
606+
match io::utils::read_payments(Arc::clone(&kv_store), Arc::clone(&logger)) {
607+
Ok(payments) => Arc::new(PaymentStore::new(
608+
payments,
609+
Arc::clone(&kv_store),
610+
Arc::clone(&logger),
611+
)),
612+
Err(e) => {
613+
panic!("Failed to read payment information: {}", e.to_string());
614+
}
615+
};
613616

614617
let event_queue =
615618
match io::utils::read_event_queue(Arc::clone(&kv_store), Arc::clone(&logger)) {
@@ -618,7 +621,6 @@ impl Builder {
618621
if e.kind() == std::io::ErrorKind::NotFound {
619622
Arc::new(EventQueue::new(Arc::clone(&kv_store), Arc::clone(&logger)))
620623
} else {
621-
log_error!(logger, "Failed to read event queue: {}", e.to_string());
622624
panic!("Failed to read event queue: {}", e.to_string());
623625
}
624626
}
@@ -631,7 +633,6 @@ impl Builder {
631633
if e.kind() == std::io::ErrorKind::NotFound {
632634
Arc::new(PeerStore::new(Arc::clone(&kv_store), Arc::clone(&logger)))
633635
} else {
634-
log_error!(logger, "Failed to read peer store: {}", e.to_string());
635636
panic!("Failed to read peer store: {}", e.to_string());
636637
}
637638
}
@@ -700,6 +701,8 @@ impl Node {
700701
return Err(Error::AlreadyRunning);
701702
}
702703

704+
log_info!(self.logger, "Starting up LDK Node on network: {}", self.config.network);
705+
703706
let runtime = tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap();
704707

705708
let event_handler = Arc::new(EventHandler::new(
@@ -922,7 +925,7 @@ impl Node {
922925
return;
923926
}
924927
_ = interval.tick() => {
925-
let skip_broadcast = match io::utils::read_latest_node_ann_bcast_timestamp(Arc::clone(&bcast_store)) {
928+
let skip_broadcast = match io::utils::read_latest_node_ann_bcast_timestamp(Arc::clone(&bcast_store), Arc::clone(&bcast_logger)) {
926929
Ok(latest_bcast_time_secs) => {
927930
// Skip if the time hasn't elapsed yet.
928931
let next_bcast_unix_time = SystemTime::UNIX_EPOCH + Duration::from_secs(latest_bcast_time_secs) + NODE_ANN_BCAST_INTERVAL;
@@ -1002,6 +1005,8 @@ impl Node {
10021005
});
10031006

10041007
*runtime_lock = Some(runtime);
1008+
1009+
log_info!(self.logger, "Startup complete.");
10051010
Ok(())
10061011
}
10071012

@@ -1010,6 +1015,9 @@ impl Node {
10101015
/// After this returns most API methods will return [`Error::NotRunning`].
10111016
pub fn stop(&self) -> Result<(), Error> {
10121017
let runtime = self.runtime.write().unwrap().take().ok_or(Error::NotRunning)?;
1018+
1019+
log_info!(self.logger, "Shutting down LDK Node...");
1020+
10131021
// Stop the runtime.
10141022
match self.stop_sender.send(()) {
10151023
Ok(_) => (),
@@ -1027,6 +1035,8 @@ impl Node {
10271035
self.peer_manager.disconnect_all_peers();
10281036

10291037
runtime.shutdown_timeout(Duration::from_secs(10));
1038+
1039+
log_info!(self.logger, "Shutdown complete.");
10301040
Ok(())
10311041
}
10321042

0 commit comments

Comments
 (0)