storage: read_or_create_relay() [more ergonomic than write_relay_if_missing]

gossip-bin/src/ui/wizard/setup_relays.rs

@@ -12,13 +12,7 @@ pub(super) fn update(app: &mut GossipUi, _ctx: &Context, _frame: &mut eframe::Fr
     ui.add_space(20.0);
     ui.label("Please choose which relays you will use.");
 
-    let read_relay = |url: &RelayUrl| {
-        GLOBALS
-            .storage
-            .read_relay(url)
-            .unwrap()
-            .unwrap_or(Relay::new(url.to_owned()))
-    };
+    let read_relay = |url: &RelayUrl| GLOBALS.storage.read_or_create_relay(url, None).unwrap();
 
     // Convert our default relay strings into Relays
     // fetching from storage so we don't overwrite any critical values when saving them later.

gossip-lib/src/overlord/minion/mod.rs

@@ -62,14 +62,7 @@ impl Minion {
     pub async fn new(url: RelayUrl) -> Result<Minion, Error> {
         let to_overlord = GLOBALS.to_overlord.clone();
         let from_overlord = GLOBALS.to_minions.subscribe();
-        let dbrelay = match GLOBALS.storage.read_relay(&url)? {
-            Some(dbrelay) => dbrelay,
-            None => {
-                let dbrelay = Relay::new(url.clone());
-                GLOBALS.storage.write_relay(&dbrelay, None)?;
-                dbrelay
-            }
-        };
+        let dbrelay = GLOBALS.storage.read_or_create_relay(&url, None)?;
 
         Ok(Minion {
             url,

gossip-lib/src/overlord/mod.rs

@@ -304,12 +304,9 @@ impl Overlord {
             return Ok(());
         }
 
-        if let Some(relay) = GLOBALS.storage.read_relay(&url)? {
-            if relay.rank == 0 {
-                return Ok(()); // don't connect to rank=0 relays
-            }
-        } else {
-            GLOBALS.storage.write_relay_if_missing(&url, None)?;
+        let relay = GLOBALS.storage.read_or_create_relay(&url, None)?;
+        if relay.rank == 0 {
+            return Ok(()); // don't connect to rank=0 relays
         }
 
         if let Some(mut refmut) = GLOBALS.connected_relays.get_mut(&url) {

gossip-lib/src/storage/mod.rs

@@ -1014,6 +1014,22 @@ impl Storage {
         self.read_relay1(url)
     }
 
+    /// Read or create relay
+    pub fn read_or_create_relay<'a>(
+        &'a self,
+        url: &RelayUrl,
+        rw_txn: Option<&mut RwTxn<'a>>,
+    ) -> Result<Relay, Error> {
+        match self.read_relay(url)? {
+            Some(relay) => Ok(relay),
+            None => {
+                let relay = Relay::new(url.to_owned());
+                self.write_relay(&relay, rw_txn)?;
+                Ok(relay)
+            }
+        }
+    }
+
     /// Read matching relay records
     #[inline]
     pub fn filter_relays<F>(&self, f: F) -> Result<Vec<Relay>, Error>
@@ -2027,14 +2043,7 @@ impl Storage {
 
         // Modulate these scores with our local rankings
         for ranked_relay in ranked_relays.iter_mut() {
-            let relay = match self.read_relay(&ranked_relay.0)? {
-                None => {
-                    self.write_relay_if_missing(&ranked_relay.0, None)?;
-                    Relay::new(ranked_relay.0.clone())
-                }
-                Some(relay) => relay,
-            };
-
+            let relay = self.read_or_create_relay(&ranked_relay.0, None)?;
             ranked_relay.1 = (ranked_relay.1 as f32
                 * (relay.rank as f32 / 3.0)
                 * (relay.success_rate() * 2.0)) as u64;