mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-25 15:20:24 +01:00
Code Issues Projects Releases Packages Wiki Activity

Change ChannelManager::wait to be more descriptive

Browse source 
`wait` doesn't capture enough of what's going on, but also Java
Java doesn't accpet methods just called `wait`, as it conflicts
with existing sync primitives on all Objects.
This commit is contained in:
Matt Corallo 2021-02-26 11:28:55 -05:00
parent 6742343319
commit 578f8b72e2
4 changed files with 18 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
background-processor/src/lib.rs
View file

@ -66,7 +66,7 @@ impl BackgroundProcessor {
let handle = thread::spawn(move || -> Result<(), std::io::Error> {
let mut current_time = Instant::now();
loop {
let updates_available = manager.wait_timeout(Duration::from_millis(100));
let updates_available = manager.await_persistable_update_timeout(Duration::from_millis(100));
if updates_available {
persist_manager(&*manager)?;
}

2
lightning-c-bindings/include/lightning.h
View file

@ -6072,7 +6072,7 @@ void ChannelManager_block_disconnected(const struct LDKChannelManager *NONNULL_P
* Blocks until ChannelManager needs to be persisted. Only one listener on `wait` is
* guaranteed to be woken up.
*/
void ChannelManager_wait(const struct LDKChannelManager *NONNULL_PTR this_arg);
void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);

4
lightning-c-bindings/src/ln/channelmanager.rs
View file

@ -784,8 +784,8 @@ pub extern "C" fn ChannelManager_block_disconnected(this_arg: &ChannelManager, h
/// Blocks until ChannelManager needs to be persisted. Only one listener on `wait` is
/// guaranteed to be woken up.
#[no_mangle]
pub extern "C" fn ChannelManager_wait(this_arg: &ChannelManager) {
unsafe { &*this_arg.inner }.wait()
pub extern "C" fn ChannelManager_await_persistable_update(this_arg: &ChannelManager) {
unsafe { &*this_arg.inner }.await_persistable_update()
}
impl From<nativeChannelManager> for crate::ln::msgs::ChannelMessageHandler {

25
lightning/src/ln/channelmanager.rs
View file

@ -480,10 +480,11 @@ pub struct ChainParameters {
}
/// Whenever we release the `ChannelManager`'s `total_consistency_lock`, from read mode, it is
/// desirable to notify any listeners on `wait_timeout`/`wait` that new updates are available for
/// persistence. Therefore, this struct is responsible for locking the total consistency lock and,
/// upon going out of scope, sending the aforementioned notification (since the lock being released
/// indicates that the updates are ready for persistence).
/// desirable to notify any listeners on `await_persistable_update_timeout`/
/// `await_persistable_update` that new updates are available for persistence. Therefore, this
/// struct is responsible for locking the total consistency lock and, upon going out of scope,
/// sending the aforementioned notification (since the lock being released indicates that the
/// updates are ready for persistence).
struct PersistenceNotifierGuard<'a> {
persistence_notifier: &'a PersistenceNotifier,
// We hold onto this result so the lock doesn't get released immediately.
@ -3407,17 +3408,19 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
}
/// Blocks until ChannelManager needs to be persisted or a timeout is reached. It returns a bool
/// indicating whether persistence is necessary. Only one listener on `wait_timeout` is
/// guaranteed to be woken up.
/// indicating whether persistence is necessary. Only one listener on
/// `await_persistable_update` or `await_persistable_update_timeout` is guaranteed to be woken
/// up.
/// Note that the feature `allow_wallclock_use` must be enabled to use this function.
#[cfg(any(test, feature = "allow_wallclock_use"))]
pub fn wait_timeout(&self, max_wait: Duration) -> bool {
pub fn await_persistable_update_timeout(&self, max_wait: Duration) -> bool {
self.persistence_notifier.wait_timeout(max_wait)
}
/// Blocks until ChannelManager needs to be persisted. Only one listener on `wait` is
/// guaranteed to be woken up.
pub fn wait(&self) {
/// Blocks until ChannelManager needs to be persisted. Only one listener on
/// `await_persistable_update` or `await_persistable_update_timeout` is guaranteed to be woken
/// up.
pub fn await_persistable_update(&self) {
self.persistence_notifier.wait()
}
@ -3669,7 +3672,7 @@ impl<Signer: Sign, M: Deref + Sync + Send, T: Deref + Sync + Send, K: Deref + Sy
}
/// Used to signal to the ChannelManager persister that the manager needs to be re-persisted to
/// disk/backups, through `wait_timeout` and `wait`.
/// disk/backups, through `await_persistable_update_timeout` and `await_persistable_update`.
struct PersistenceNotifier {
/// Users won't access the persistence_lock directly, but rather wait on its bool using
/// `wait_timeout` and `wait`.