Skip to content

Commit 070810b

Browse files
tnulltnull
committed
Drop unnecessary uses of io::Cursor 
1 parent 2dc569e commit 070810b

5 files changed

Lines changed: 77 additions & 106 deletions

File tree

‎src/builder.rs‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,6 @@ use bitcoin::key::Secp256k1;
2020
use bitcoin::secp256k1::PublicKey;
2121
use bitcoin::{BlockHash, Network};
2222
use lightning::chain::{chainmonitor, BestBlock, Watch};
23-
use lightning::io::Cursor;
2423
use lightning::ln::channelmanager::{self, ChainParameters, ChannelManagerReadArgs};
2524
use lightning::ln::msgs::{RoutingMessageHandler, SocketAddress};
2625
use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler};
@@ -1385,13 +1384,12 @@ fn build_with_store_internal(
13851384

13861385
// Initialize the ChannelManager
13871386
let channel_manager = {
1388-
if let Ok(res) = KVStoreSync::read(
1387+
if let Ok(reader) = KVStoreSync::read(
13891388
&*kv_store,
13901389
CHANNEL_MANAGER_PERSISTENCE_PRIMARY_NAMESPACE,
13911390
CHANNEL_MANAGER_PERSISTENCE_SECONDARY_NAMESPACE,
13921391
CHANNEL_MANAGER_PERSISTENCE_KEY,
13931392
) {
1394-
let mut reader = Cursor::new(res);
13951393
let channel_monitor_references =
13961394
channel_monitors.iter().map(|(_, chanmon)| chanmon).collect();
13971395
let read_args = ChannelManagerReadArgs::new(
@@ -1408,7 +1406,7 @@ fn build_with_store_internal(
14081406
channel_monitor_references,
14091407
);
14101408
let (_hash, channel_manager) =
1411-
<(BlockHash, ChannelManager)>::read(&mut reader, read_args).map_err(|e| {
1409+
<(BlockHash, ChannelManager)>::read(&mut &*reader, read_args).map_err(|e| {
14121410
log_error!(logger, "Failed to read channel manager from store: {}", e);
14131411
BuildError::ReadFailed
14141412
})?;

‎src/io/utils.rs‎

Lines changed: 60 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,6 @@ use bdk_chain::tx_graph::ChangeSet as BdkTxGraphChangeSet;
1818
use bdk_chain::ConfirmationBlockTime;
1919
use bdk_wallet::ChangeSet as BdkWalletChangeSet;
2020
use bitcoin::Network;
21-
use lightning::io::Cursor;
2221
use lightning::ln::msgs::DecodeError;
2322
use lightning::routing::gossip::NetworkGraph;
2423
use lightning::routing::scoring::{
@@ -94,16 +93,14 @@ pub(crate) async fn read_network_graph<L: Deref + Clone>(
9493
where
9594
L::Target: LdkLogger,
9695
{
97-
let mut reader = Cursor::new(
98-
KVStore::read(
99-
&*kv_store,
100-
NETWORK_GRAPH_PERSISTENCE_PRIMARY_NAMESPACE,
101-
NETWORK_GRAPH_PERSISTENCE_SECONDARY_NAMESPACE,
102-
NETWORK_GRAPH_PERSISTENCE_KEY,
103-
)
104-
.await?,
105-
);
106-
NetworkGraph::read(&mut reader, logger.clone()).map_err(|e| {
96+
let reader = KVStore::read(
97+
&*kv_store,
98+
NETWORK_GRAPH_PERSISTENCE_PRIMARY_NAMESPACE,
99+
NETWORK_GRAPH_PERSISTENCE_SECONDARY_NAMESPACE,
100+
NETWORK_GRAPH_PERSISTENCE_KEY,
101+
)
102+
.await?;
103+
NetworkGraph::read(&mut &*reader, logger.clone()).map_err(|e| {
107104
log_error!(logger, "Failed to deserialize NetworkGraph: {}", e);
108105
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize NetworkGraph")
109106
})
@@ -117,17 +114,15 @@ where
117114
L::Target: LdkLogger,
118115
{
119116
let params = ProbabilisticScoringDecayParameters::default();
120-
let mut reader = Cursor::new(
121-
KVStore::read(
122-
&*kv_store,
123-
SCORER_PERSISTENCE_PRIMARY_NAMESPACE,
124-
SCORER_PERSISTENCE_SECONDARY_NAMESPACE,
125-
SCORER_PERSISTENCE_KEY,
126-
)
127-
.await?,
128-
);
117+
let reader = KVStore::read(
118+
&*kv_store,
119+
SCORER_PERSISTENCE_PRIMARY_NAMESPACE,
120+
SCORER_PERSISTENCE_SECONDARY_NAMESPACE,
121+
SCORER_PERSISTENCE_KEY,
122+
)
123+
.await?;
129124
let args = (params, network_graph, logger.clone());
130-
ProbabilisticScorer::read(&mut reader, args).map_err(|e| {
125+
ProbabilisticScorer::read(&mut &*reader, args).map_err(|e| {
131126
log_error!(logger, "Failed to deserialize scorer: {}", e);
132127
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize Scorer")
133128
})
@@ -140,16 +135,14 @@ pub(crate) async fn read_external_pathfinding_scores_from_cache<L: Deref>(
140135
where
141136
L::Target: LdkLogger,
142137
{
143-
let mut reader = Cursor::new(
144-
KVStore::read(
145-
&*kv_store,
146-
SCORER_PERSISTENCE_PRIMARY_NAMESPACE,
147-
SCORER_PERSISTENCE_SECONDARY_NAMESPACE,
148-
EXTERNAL_PATHFINDING_SCORES_CACHE_KEY,
149-
)
150-
.await?,
151-
);
152-
ChannelLiquidities::read(&mut reader).map_err(|e| {
138+
let reader = KVStore::read(
139+
&*kv_store,
140+
SCORER_PERSISTENCE_PRIMARY_NAMESPACE,
141+
SCORER_PERSISTENCE_SECONDARY_NAMESPACE,
142+
EXTERNAL_PATHFINDING_SCORES_CACHE_KEY,
143+
)
144+
.await?;
145+
ChannelLiquidities::read(&mut &*reader).map_err(|e| {
153146
log_error!(logger, "Failed to deserialize scorer: {}", e);
154147
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize Scorer")
155148
})
@@ -190,16 +183,14 @@ pub(crate) async fn read_event_queue<L: Deref + Clone>(
190183
where
191184
L::Target: LdkLogger,
192185
{
193-
let mut reader = Cursor::new(
194-
KVStore::read(
195-
&*kv_store,
196-
EVENT_QUEUE_PERSISTENCE_PRIMARY_NAMESPACE,
197-
EVENT_QUEUE_PERSISTENCE_SECONDARY_NAMESPACE,
198-
EVENT_QUEUE_PERSISTENCE_KEY,
199-
)
200-
.await?,
201-
);
202-
EventQueue::read(&mut reader, (kv_store, logger.clone())).map_err(|e| {
186+
let reader = KVStore::read(
187+
&*kv_store,
188+
EVENT_QUEUE_PERSISTENCE_PRIMARY_NAMESPACE,
189+
EVENT_QUEUE_PERSISTENCE_SECONDARY_NAMESPACE,
190+
EVENT_QUEUE_PERSISTENCE_KEY,
191+
)
192+
.await?;
193+
EventQueue::read(&mut &*reader, (kv_store, logger.clone())).map_err(|e| {
203194
log_error!(logger, "Failed to deserialize event queue: {}", e);
204195
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize EventQueue")
205196
})
@@ -212,16 +203,14 @@ pub(crate) async fn read_peer_info<L: Deref + Clone>(
212203
where
213204
L::Target: LdkLogger,
214205
{
215-
let mut reader = Cursor::new(
216-
KVStore::read(
217-
&*kv_store,
218-
PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
219-
PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
220-
PEER_INFO_PERSISTENCE_KEY,
221-
)
222-
.await?,
223-
);
224-
PeerStore::read(&mut reader, (kv_store, logger.clone())).map_err(|e| {
206+
let reader = KVStore::read(
207+
&*kv_store,
208+
PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
209+
PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
210+
PEER_INFO_PERSISTENCE_KEY,
211+
)
212+
.await?;
213+
PeerStore::read(&mut &*reader, (kv_store, logger.clone())).map_err(|e| {
225214
log_error!(logger, "Failed to deserialize peer store: {}", e);
226215
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize PeerStore")
227216
})
@@ -263,7 +252,7 @@ where
263252

264253
while let Some(read_res) = set.join_next().await {
265254
// Exit early if we get an IO error.
266-
let read_res = read_res??;
255+
let reader = read_res??;
267256

268257
// Refill set for every finished future, if we still have something to do.
269258
if let Some(next_key) = stored_keys.pop() {
@@ -278,8 +267,7 @@ where
278267
}
279268

280269
// Handle result.
281-
let mut reader = Cursor::new(read_res);
282-
let payment = PaymentDetails::read(&mut reader).map_err(|e| {
270+
let payment = PaymentDetails::read(&mut &*reader).map_err(|e| {
283271
log_error!(logger, "Failed to deserialize PaymentDetails: {}", e);
284272
std::io::Error::new(
285273
std::io::ErrorKind::InvalidData,
@@ -301,15 +289,13 @@ pub(crate) async fn read_output_sweeper(
301289
chain_data_source: Arc<ChainSource>, keys_manager: Arc<KeysManager>, kv_store: Arc<DynStore>,
302290
logger: Arc<Logger>,
303291
) -> Result<Sweeper, std::io::Error> {
304-
let mut reader = Cursor::new(
305-
KVStore::read(
306-
&*kv_store,
307-
OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE,
308-
OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE,
309-
OUTPUT_SWEEPER_PERSISTENCE_KEY,
310-
)
311-
.await?,
312-
);
292+
let reader = KVStore::read(
293+
&*kv_store,
294+
OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE,
295+
OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE,
296+
OUTPUT_SWEEPER_PERSISTENCE_KEY,
297+
)
298+
.await?;
313299
let args = (
314300
broadcaster,
315301
fee_estimator,
@@ -319,7 +305,7 @@ pub(crate) async fn read_output_sweeper(
319305
kv_store,
320306
logger.clone(),
321307
);
322-
let (_, sweeper) = <(_, Sweeper)>::read(&mut reader, args).map_err(|e| {
308+
let (_, sweeper) = <(_, Sweeper)>::read(&mut &*reader, args).map_err(|e| {
323309
log_error!(logger, "Failed to deserialize OutputSweeper: {}", e);
324310
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize OutputSweeper")
325311
})?;
@@ -332,16 +318,14 @@ pub(crate) async fn read_node_metrics<L: Deref>(
332318
where
333319
L::Target: LdkLogger,
334320
{
335-
let mut reader = Cursor::new(
336-
KVStore::read(
337-
&*kv_store,
338-
NODE_METRICS_PRIMARY_NAMESPACE,
339-
NODE_METRICS_SECONDARY_NAMESPACE,
340-
NODE_METRICS_KEY,
341-
)
342-
.await?,
343-
);
344-
NodeMetrics::read(&mut reader).map_err(|e| {
321+
let reader = KVStore::read(
322+
&*kv_store,
323+
NODE_METRICS_PRIMARY_NAMESPACE,
324+
NODE_METRICS_SECONDARY_NAMESPACE,
325+
NODE_METRICS_KEY,
326+
)
327+
.await?;
328+
NodeMetrics::read(&mut &*reader).map_err(|e| {
345329
log_error!(logger, "Failed to deserialize NodeMetrics: {}", e);
346330
std::io::Error::new(std::io::ErrorKind::InvalidData, "Failed to deserialize NodeMetrics")
347331
})
@@ -480,7 +464,7 @@ macro_rules! impl_read_write_change_set_type {
480464
where
481465
L::Target: LdkLogger,
482466
{
483-
let bytes =
467+
let reader =
484468
match KVStoreSync::read(&*kv_store, $primary_namespace, $secondary_namespace, $key)
485469
{
486470
Ok(bytes) => bytes,
@@ -501,9 +485,8 @@ macro_rules! impl_read_write_change_set_type {
501485
},
502486
};
503487

504-
let mut reader = Cursor::new(bytes);
505488
let res: Result<ChangeSetDeserWrapper<$change_set_type>, DecodeError> =
506-
Readable::read(&mut reader);
489+
Readable::read(&mut &*reader);
507490
match res {
508491
Ok(res) => Ok(Some(res.0)),
509492
Err(e) => {

‎src/io/vss_store.rs‎

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -745,11 +745,10 @@ async fn determine_and_write_schema_version(
745745
})?
746746
.0;
747747

748-
let schema_version: VssSchemaVersion = Readable::read(&mut io::Cursor::new(decrypted))
749-
.map_err(|e| {
750-
let msg = format!("Failed to decode schema version: {}", e);
751-
Error::new(ErrorKind::Other, msg)
752-
})?;
748+
let schema_version: VssSchemaVersion = Readable::read(&mut &*decrypted).map_err(|e| {
749+
let msg = format!("Failed to decode schema version: {}", e);
750+
Error::new(ErrorKind::Other, msg)
751+
})?;
753752
Ok(schema_version)
754753
} else {
755754
// The schema version wasn't present, this either means we're running for the first time *or* it's V0 pre-migration (predating writing of the schema version).

‎src/payment/store.rs‎

Lines changed: 9 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -605,7 +605,6 @@ impl StorableObjectUpdate<PaymentDetails> for PaymentDetailsUpdate {
605605

606606
#[cfg(test)]
607607
mod tests {
608-
use bitcoin::io::Cursor;
609608
use lightning::util::ser::Readable;
610609

611610
use super::*;
@@ -657,16 +656,12 @@ mod tests {
657656
let old_bolt11_encoded = old_bolt11_payment.encode();
658657
assert_eq!(
659658
old_bolt11_payment,
660-
OldPaymentDetails::read(&mut Cursor::new(old_bolt11_encoded.clone())).unwrap()
659+
OldPaymentDetails::read(&mut &*old_bolt11_encoded.clone()).unwrap()
661660
);
662661

663-
let bolt11_decoded =
664-
PaymentDetails::read(&mut Cursor::new(old_bolt11_encoded)).unwrap();
662+
let bolt11_decoded = PaymentDetails::read(&mut &*old_bolt11_encoded).unwrap();
665663
let bolt11_reencoded = bolt11_decoded.encode();
666-
assert_eq!(
667-
bolt11_decoded,
668-
PaymentDetails::read(&mut Cursor::new(bolt11_reencoded)).unwrap()
669-
);
664+
assert_eq!(bolt11_decoded, PaymentDetails::read(&mut &*bolt11_reencoded).unwrap());
670665

671666
match bolt11_decoded.kind {
672667
PaymentKind::Bolt11 { hash: h, preimage: p, secret: s } => {
@@ -700,15 +695,14 @@ mod tests {
700695
let old_bolt11_jit_encoded = old_bolt11_jit_payment.encode();
701696
assert_eq!(
702697
old_bolt11_jit_payment,
703-
OldPaymentDetails::read(&mut Cursor::new(old_bolt11_jit_encoded.clone())).unwrap()
698+
OldPaymentDetails::read(&mut &*old_bolt11_jit_encoded.clone()).unwrap()
704699
);
705700

706-
let bolt11_jit_decoded =
707-
PaymentDetails::read(&mut Cursor::new(old_bolt11_jit_encoded)).unwrap();
701+
let bolt11_jit_decoded = PaymentDetails::read(&mut &*old_bolt11_jit_encoded).unwrap();
708702
let bolt11_jit_reencoded = bolt11_jit_decoded.encode();
709703
assert_eq!(
710704
bolt11_jit_decoded,
711-
PaymentDetails::read(&mut Cursor::new(bolt11_jit_reencoded)).unwrap()
705+
PaymentDetails::read(&mut &*bolt11_jit_reencoded).unwrap()
712706
);
713707

714708
match bolt11_jit_decoded.kind {
@@ -746,15 +740,14 @@ mod tests {
746740
let old_spontaneous_encoded = old_spontaneous_payment.encode();
747741
assert_eq!(
748742
old_spontaneous_payment,
749-
OldPaymentDetails::read(&mut Cursor::new(old_spontaneous_encoded.clone())).unwrap()
743+
OldPaymentDetails::read(&mut &*old_spontaneous_encoded.clone()).unwrap()
750744
);
751745

752-
let spontaneous_decoded =
753-
PaymentDetails::read(&mut Cursor::new(old_spontaneous_encoded)).unwrap();
746+
let spontaneous_decoded = PaymentDetails::read(&mut &*old_spontaneous_encoded).unwrap();
754747
let spontaneous_reencoded = spontaneous_decoded.encode();
755748
assert_eq!(
756749
spontaneous_decoded,
757-
PaymentDetails::read(&mut Cursor::new(spontaneous_reencoded)).unwrap()
750+
PaymentDetails::read(&mut &*spontaneous_reencoded).unwrap()
758751
);
759752

760753
match spontaneous_decoded.kind {

‎src/scoring.rs‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
use std::io::Cursor;
21
use std::sync::{Arc, Mutex, RwLock};
32
use std::time::{Duration, SystemTime};
43

@@ -74,15 +73,14 @@ async fn sync_external_scores(
7473
return;
7574
},
7675
};
77-
let body = match response.bytes().await {
76+
let reader = match response.bytes().await {
7877
Ok(bytes) => bytes,
7978
Err(e) => {
8079
log_error!(logger, "Failed to read external scores update: {}", e);
8180
return;
8281
},
8382
};
84-
let mut reader = Cursor::new(body);
85-
match ChannelLiquidities::read(&mut reader) {
83+
match ChannelLiquidities::read(&mut &*reader) {
8684
Ok(liquidities) => {
8785
if let Err(e) = write_external_pathfinding_scores_to_cache(
8886
Arc::clone(&kv_store),

0 commit comments

Comments
 (0)