Remove globals.events; everything is now in globals.feed_events

src/globals.rs

@@ -7,6 +7,7 @@ use rusqlite::Connection;
 use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use tokio::sync::{broadcast, mpsc, Mutex};
+use tracing::warn;
 
 /// Only one of these is ever created, via lazy_static!, and represents
 /// global state for the rust application
@@ -26,9 +27,6 @@ pub struct Globals {
     /// and stolen away when the Overlord is created.
     pub from_minions: Mutex<Option<mpsc::UnboundedReceiver<BusMessage>>>,
 
-    /// All nostr events currently loaded to memory, keyed by their Id
-    pub events: Mutex<HashMap<Id, Event>>,
-
     /// All nostr event related data, keyed by the event Id
     pub feed_events: Mutex<HashMap<Id, FeedEvent>>,
 
@@ -54,7 +52,6 @@ lazy_static! {
             to_minions,
             to_overlord,
             from_minions: Mutex::new(Some(from_minions)),
-            events: Mutex::new(HashMap::new()),
             feed_events: Mutex::new(HashMap::new()),
             people: Mutex::new(HashMap::new()),
             need_password: AtomicBool::new(false),
@@ -147,18 +144,25 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
                     }
                 } else if event.kind == EventKind::EventDeletion {
                     // Find the other event
-                    if let Some(other_event) = { GLOBALS.events.lock().await.get(id) } {
+                    if let Some(deleted_feed_event) = { GLOBALS.feed_events.lock().await.get(id) } {
-                        // Make sure the authors match
+                        match &deleted_feed_event.event {
-                        if other_event.pubkey != event.pubkey {
+                            None => {
-                            // Invalid delete event
+                                // Can't verify the author. Take no action
-                            GLOBALS.events.lock().await.remove(id);
+                            }
-                            GLOBALS.feed_events.lock().await.remove(id);
+                            Some(deleted_event) => {
-                            return Ok(());
+                                if deleted_event.pubkey != event.pubkey {
+                                    // Invalid delete event, author does not match
+                                    warn!("Somebody tried to delete someone elses event");
+                                    GLOBALS.feed_events.lock().await.remove(id);
+                                    return Ok(());
+                                } else {
+                                    update_feed_event(*id, |er| {
+                                        er.deleted_reason = Some(event.content.clone());
+                                    })
+                                    .await;
+                                }
+                            }
                         }
-                        update_feed_event(*id, |er| {
-                            er.deleted_reason = Some(event.content.clone());
-                        })
-                        .await;
                     } else {
                         // FIXME - currently we don't apply this deletion event
                         // if we don't have the event it refers to because we cannot
@@ -209,8 +213,8 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
 }
 
 async fn insert_event(event: &Event) {
-    let mut events = GLOBALS.events.lock().await;
+    let mut feed_events = GLOBALS.feed_events.lock().await;
-    events.insert(event.id, event.clone());
+    feed_events.insert(event.id, event.into());
 }
 
 async fn update_feed_event<F>(id: Id, mut f: F)
@@ -218,9 +222,7 @@ where
     F: FnMut(&mut FeedEvent),
 {
     let mut feed_events = GLOBALS.feed_events.lock().await;
-    let feed_event = feed_events
+    let feed_event = feed_events.entry(id).or_insert_with(|| FeedEvent::new(id));
-        .entry(id)
-        .or_insert_with(|| FeedEvent::new(id));
     f(feed_event);
 }
 

src/overlord/mod.rs

@@ -231,33 +231,35 @@ impl Overlord {
                     let event: Event = serde_json::from_str(&bus_message.json_payload)?;
 
                     // If feed-related, send to the feed event processor
-                    if event.kind==EventKind::TextNote || event.kind==EventKind::EncryptedDirectMessage ||
+                    if event.kind == EventKind::TextNote
-                        event.kind==EventKind::EventDeletion || event.kind==EventKind::Reaction
+                        || event.kind == EventKind::EncryptedDirectMessage
+                        || event.kind == EventKind::EventDeletion
+                        || event.kind == EventKind::Reaction
                     {
                         crate::globals::add_event(&event).await?;
 
                         debug!("Received new feed event");
-                    }
+                    } else {
-                    else {
                         // Not Feed Related:  Metadata, RecommendRelay, ContactList
                         debug!("Received new non-feed event");
 
-                        if event.kind==EventKind::Metadata {
+                        if event.kind == EventKind::Metadata {
                             let metadata: Metadata = serde_json::from_str(&event.content)?;
                             crate::globals::update_person_from_event_metadata(
-                                event.pubkey.into(), event.created_at, metadata
+                                event.pubkey,
-                            ).await;
+                                event.created_at,
+                                metadata,
+                            )
+                            .await;
                         }
 
                         // FIXME: Handle EventKind::RecommendedRelay
                         // FIXME: Handle EventKind::ContactList
                     }
-
+                }
-                },
+                "minion_is_ready" => {}
-                "minion_is_ready" => {
-                },
                 _ => {}
-            }
+            },
             _ => {}
         }
 

src/ui/feed.rs

@@ -15,27 +15,26 @@ pub(super) fn update(_app: &mut GossipUi, ctx: &Context, _frame: &mut eframe::Fr
                 break;
             }
 
-            if let Some(event) = crate::globals::GLOBALS.events.blocking_lock().get(id) {
+            if let Some(fevent) = crate::globals::GLOBALS.feed_events.blocking_lock().get(id) {
-                ui.label(crate::date_ago::date_ago(event.created_at));
+                if let Some(event) = &fevent.event {
+                    ui.label(crate::date_ago::date_ago(event.created_at));
 
-                if let Some(person) = crate::globals::GLOBALS
+                    if let Some(person) = crate::globals::GLOBALS
-                    .people
+                        .people
-                    .blocking_lock()
+                        .blocking_lock()
-                    .get(&event.pubkey)
+                        .get(&event.pubkey)
-                {
+                    {
-                    if let Some(name) = &person.name {
+                        if let Some(name) = &person.name {
-                        ui.label(name);
+                            ui.label(name);
+                        } else {
+                            ui.label(event.pubkey.as_hex_string());
+                        }
                     } else {
                         ui.label(event.pubkey.as_hex_string());
                     }
-                } else {
+                    ui.label(&event.content);
-                    ui.label(event.pubkey.as_hex_string());
+                    ui.separator();
                 }
-                ui.label(&event.content);
-                ui.separator();
-            } else {
-                ui.label("-- missing event --".to_string());
-                ui.separator();
             }
         }
     });