Merge pull request #10054 from Turbo87/remove-sync-fns

Remove unused sync fns

Author: Turbo87

src/bin/crates-admin/delete_crate.rs

@@ -61,7 +61,7 @@ pub async fn run(opts: Opts) -> anyhow::Result<()> {
         .await
         .context("Failed to look up crate name from the database")?;
 
-    let deleted_by = User::async_find_by_login(&mut conn, &opts.deleted_by)
+    let deleted_by = User::find_by_login(&mut conn, &opts.deleted_by)
         .await
         .context("Failed to look up `--deleted-by` user from the database")?;
 

src/controllers/crate_owner_invitation.rs

@@ -110,7 +110,7 @@ async fn prepare_list(
             ListFilter::CrateName(crate_name) => {
                 // Only allow crate owners to query pending invitations for their crate.
                 let krate: Crate = Crate::by_name(&crate_name).first(conn).await?;
-                let owners = krate.async_owners(conn).await?;
+                let owners = krate.owners(conn).await?;
                 if user.rights(state, &owners).await? != Rights::Full {
                     let detail = "only crate owners can query pending invitations for their crate";
                     return Err(forbidden(detail));

src/controllers/github/secret_scanning.rs

@@ -187,7 +187,7 @@ async fn send_notification_email(
         .await
         .context("Failed to find user")?;
 
-    let Some(recipient) = user.async_email(conn).await? else {
+    let Some(recipient) = user.email(conn).await? else {
         return Err(anyhow!("No address found"));
     };
 
@@ -199,7 +199,7 @@ async fn send_notification_email(
         url: &alert.url,
     };
 
-    state.emails.async_send(&recipient, email).await?;
+    state.emails.send(&recipient, email).await?;
 
     Ok(())
 }

src/controllers/krate/owners.rs

@@ -30,7 +30,7 @@ pub async fn owners(state: AppState, Path(crate_name): Path<String>) -> AppResul
         .ok_or_else(|| crate_not_found(&crate_name))?;
 
     let owners = krate
-        .async_owners(&mut conn)
+        .owners(&mut conn)
         .await?
         .into_iter()
         .map(Owner::into)
@@ -144,7 +144,7 @@ async fn modify_owners(
                     .optional()?
                     .ok_or_else(|| crate_not_found(&crate_name))?;
 
-                let owners = krate.async_owners(conn).await?;
+                let owners = krate.owners(conn).await?;
 
                 match user.rights(&app, &owners).await? {
                     Rights::Full => {}
@@ -188,7 +188,7 @@ async fn modify_owners(
                                 ));
 
                                 if let Some(recipient) =
-                                    invitee.async_verified_email(conn).await.ok().flatten()
+                                    invitee.verified_email(conn).await.ok().flatten()
                                 {
                                     emails.push(OwnerInviteEmail {
                                         recipient_email_address: recipient,
@@ -243,7 +243,7 @@ async fn modify_owners(
     for email in emails {
         let addr = email.recipient_email_address().to_string();
 
-        if let Err(e) = app.emails.async_send(&addr, email).await {
+        if let Err(e) = app.emails.send(&addr, email).await {
             warn!("Failed to send co-owner invite email: {e}");
         }
     }

src/controllers/krate/publish.rs

@@ -118,7 +118,7 @@ pub async fn publish(app: AppState, req: BytesRequest) -> AppResult<Json<GoodCra
         .check(&req, &mut conn)
         .await?;
 
-    let verified_email_address = auth.user().async_verified_email(&mut conn).await?;
+    let verified_email_address = auth.user().verified_email(&mut conn).await?;
     let verified_email_address = verified_email_address.ok_or_else(|| {
         bad_request(format!(
             "A verified email address is required to publish crates to crates.io. \
@@ -349,7 +349,7 @@ pub async fn publish(app: AppState, req: BytesRequest) -> AppResult<Json<GoodCra
             None => persist.update(conn).await?,
         };
 
-        let owners = krate.async_owners(conn).await?;
+        let owners = krate.owners(conn).await?;
         if user.rights(&app, &owners).await? < Rights::Publish {
             return Err(custom(StatusCode::FORBIDDEN, MISSING_RIGHTS_ERROR_MESSAGE));
         }

src/controllers/token.rs

@@ -132,7 +132,7 @@ pub async fn new(
         .transpose()
         .map_err(|_err| bad_request("invalid endpoint scope"))?;
 
-    let recipient = user.async_email(&mut conn).await?;
+    let recipient = user.email(&mut conn).await?;
 
     let api_token = ApiToken::insert_with_scopes(
         &mut conn,
@@ -154,7 +154,7 @@ pub async fn new(
         // At this point the token has been created so failing to send the
         // email should not cause an error response to be returned to the
         // caller.
-        let email_ret = app.emails.async_send(&recipient, email).await;
+        let email_ret = app.emails.send(&recipient, email).await;
         if let Err(e) = email_ret {
             error!("Failed to send token creation email: {e}")
         }

src/controllers/user/resend.rs

@@ -45,7 +45,7 @@ pub async fn regenerate_token_and_send(
 
             state
                 .emails
-                .async_send(&email.email, email1)
+                .send(&email.email, email1)
                 .await
                 .map_err(BoxedAppError::from)
         }

src/controllers/user/update.rs

@@ -50,15 +50,15 @@ pub async fn update_user(
                 .await?;
 
             if !publish_notifications {
-                let email_address = user.async_verified_email(&mut conn).await?;
+                let email_address = user.verified_email(&mut conn).await?;
 
                 if let Some(email_address) = email_address {
                     let email = PublishNotificationsUnsubscribeEmail {
                         user_name: &user.gh_login,
                         domain: &state.emails.domain,
                     };
 
-                    if let Err(error) = state.emails.async_send(&email_address, email).await {
+                    if let Err(error) = state.emails.send(&email_address, email).await {
                         warn!("Failed to send publish notifications unsubscribe email to {email_address}: {error}");
                     }
                 }
@@ -103,7 +103,7 @@ pub async fn update_user(
             token,
         };
 
-        let _ = state.emails.async_send(user_email, email).await;
+        let _ = state.emails.send(user_email, email).await;
     }
 
     ok_true()

src/controllers/version/metadata.rs

@@ -186,7 +186,7 @@ pub async fn perform_version_yank_update(
 
     let api_token_id = auth.api_token_id();
     let user = auth.user();
-    let owners = krate.async_owners(conn).await?;
+    let owners = krate.owners(conn).await?;
 
     let yanked = yanked.unwrap_or(version.yanked);
 

src/email.rs

@@ -10,7 +10,6 @@ use lettre::transport::stub::AsyncStubTransport;
 use lettre::{Address, AsyncTransport, Message, Tokio1Executor};
 use rand::distributions::{Alphanumeric, DistString};
 use std::sync::Arc;
-use tokio::runtime::Handle;
 
 pub trait Email {
     fn subject(&self) -> String;
@@ -115,15 +114,7 @@ impl Emails {
         Ok(message)
     }
 
-    pub fn send<E: Email>(&self, recipient: &str, email: E) -> Result<(), EmailError> {
-        let email = self.build_message(recipient, email)?;
-
-        Handle::current()
-            .block_on(self.backend.send(email))
-            .map_err(EmailError::TransportError)
-    }
-
-    pub async fn async_send<E: Email>(&self, recipient: &str, email: E) -> Result<(), EmailError> {
+    pub async fn send<E: Email>(&self, recipient: &str, email: E) -> Result<(), EmailError> {
         let email = self.build_message(recipient, email)?;
 
         self.backend
@@ -195,14 +186,14 @@ mod tests {
         let emails = Emails::new_in_memory();
 
         let address = "String.Format(\"{0}.{1}@live.com\", FirstName, LastName)";
-        assert_err!(emails.async_send(address, TestEmail).await);
+        assert_err!(emails.send(address, TestEmail).await);
     }
 
     #[tokio::test]
     async fn sending_to_valid_email_succeeds() {
         let emails = Emails::new_in_memory();
 
         let address = "[email protected]";
-        assert_ok!(emails.async_send(address, TestEmail).await);
+        assert_ok!(emails.send(address, TestEmail).await);
     }
 }