fix(main): better messages for background thread operations

src/main.rs

@@ -107,7 +107,7 @@ impl Drop for EventSender {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-enum MostrMessage {
+pub(crate) enum MostrMessage {
     Flush,
     NewRelay(Url),
     AddTasks(Url, Vec<Event>),
@@ -120,7 +120,7 @@ async fn main() {
         args.next();
         Builder::new()
             .filter(None, LevelFilter::Debug)
-            .filter(Some("mostr"), LevelFilter::Trace)
+            //.filter(Some("mostr"), LevelFilter::Trace)
             .parse_default_env()
             .init();
     } else {
@@ -183,20 +183,7 @@ async fn main() {
     let sub_id = client.subscribe(vec![Filter::new().kinds(KINDS.into_iter().map(|k| Kind::from(k)))], None).await;
     info!("Subscribed with {:?}", sub_id);
 
-    //let proxy = Some(SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 9050)));
-    //client
-    //    .add_relay_with_opts(
-    //        "wss://relay.nostr.info",
-    //        RelayOptions::new().proxy(proxy).flags(RelayServiceFlags::default().remove(RelayServiceFlags::WRITE)),
-    //    )
-    //    .await?;
-    //client
-    //    .add_relay_with_opts(
-    //        "ws://jgqaglhautb4k6e6i2g34jakxiemqp6z4wynlirltuukgkft2xuglmqd.onion",
-    //        RelayOptions::new().proxy(proxy),
-    //    )
-    //    .await?;
-
+    // TODO user data from config file or home relay?
     //let metadata = Metadata::new()
     //    .name("username")
     //    .display_name("My Username")
@@ -206,42 +193,22 @@ async fn main() {
     //    .nip05("username@example.com")
     //    .lud16("yuki@getalby.com")
     //    .custom_field("custom_field", "my value");
-
     //client.set_metadata(&metadata).await?;
 
-    client.connect().await;
     let mut notifications = client.notifications();
+    client.connect().await;
 
     let (tx, rx) = mpsc::channel::<MostrMessage>();
     let tasks_for_url = |url: Option<Url>| Tasks::from(url, &tx, &keys);
     let mut relays: HashMap<Url, Tasks> =
         client.relays().await.into_keys().map(|url| (url.clone(), tasks_for_url(Some(url)))).collect();
 
-    /*println!("Finding existing events");
-    let _ = client
-        .get_events_of(vec![Filter::new()], Some(Duration::from_secs(5)))
-        .map_ok(|res| {
-            println!("Found {} events", res.len());
-            let (mut task_events, props): (Vec<Event>, Vec<Event>) =
-                res.into_iter().partition(|e| e.kind.as_u32() == 1621);
-            task_events.sort_unstable();
-            for event in task_events {
-                print_event(&event);
-                tasks.add_task(event);
-            }
-            for event in props {
-                print_event(&event);
-                tasks.add_prop(&event);
-            }
-        })
-        .await;*/
-
     let sender = tokio::spawn(async move {
         let mut queue: Option<(Url, Vec<Event>)> = None;
 
         loop {
-            let result = rx.recv_timeout(Duration::from_secs(INACTVITY_DELAY));
-            match result {
+            let result_received = rx.recv_timeout(Duration::from_secs(INACTVITY_DELAY));
+            match result_received {
                 Ok(MostrMessage::NewRelay(url)) => {
                     if client.add_relay(&url).await.unwrap() {
                         match client.connect_relay(&url).await {
@@ -270,12 +237,13 @@ async fn main() {
                     }
                 }
                 Ok(MostrMessage::Flush) | Err(RecvTimeoutError::Timeout) => if let Some((url, events)) = queue {
-                    info!("Sending {} events to {url} due to {:?}", events.len(), result);
+                    info!("Sending {} events to {url} due to {}", events.len(),
+                        result_received.map_or_else(|e| format!("{:?}", e), |m| format!("{:?}", m)));
                     client.batch_event_to(vec![url], events, RelaySendOptions::new()).await;
                     queue = None;
                 }
                 Err(err) => {
-                    debug!("Finalizing nostr communication thread because of {:?}", err);
+                    debug!("Finalizing nostr communication thread because of {:?}: {}", err, err);
                     break;
                 }
             }

src/tasks.rs

@@ -298,39 +298,35 @@ impl Tasks {
 
     // Helpers
 
-    fn resolve_tasks<'a>(&self, iter: impl IntoIterator<Item=&'a EventId>) -> Vec<&Task> {
+    fn resolve_tasks<'a>(&'a self, iter: impl Iterator<Item=&'a EventId>) -> impl Iterator<Item=&'a Task> {
         self.resolve_tasks_rec(iter, self.depth)
     }
 
     fn resolve_tasks_rec<'a>(
-        &self,
-        iter: impl IntoIterator<Item=&'a EventId>,
+        &'a self,
+        iter: impl Iterator<Item=&'a EventId>,
         depth: i8,
-    ) -> Vec<&Task> {
-        iter.into_iter()
-            .filter_map(|id| self.get_by_id(&id))
-            .flat_map(|task| {
+    ) -> Box<impl Iterator<Item=&'a Task>> {
+        iter.filter_map(|id| self.get_by_id(&id))
+            .flat_map(move |task| {
                 let new_depth = depth - 1;
+                if new_depth == 0 {
+                    vec![task]
+                } else {
+                    let tasks_iter = self.resolve_tasks_rec(task.children.iter(), new_depth);
                     if new_depth < 0 {
-                    let tasks = self
-                        .resolve_tasks_rec(task.children.iter(), new_depth)
-                        .into_iter()
-                        .collect::<Vec<&Task>>();
+                        let tasks: Vec<&Task> = tasks_iter.collect();
                         if tasks.is_empty() {
                             vec![task]
                         } else {
                             tasks
                         }
-                } else if new_depth > 0 {
-                    self.resolve_tasks_rec(task.children.iter(), new_depth)
-                        .into_iter()
-                        .chain(once(task))
-                        .collect()
                     } else {
-                    vec![task]
+                        tasks_iter.chain(once(task)).collect()
+                    }
                 }
             })
-            .collect()
+            .into()
     }
 
     pub(crate) fn referenced_tasks<F: Fn(&mut Task)>(&mut self, event: &Event, f: F) {
@@ -354,8 +350,8 @@ impl Tasks {
     }
 
     pub(crate) fn filtered_tasks(&self, position: Option<EventId>) -> impl Iterator<Item=&Task> {
-        // TODO use ChildrenIterator
-        self.resolve_tasks(self.children_of(position)).into_iter()
+        // TODO use ChildIterator
+        self.resolve_tasks(self.children_of(position))
             .filter(|t| {
                 // TODO apply filters in transit
                 self.state.matches(t) &&
@@ -375,7 +371,7 @@ impl Tasks {
             return self.get_current_task().into_iter().collect();
         }
         if self.view.len() > 0 {
-            return self.resolve_tasks(self.view.iter());
+            return self.resolve_tasks(self.view.iter()).collect();
         }
         self.filtered_tasks(self.position).collect()
     }