Fixes #84

watchtower-plugin/src/dbm.rs

@@ -405,6 +405,22 @@ impl DBM {
         appointments
     }
 
+    /// Loads an appointment from the database.
+    pub fn load_appointment(&self, locator: Locator) -> Result<Appointment, Error> {
+        let mut stmt = self
+            .connection
+            .prepare("SELECT * FROM appointments WHERE locator = ?")
+            .unwrap();
+
+        stmt.query_row(params![locator.to_vec()], |row| {
+            let encrypted_blob = row.get::<_, Vec<u8>>(1).unwrap();
+            let to_self_delay = row.get::<_, u32>(2).unwrap();
+
+            Ok(Appointment::new(locator, encrypted_blob, to_self_delay))
+        })
+        .map_err(|_| Error::NotFound)
+    }
+
     /// Stores an appointment into the database.
     ///
     /// Appointments are only stored as a whole when they are pending or invalid.
@@ -1010,7 +1026,27 @@ mod tests {
         );
     }
 
-    // `store_appointments` is implicitly tested by `store_pending_appointment` and `store_invalid_appointment`
+    #[test]
+    fn test_store_load_appointment() {
+        let mut dbm = DBM::in_memory().unwrap();
+
+        let appointment = generate_random_appointment(None);
+        let tx = dbm.get_mut_connection().transaction().unwrap();
+        DBM::store_appointment(&tx, &appointment).unwrap();
+        tx.commit().unwrap();
+
+        let loaded_appointment = dbm.load_appointment(appointment.locator);
+        assert_eq!(appointment, loaded_appointment.unwrap());
+    }
+
+    #[test]
+    fn test_store_load_appointment_inexistent() {
+        let dbm = DBM::in_memory().unwrap();
+
+        let locator = generate_random_appointment(None).locator;
+        let loaded_appointment = dbm.load_appointment(locator);
+        assert!(matches!(loaded_appointment, Err(Error::NotFound)));
+    }
 
     #[test]
     fn test_store_pending_appointment() {

watchtower-plugin/src/main.rs

@@ -281,10 +281,18 @@ async fn retry_tower(
             ));
         }
 
-        state
-            .unreachable_towers
-            .send(tower_id)
-            .map_err(|e| anyhow!(e))?;
+        for locator in state
+            .towers
+            .get(&tower_id)
+            .unwrap()
+            .pending_appointments
+            .iter()
+        {
+            state
+                .unreachable_towers
+                .send((tower_id, *locator))
+                .map_err(|e| anyhow!(e))?;
+        }
         Ok(json!(format!("Retrying {}", tower_id)))
     } else {
         Err(anyhow!("Unknown tower {}", tower_id))
@@ -379,8 +387,10 @@ async fn on_commitment_revocation(
                             let mut state = plugin.state().lock().unwrap();
                             state.set_tower_status(tower_id, TowerStatus::TemporaryUnreachable);
                             state.add_pending_appointment(tower_id, &appointment);
-
-                            state.unreachable_towers.send(tower_id).unwrap();
+                            state
+                                .unreachable_towers
+                                .send((tower_id, appointment.locator))
+                                .unwrap();
                         }
                     }
                     AddAppointmentError::ApiError(e) => match e.error_code {
@@ -389,8 +399,10 @@ async fn on_commitment_revocation(
                             let mut state = plugin.state().lock().unwrap();
                             state.set_tower_status(tower_id, TowerStatus::SubscriptionError);
                             state.add_pending_appointment(tower_id, &appointment);
-
-                            state.unreachable_towers.send(tower_id).unwrap();
+                            state
+                                .unreachable_towers
+                                .send((tower_id, appointment.locator))
+                                .unwrap();
                         }
 
                         _ => {