Skip to content

Commit 9c572a9

Browse files
TheBlueMattTheBlueMatt
authored
Merge pull request #449 from jkczyz/2020-01-remove-borrow-parts
Remove unnecessary borrow_parts() methods
2 parents a252f81 + e58440f commit 9c572a9

File tree

4 files changed

+49
-96
lines changed

4 files changed

+49
-96
lines changed

‎lightning/src/ln/channelmanager.rs‎

Lines changed: 39 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -274,24 +274,6 @@ pub(super) struct ChannelHolder<ChanSigner: ChannelKeys> {
274274
/// for broadcast messages, where ordering isn't as strict).
275275
pub(super) pending_msg_events: Vec<events::MessageSendEvent>,
276276
}
277-
pub(super) struct MutChannelHolder<'a, ChanSigner: ChannelKeys + 'a> {
278-
pub(super) by_id: &'a mut HashMap<[u8; 32], Channel<ChanSigner>>,
279-
pub(super) short_to_id: &'a mut HashMap<u64, [u8; 32]>,
280-
pub(super) forward_htlcs: &'a mut HashMap<u64, Vec<HTLCForwardInfo>>,
281-
pub(super) claimable_htlcs: &'a mut HashMap<PaymentHash, Vec<(u64, HTLCPreviousHopData)>>,
282-
pub(super) pending_msg_events: &'a mut Vec<events::MessageSendEvent>,
283-
}
284-
impl<ChanSigner: ChannelKeys> ChannelHolder<ChanSigner> {
285-
pub(super) fn borrow_parts(&mut self) -> MutChannelHolder<ChanSigner> {
286-
MutChannelHolder {
287-
by_id: &mut self.by_id,
288-
short_to_id: &mut self.short_to_id,
289-
forward_htlcs: &mut self.forward_htlcs,
290-
claimable_htlcs: &mut self.claimable_htlcs,
291-
pending_msg_events: &mut self.pending_msg_events,
292-
}
293-
}
294-
}
295277

296278
#[cfg(not(any(target_pointer_width = "32", target_pointer_width = "64")))]
297279
const ERR: () = "You need at least 32 bit pointers (well, usize, but we'll assume they're the same) for ChannelManager::latest_block_height";
@@ -738,7 +720,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
738720

739721
let (mut failed_htlcs, chan_option) = {
740722
let mut channel_state_lock = self.channel_state.lock().unwrap();
741-
let channel_state = channel_state_lock.borrow_parts();
723+
let channel_state = &mut *channel_state_lock;
742724
match channel_state.by_id.entry(channel_id.clone()) {
743725
hash_map::Entry::Occupied(mut chan_entry) => {
744726
let (shutdown_msg, failed_htlcs) = chan_entry.get_mut().get_shutdown()?;
@@ -795,7 +777,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
795777

796778
let mut chan = {
797779
let mut channel_state_lock = self.channel_state.lock().unwrap();
798-
let channel_state = channel_state_lock.borrow_parts();
780+
let channel_state = &mut *channel_state_lock;
799781
if let Some(chan) = channel_state.by_id.remove(channel_id) {
800782
if let Some(short_id) = chan.get_short_channel_id() {
801783
channel_state.short_to_id.remove(&short_id);
@@ -1127,7 +1109,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
11271109
Some(id) => id.clone(),
11281110
};
11291111

1130-
let channel_state = channel_lock.borrow_parts();
1112+
let channel_state = &mut *channel_lock;
11311113
if let hash_map::Entry::Occupied(mut chan) = channel_state.by_id.entry(id) {
11321114
match {
11331115
if chan.get().get_their_node_id() != route.hops.first().unwrap().pubkey {
@@ -1275,7 +1257,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
12751257
let mut handle_errors = Vec::new();
12761258
{
12771259
let mut channel_state_lock = self.channel_state.lock().unwrap();
1278-
let channel_state = channel_state_lock.borrow_parts();
1260+
let channel_state = &mut *channel_state_lock;
12791261

12801262
for (short_chan_id, mut pending_forwards) in channel_state.forward_htlcs.drain() {
12811263
if short_chan_id != 0 {
@@ -1473,8 +1455,8 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
14731455
pub fn timer_chan_freshness_every_min(&self) {
14741456
let _ = self.total_consistency_lock.read().unwrap();
14751457
let mut channel_state_lock = self.channel_state.lock().unwrap();
1476-
let channel_state = channel_state_lock.borrow_parts();
1477-
for (_, chan) in channel_state.by_id {
1458+
let channel_state = &mut *channel_state_lock;
1459+
for (_, chan) in channel_state.by_id.iter_mut() {
14781460
if chan.is_disabled_staged() && !chan.is_live() {
14791461
if let Ok(update) = self.get_channel_update(&chan) {
14801462
channel_state.pending_msg_events.push(events::MessageSendEvent::BroadcastChannelUpdate {
@@ -1657,7 +1639,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
16571639
},
16581640
HTLCSource::PreviousHopData(HTLCPreviousHopData { short_channel_id, htlc_id, .. }) => {
16591641
//TODO: Delay the claimed_funds relaying just like we do outbound relay!
1660-
let channel_state = channel_state_lock.borrow_parts();
1642+
let channel_state = &mut *channel_state_lock;
16611643

16621644
let chan_id = match channel_state.short_to_id.get(&short_channel_id) {
16631645
Some(chan_id) => chan_id.clone(),
@@ -1729,9 +1711,9 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
17291711

17301712
{
17311713
let mut channel_lock = self.channel_state.lock().unwrap();
1732-
let channel_state = channel_lock.borrow_parts();
1733-
let short_to_id = channel_state.short_to_id;
1734-
let pending_msg_events = channel_state.pending_msg_events;
1714+
let channel_state = &mut *channel_lock;
1715+
let short_to_id = &mut channel_state.short_to_id;
1716+
let pending_msg_events = &mut channel_state.pending_msg_events;
17351717
channel_state.by_id.retain(|_, channel| {
17361718
if channel.is_awaiting_monitor_update() {
17371719
let chan_monitor = channel.channel_monitor().clone();
@@ -1836,7 +1818,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
18361818
let channel = Channel::new_from_req(&*self.fee_estimator, &self.keys_manager, their_node_id.clone(), their_features, msg, 0, Arc::clone(&self.logger), &self.default_configuration)
18371819
.map_err(|e| MsgHandleErrInternal::from_chan_no_close(e, msg.temporary_channel_id))?;
18381820
let mut channel_state_lock = self.channel_state.lock().unwrap();
1839-
let channel_state = channel_state_lock.borrow_parts();
1821+
let channel_state = &mut *channel_state_lock;
18401822
match channel_state.by_id.entry(channel.channel_id()) {
18411823
hash_map::Entry::Occupied(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close("temporary_channel_id collision!", msg.temporary_channel_id.clone())),
18421824
hash_map::Entry::Vacant(entry) => {
@@ -1853,7 +1835,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
18531835
fn internal_accept_channel(&self, their_node_id: &PublicKey, their_features: InitFeatures, msg: &msgs::AcceptChannel) -> Result<(), MsgHandleErrInternal> {
18541836
let (value, output_script, user_id) = {
18551837
let mut channel_lock = self.channel_state.lock().unwrap();
1856-
let channel_state = channel_lock.borrow_parts();
1838+
let channel_state = &mut *channel_lock;
18571839
match channel_state.by_id.entry(msg.temporary_channel_id) {
18581840
hash_map::Entry::Occupied(mut chan) => {
18591841
if chan.get().get_their_node_id() != *their_node_id {
@@ -1878,7 +1860,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
18781860
fn internal_funding_created(&self, their_node_id: &PublicKey, msg: &msgs::FundingCreated) -> Result<(), MsgHandleErrInternal> {
18791861
let ((funding_msg, monitor_update), mut chan) = {
18801862
let mut channel_lock = self.channel_state.lock().unwrap();
1881-
let channel_state = channel_lock.borrow_parts();
1863+
let channel_state = &mut *channel_lock;
18821864
match channel_state.by_id.entry(msg.temporary_channel_id.clone()) {
18831865
hash_map::Entry::Occupied(mut chan) => {
18841866
if chan.get().get_their_node_id() != *their_node_id {
@@ -1910,7 +1892,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
19101892
}
19111893
}
19121894
let mut channel_state_lock = self.channel_state.lock().unwrap();
1913-
let channel_state = channel_state_lock.borrow_parts();
1895+
let channel_state = &mut *channel_state_lock;
19141896
match channel_state.by_id.entry(funding_msg.channel_id) {
19151897
hash_map::Entry::Occupied(_) => {
19161898
return Err(MsgHandleErrInternal::send_err_msg_no_close("Already had channel with the new channel_id", funding_msg.channel_id))
@@ -1929,7 +1911,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
19291911
fn internal_funding_signed(&self, their_node_id: &PublicKey, msg: &msgs::FundingSigned) -> Result<(), MsgHandleErrInternal> {
19301912
let (funding_txo, user_id) = {
19311913
let mut channel_lock = self.channel_state.lock().unwrap();
1932-
let channel_state = channel_lock.borrow_parts();
1914+
let channel_state = &mut *channel_lock;
19331915
match channel_state.by_id.entry(msg.channel_id) {
19341916
hash_map::Entry::Occupied(mut chan) => {
19351917
if chan.get().get_their_node_id() != *their_node_id {
@@ -1954,7 +1936,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
19541936

19551937
fn internal_funding_locked(&self, their_node_id: &PublicKey, msg: &msgs::FundingLocked) -> Result<(), MsgHandleErrInternal> {
19561938
let mut channel_state_lock = self.channel_state.lock().unwrap();
1957-
let channel_state = channel_state_lock.borrow_parts();
1939+
let channel_state = &mut *channel_state_lock;
19581940
match channel_state.by_id.entry(msg.channel_id) {
19591941
hash_map::Entry::Occupied(mut chan) => {
19601942
if chan.get().get_their_node_id() != *their_node_id {
@@ -1985,7 +1967,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
19851967
fn internal_shutdown(&self, their_node_id: &PublicKey, msg: &msgs::Shutdown) -> Result<(), MsgHandleErrInternal> {
19861968
let (mut dropped_htlcs, chan_option) = {
19871969
let mut channel_state_lock = self.channel_state.lock().unwrap();
1988-
let channel_state = channel_state_lock.borrow_parts();
1970+
let channel_state = &mut *channel_state_lock;
19891971

19901972
match channel_state.by_id.entry(msg.channel_id.clone()) {
19911973
hash_map::Entry::Occupied(mut chan_entry) => {
@@ -2032,7 +2014,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
20322014
fn internal_closing_signed(&self, their_node_id: &PublicKey, msg: &msgs::ClosingSigned) -> Result<(), MsgHandleErrInternal> {
20332015
let (tx, chan_option) = {
20342016
let mut channel_state_lock = self.channel_state.lock().unwrap();
2035-
let channel_state = channel_state_lock.borrow_parts();
2017+
let channel_state = &mut *channel_state_lock;
20362018
match channel_state.by_id.entry(msg.channel_id.clone()) {
20372019
hash_map::Entry::Occupied(mut chan_entry) => {
20382020
if chan_entry.get().get_their_node_id() != *their_node_id {
@@ -2086,7 +2068,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
20862068
//but we should prevent it anyway.
20872069

20882070
let (mut pending_forward_info, mut channel_state_lock) = self.decode_update_add_htlc_onion(msg);
2089-
let channel_state = channel_state_lock.borrow_parts();
2071+
let channel_state = &mut *channel_state_lock;
20902072

20912073
match channel_state.by_id.entry(msg.channel_id) {
20922074
hash_map::Entry::Occupied(mut chan) => {
@@ -2135,7 +2117,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
21352117
fn internal_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFulfillHTLC) -> Result<(), MsgHandleErrInternal> {
21362118
let mut channel_lock = self.channel_state.lock().unwrap();
21372119
let htlc_source = {
2138-
let channel_state = channel_lock.borrow_parts();
2120+
let channel_state = &mut *channel_lock;
21392121
match channel_state.by_id.entry(msg.channel_id) {
21402122
hash_map::Entry::Occupied(mut chan) => {
21412123
if chan.get().get_their_node_id() != *their_node_id {
@@ -2152,7 +2134,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
21522134

21532135
fn internal_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailHTLC) -> Result<(), MsgHandleErrInternal> {
21542136
let mut channel_lock = self.channel_state.lock().unwrap();
2155-
let channel_state = channel_lock.borrow_parts();
2137+
let channel_state = &mut *channel_lock;
21562138
match channel_state.by_id.entry(msg.channel_id) {
21572139
hash_map::Entry::Occupied(mut chan) => {
21582140
if chan.get().get_their_node_id() != *their_node_id {
@@ -2167,7 +2149,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
21672149

21682150
fn internal_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFailMalformedHTLC) -> Result<(), MsgHandleErrInternal> {
21692151
let mut channel_lock = self.channel_state.lock().unwrap();
2170-
let channel_state = channel_lock.borrow_parts();
2152+
let channel_state = &mut *channel_lock;
21712153
match channel_state.by_id.entry(msg.channel_id) {
21722154
hash_map::Entry::Occupied(mut chan) => {
21732155
if chan.get().get_their_node_id() != *their_node_id {
@@ -2185,7 +2167,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
21852167

21862168
fn internal_commitment_signed(&self, their_node_id: &PublicKey, msg: &msgs::CommitmentSigned) -> Result<(), MsgHandleErrInternal> {
21872169
let mut channel_state_lock = self.channel_state.lock().unwrap();
2188-
let channel_state = channel_state_lock.borrow_parts();
2170+
let channel_state = &mut *channel_state_lock;
21892171
match channel_state.by_id.entry(msg.channel_id) {
21902172
hash_map::Entry::Occupied(mut chan) => {
21912173
if chan.get().get_their_node_id() != *their_node_id {
@@ -2261,7 +2243,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
22612243
fn internal_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &msgs::RevokeAndACK) -> Result<(), MsgHandleErrInternal> {
22622244
let (pending_forwards, mut pending_failures, short_channel_id) = {
22632245
let mut channel_state_lock = self.channel_state.lock().unwrap();
2264-
let channel_state = channel_state_lock.borrow_parts();
2246+
let channel_state = &mut *channel_state_lock;
22652247
match channel_state.by_id.entry(msg.channel_id) {
22662248
hash_map::Entry::Occupied(mut chan) => {
22672249
if chan.get().get_their_node_id() != *their_node_id {
@@ -2305,7 +2287,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
23052287

23062288
fn internal_update_fee(&self, their_node_id: &PublicKey, msg: &msgs::UpdateFee) -> Result<(), MsgHandleErrInternal> {
23072289
let mut channel_lock = self.channel_state.lock().unwrap();
2308-
let channel_state = channel_lock.borrow_parts();
2290+
let channel_state = &mut *channel_lock;
23092291
match channel_state.by_id.entry(msg.channel_id) {
23102292
hash_map::Entry::Occupied(mut chan) => {
23112293
if chan.get().get_their_node_id() != *their_node_id {
@@ -2320,7 +2302,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
23202302

23212303
fn internal_announcement_signatures(&self, their_node_id: &PublicKey, msg: &msgs::AnnouncementSignatures) -> Result<(), MsgHandleErrInternal> {
23222304
let mut channel_state_lock = self.channel_state.lock().unwrap();
2323-
let channel_state = channel_state_lock.borrow_parts();
2305+
let channel_state = &mut *channel_state_lock;
23242306

23252307
match channel_state.by_id.entry(msg.channel_id) {
23262308
hash_map::Entry::Occupied(mut chan) => {
@@ -2362,7 +2344,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
23622344

23632345
fn internal_channel_reestablish(&self, their_node_id: &PublicKey, msg: &msgs::ChannelReestablish) -> Result<(), MsgHandleErrInternal> {
23642346
let mut channel_state_lock = self.channel_state.lock().unwrap();
2365-
let channel_state = channel_state_lock.borrow_parts();
2347+
let channel_state = &mut *channel_state_lock;
23662348

23672349
match channel_state.by_id.entry(msg.channel_id) {
23682350
hash_map::Entry::Occupied(mut chan) => {
@@ -2440,7 +2422,7 @@ impl<ChanSigner: ChannelKeys> ChannelManager<ChanSigner> {
24402422
let mut channel_state_lock = self.channel_state.lock().unwrap();
24412423
let their_node_id;
24422424
let err: Result<(), _> = loop {
2443-
let channel_state = channel_state_lock.borrow_parts();
2425+
let channel_state = &mut *channel_state_lock;
24442426

24452427
match channel_state.by_id.entry(channel_id) {
24462428
hash_map::Entry::Vacant(_) => return Err(APIError::APIMisuseError{err: "Failed to find corresponding channel"}),
@@ -2543,9 +2525,9 @@ impl<ChanSigner: ChannelKeys> ChainListener for ChannelManager<ChanSigner> {
25432525
let mut failed_channels = Vec::new();
25442526
{
25452527
let mut channel_lock = self.channel_state.lock().unwrap();
2546-
let channel_state = channel_lock.borrow_parts();
2547-
let short_to_id = channel_state.short_to_id;
2548-
let pending_msg_events = channel_state.pending_msg_events;
2528+
let channel_state = &mut *channel_lock;
2529+
let short_to_id = &mut channel_state.short_to_id;
2530+
let pending_msg_events = &mut channel_state.pending_msg_events;
25492531
channel_state.by_id.retain(|_, channel| {
25502532
let chan_res = channel.block_connected(header, height, txn_matched, indexes_of_txn_matched);
25512533
if let Ok(Some(funding_locked)) = chan_res {
@@ -2621,9 +2603,9 @@ impl<ChanSigner: ChannelKeys> ChainListener for ChannelManager<ChanSigner> {
26212603
let mut failed_channels = Vec::new();
26222604
{
26232605
let mut channel_lock = self.channel_state.lock().unwrap();
2624-
let channel_state = channel_lock.borrow_parts();
2625-
let short_to_id = channel_state.short_to_id;
2626-
let pending_msg_events = channel_state.pending_msg_events;
2606+
let channel_state = &mut *channel_lock;
2607+
let short_to_id = &mut channel_state.short_to_id;
2608+
let pending_msg_events = &mut channel_state.pending_msg_events;
26272609
channel_state.by_id.retain(|_, v| {
26282610
if v.block_disconnected(header) {
26292611
if let Some(short_id) = v.get_short_channel_id() {
@@ -2800,9 +2782,9 @@ impl<ChanSigner: ChannelKeys> ChannelMessageHandler for ChannelManager<ChanSigne
28002782
let mut failed_payments = Vec::new();
28012783
{
28022784
let mut channel_state_lock = self.channel_state.lock().unwrap();
2803-
let channel_state = channel_state_lock.borrow_parts();
2804-
let short_to_id = channel_state.short_to_id;
2805-
let pending_msg_events = channel_state.pending_msg_events;
2785+
let channel_state = &mut *channel_state_lock;
2786+
let short_to_id = &mut channel_state.short_to_id;
2787+
let pending_msg_events = &mut channel_state.pending_msg_events;
28062788
if no_connection_possible {
28072789
log_debug!(self, "Failing all channels with {} due to no_connection_possible", log_pubkey!(their_node_id));
28082790
channel_state.by_id.retain(|_, chan| {
@@ -2876,8 +2858,8 @@ impl<ChanSigner: ChannelKeys> ChannelMessageHandler for ChannelManager<ChanSigne
28762858

28772859
let _ = self.total_consistency_lock.read().unwrap();
28782860
let mut channel_state_lock = self.channel_state.lock().unwrap();
2879-
let channel_state = channel_state_lock.borrow_parts();
2880-
let pending_msg_events = channel_state.pending_msg_events;
2861+
let channel_state = &mut *channel_state_lock;
2862+
let pending_msg_events = &mut channel_state.pending_msg_events;
28812863
channel_state.by_id.retain(|_, chan| {
28822864
if chan.get_their_node_id() == *their_node_id {
28832865
if !chan.have_received_message() {

‎lightning/src/ln/functional_tests.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5019,7 +5019,7 @@ fn test_onion_failure() {
50195019
}, || {}, true, Some(17), None);
50205020

50215021
run_onion_failure_test("final_incorrect_cltv_expiry", 1, &nodes, &route, &payment_hash, |_| {}, || {
5022-
for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().borrow_parts().forward_htlcs.iter_mut() {
5022+
for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
50235023
for f in pending_forwards.iter_mut() {
50245024
match f {
50255025
&mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>
@@ -5032,7 +5032,7 @@ fn test_onion_failure() {
50325032

50335033
run_onion_failure_test("final_incorrect_htlc_amount", 1, &nodes, &route, &payment_hash, |_| {}, || {
50345034
// violate amt_to_forward > msg.amount_msat
5035-
for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().borrow_parts().forward_htlcs.iter_mut() {
5035+
for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
50365036
for f in pending_forwards.iter_mut() {
50375037
match f {
50385038
&mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>

0 commit comments

Comments
 (0)