Merge pull request 'Reverse subscription flow' (#2) from reverse_subscription_flow into main

Reviewed-on: #2

src/routes.rs

@@ -179,23 +179,32 @@ pub async fn subscribe_form(
         };
         let peer_info = Peer::new(&peer.public_key).set_name(&peer_name);
 
-        // Add the peer to the database and then check the follow state.
         // Follow the peer if our local instance is not already following.
-        if db.add_peer(peer_info).is_ok() {
+        match sbot::follow_if_not_following(&peer.public_key).await {
-            info!("Added {} to 'peers' database tree", &peer.public_key);
+            Ok(_) => {
-            sbot::follow_if_not_following(&peer.public_key).await;
+                // Add the peer to the database.
+                if db.add_peer(peer_info).is_ok() {
+                    info!("Added {} to 'peers' database tree", &peer.public_key);
+                    let peer_id = peer.public_key.to_string();
 
-            let peer_id = peer.public_key.to_string();
+                    // Fetch all root posts authored by the peer we're subscribing
-            // Fetch all root posts authored by the peer we're subscribing
+                    // to. Posts will be added to the key-value database.
-            // to. Posts will be added to the key-value database.
+                    if let Err(e) = tx.send(Task::FetchAllPosts(peer_id)).await {
-            if let Err(e) = tx.send(Task::FetchAllPosts(peer_id)).await {
+                        warn!("Task loop error: {}", e)
-                warn!("Task loop error: {}", e)
+                    }
+                } else {
+                    let err_msg = format!(
+                        "Failed to add peer {} to 'peers' database tree",
+                        &peer.public_key
+                    );
+                    warn!("{}", err_msg);
+                    return Err(Flash::error(Redirect::to(uri!(home)), err_msg));
+                }
+            }
+            Err(e) => {
+                warn!("{}", e);
+                return Err(Flash::error(Redirect::to(uri!(home)), e));
             }
-        } else {
-            warn!(
-                "Failed to add peer {} to 'peers' database tree",
-                &peer.public_key
-            )
         }
     }
 
@@ -215,17 +224,24 @@ pub async fn unsubscribe_form(
         return Err(Flash::error(Redirect::to(uri!(home)), err_msg));
     } else {
         info!("Public key {} is valid", &peer.public_key);
-        if db.remove_peer(&peer.public_key).is_ok() {
+        match sbot::unfollow_if_following(&peer.public_key).await {
-            info!(
+            Ok(_) => {
-                "Removed peer {} from 'peers' database tree",
+                if db.remove_peer(&peer.public_key).is_ok() {
-                &peer.public_key
+                    info!(
-            );
+                        "Removed peer {} from 'peers' database tree",
-            sbot::unfollow_if_following(&peer.public_key).await;
+                        &peer.public_key
-        } else {
+                    );
-            warn!(
+                } else {
-                "Failed to remove peer {} from 'peers' database tree",
+                    warn!(
-                &peer.public_key
+                        "Failed to remove peer {} from 'peers' database tree",
-            );
+                        &peer.public_key
+                    );
+                }
+            }
+            Err(e) => {
+                warn!("{}", e);
+                return Err(Flash::error(Redirect::to(uri!(home)), e));
+            }
         }
     }
 

src/sbot.rs

@@ -17,31 +17,44 @@ use crate::{db::Post, sbot};
 
 /// Check the follow status of a remote peer and follow them if not already
 /// following.
-pub async fn follow_if_not_following(remote_peer: &str) {
+pub async fn follow_if_not_following(remote_peer: &str) -> Result<(), String> {
     if let Ok(whoami) = sbot::whoami().await {
         match sbot::is_following(&whoami, remote_peer).await {
             Ok(status) if status.as_str() == "false" => {
                 match sbot::follow_peer(remote_peer).await {
-                    Ok(_) => info!("Followed peer {}", &remote_peer),
+                    Ok(_) => {
-                    Err(e) => warn!("Failed to follow peer {}: {}", &remote_peer, e),
+                        info!("Followed peer {}", &remote_peer);
+                        Ok(())
+                    }
+                    Err(e) => {
+                        let err_msg = format!("Failed to follow peer {}: {}", &remote_peer, e);
+                        warn!("{}", err_msg);
+                        Err(err_msg)
+                    }
                 }
             }
             Ok(status) if status.as_str() == "true" => {
                 info!(
                     "Already following peer {}. No further action taken",
                     &remote_peer
-                )
+                );
+                Ok(())
             }
-            _ => (),
+            _ => Err(
+                "Failed to determine follow status: received unrecognised response from local sbot"
+                    .to_string(),
+            ),
         }
     } else {
-        warn!("Received an error during `whoami` RPC call. Please ensure the go-sbot is running and try again")
+        let err_msg = String::from("Received an error during `whoami` RPC call. Please ensure the go-sbot is running and try again");
+        warn!("{}", err_msg);
+        Err(err_msg)
     }
 }
 
 /// Check the follow status of a remote peer and unfollow them if already
 /// following.
-pub async fn unfollow_if_following(remote_peer: &str) {
+pub async fn unfollow_if_following(remote_peer: &str) -> Result<(), String> {
     if let Ok(whoami) = sbot::whoami().await {
         match sbot::is_following(&whoami, remote_peer).await {
             Ok(status) if status.as_str() == "true" => {
@@ -49,14 +62,24 @@ pub async fn unfollow_if_following(remote_peer: &str) {
                 match sbot::unfollow_peer(remote_peer).await {
                     Ok(_) => {
                         info!("Unfollowed peer {}", &remote_peer);
+                        Ok(())
+                    }
+                    Err(e) => {
+                        let err_msg = format!("Failed to unfollow peer {}: {}", &remote_peer, e);
+                        warn!("{}", err_msg);
+                        Err(err_msg)
                     }
-                    Err(e) => warn!("Failed to unfollow peer {}: {}", &remote_peer, e),
                 }
             }
-            _ => (),
+            _ => Err(
+                "Failed to determine follow status: received unrecognised response from local sbot"
+                    .to_string(),
+            ),
         }
     } else {
-        warn!("Received an error during `whoami` RPC call. Please ensure the go-sbot is running and try again")
+        let err_msg = String::from("Received an error during `whoami` RPC call. Please ensure the go-sbot is running and try again");
+        warn!("{}", err_msg);
+        Err(err_msg)
     }
 }