Change ChannelManager::wait to be more descriptive

`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.

diff --git a/background-processor/src/lib.rs b/background-processor/src/lib.rs
index 00f984580f2556fae736a4b7c153caf23839ff58..1976962bea6ef8c7951be6bd818e638be36ff5e1 100644 (file)
--- a/background-processor/src/lib.rs
+++ b/background-processor/src/lib.rs
@@ -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)?;
                                }

diff --git a/lightning-c-bindings/include/lightning.h b/lightning-c-bindings/include/lightning.h
index 8076e251b85ed9039859d20a1df09320007a610e..536d6a74cf7db1b5a3a88056db8a90eace2d1151 100644 (file)
--- a/lightning-c-bindings/include/lightning.h
+++ b/lightning-c-bindings/include/lightning.h
@@ -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);
 

diff --git a/lightning-c-bindings/src/ln/channelmanager.rs b/lightning-c-bindings/src/ln/channelmanager.rs
index a175a2ce917a8ceeca8bdb96efc88c73f0a145e9..a865372d0c27fdfda040714a7d7ce1374b0b98a7 100644 (file)
--- a/lightning-c-bindings/src/ln/channelmanager.rs
+++ b/lightning-c-bindings/src/ln/channelmanager.rs
@@ -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 {

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 6e46d79fb08a76624e57bb2b25bac77834941be3..de0ce53590dcebfad11af1ca78e11c93547a4ad2 100644 (file)
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -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`.