notedeck

commit 5168d502571543f0c2a6857ec8a344790cc8e5c3
parent cc92fc20825ba48865683751b1d23d4e58a83dc0
Author: kernelkind <kernelkind@gmail.com>
Date:   Wed, 16 Jul 2025 13:58:25 -0400

add info statements

Signed-off-by: kernelkind <kernelkind@gmail.com>

Diffstat:
M
crates/notedeck_columns/src/multi_subscriber.rs
 | 
97
++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------

1 file changed, 62 insertions(+), 35 deletions(-)
diff --git a/crates/notedeck_columns/src/multi_subscriber.rs b/crates/notedeck_columns/src/multi_subscriber.rs
@@ -270,7 +270,7 @@ pub struct TimelineSub {
     state: SubState,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 enum SubState {
     NoSub {
         dependers: usize,
@@ -300,6 +300,7 @@ impl Default for TimelineSub {
 
 impl TimelineSub {
     pub fn try_add_local(&mut self, ndb: &Ndb, filter: &[Filter]) {
+        let before = self.state.clone();
         match &mut self.state {
             SubState::NoSub { dependers } => {
                 let Some(sub) = ndb_sub(ndb, filter, "") else {
@@ -333,9 +334,15 @@ impl TimelineSub {
                 dependers: _,
             } => {}
         }
+        tracing::info!(
+            "TimelineSub::try_add_local: {:?} => {:?}",
+            before,
+            self.state
+        );
     }
 
     pub fn force_add_remote(&mut self, subid: String) {
+        let before = self.state.clone();
         match &mut self.state {
             SubState::NoSub { dependers } => {
                 self.state = SubState::RemoteOnly {
@@ -361,9 +368,15 @@ impl TimelineSub {
                 dependers: _,
             } => {}
         }
+        tracing::info!(
+            "TimelineSub::force_add_remote: {:?} => {:?}",
+            before,
+            self.state
+        );
     }
 
     pub fn try_add_remote(&mut self, pool: &mut RelayPool, filter: &Vec<Filter>) {
+        let before = self.state.clone();
         match &mut self.state {
             SubState::NoSub { dependers } => {
                 let subid = subscriptions::new_sub_id();
@@ -395,9 +408,15 @@ impl TimelineSub {
                 dependers: _,
             } => {}
         }
+        tracing::info!(
+            "TimelineSub::try_add_remote: {:?} => {:?}",
+            before,
+            self.state
+        );
     }
 
     pub fn increment(&mut self) {
+        let before = self.state.clone();
         match &mut self.state {
             SubState::NoSub { dependers } => {
                 *dependers += 1;
@@ -421,6 +440,8 @@ impl TimelineSub {
                 *dependers += 1;
             }
         }
+
+        tracing::info!("TimelineSub::increment: {:?} => {:?}", before, self.state);
     }
 
     pub fn get_local(&self) -> Option<Subscription> {
@@ -442,54 +463,60 @@ impl TimelineSub {
     }
 
     pub fn unsubscribe_or_decrement(&mut self, ndb: &mut Ndb, pool: &mut RelayPool) {
-        match &mut self.state {
-            SubState::NoSub { dependers } => {
-                *dependers -= 1;
-            }
-            SubState::LocalOnly { local, dependers } => {
-                if *dependers > 1 {
+        let before = self.state.clone();
+        's: {
+            match &mut self.state {
+                SubState::NoSub { dependers } => {
                     *dependers -= 1;
-                    return;
                 }
+                SubState::LocalOnly { local, dependers } => {
+                    if *dependers > 1 {
+                        *dependers -= 1;
+                        break 's;
+                    }
 
-                if let Err(e) = ndb.unsubscribe(*local) {
-                    tracing::error!("Could not unsub ndb: {e}");
-                    return;
-                }
+                    if let Err(e) = ndb.unsubscribe(*local) {
+                        tracing::error!("Could not unsub ndb: {e}");
+                        break 's;
+                    }
 
-                self.state = SubState::NoSub { dependers: 0 };
-            }
-            SubState::RemoteOnly { remote, dependers } => {
-                if *dependers > 1 {
-                    *dependers -= 1;
-                    return;
+                    self.state = SubState::NoSub { dependers: 0 };
                 }
+                SubState::RemoteOnly { remote, dependers } => {
+                    if *dependers > 1 {
+                        *dependers -= 1;
+                        break 's;
+                    }
 
-                pool.unsubscribe(remote.to_owned());
+                    pool.unsubscribe(remote.to_owned());
 
-                self.state = SubState::NoSub { dependers: 0 };
-            }
-            SubState::Unified { unified, dependers } => {
-                if *dependers > 1 {
-                    *dependers -= 1;
-                    return;
+                    self.state = SubState::NoSub { dependers: 0 };
                 }
+                SubState::Unified { unified, dependers } => {
+                    if *dependers > 1 {
+                        *dependers -= 1;
+                        break 's;
+                    }
 
-                pool.unsubscribe(unified.remote.to_owned());
+                    pool.unsubscribe(unified.remote.to_owned());
 
-                if let Err(e) = ndb.unsubscribe(unified.local) {
-                    tracing::error!("could not unsub ndb: {e}");
-                    self.state = SubState::LocalOnly {
-                        local: unified.local,
-                        dependers: *dependers,
+                    if let Err(e) = ndb.unsubscribe(unified.local) {
+                        tracing::error!("could not unsub ndb: {e}");
+                        self.state = SubState::LocalOnly {
+                            local: unified.local,
+                            dependers: *dependers,
+                        }
+                    } else {
+                        self.state = SubState::NoSub { dependers: 0 };
                     }
-                } else {
-                    self.state = SubState::NoSub {
-                        dependers: *dependers,
-                    };
                 }
             }
         }
+        tracing::info!(
+            "TimelineSub::unsubscribe_or_decrement: {:?} => {:?}",
+            before,
+            self.state
+        );
     }
 
     pub fn get_filter(&self) -> Option<&Vec<Filter>> {