models/version: Convert record_readme_rendering() to async fn (#9871)

... which allows us to remove a `spawn_blocking()` call from the `RenderAndUploadReadme` background job :)

Author: Turbo87

src/bin/crates-admin/render_readmes.rs

@@ -115,7 +115,8 @@ pub async fn run(opts: Opts) -> anyhow::Result<()> {
 
             let mut tasks = Vec::with_capacity(page_size);
             for (version, krate_name) in versions {
-                Version::record_readme_rendering(version.id, &mut conn)
+                Handle::current()
+                    .block_on(Version::record_readme_rendering(version.id, &mut conn))
                     .context("Couldn't record rendering time")?;
 
                 let client = client.clone();

src/models/version.rs

@@ -3,6 +3,7 @@ use std::collections::BTreeMap;
 use bon::Builder;
 use chrono::NaiveDateTime;
 use crates_io_index::features::FeaturesMap;
+use diesel_async::AsyncPgConnection;
 use serde::Deserialize;
 
 use crate::models::{Crate, User};
@@ -35,16 +36,20 @@ pub struct Version {
 }
 
 impl Version {
-    pub fn record_readme_rendering(version_id: i32, conn: &mut impl Conn) -> QueryResult<usize> {
+    pub async fn record_readme_rendering(
+        version_id: i32,
+        conn: &mut AsyncPgConnection,
+    ) -> QueryResult<usize> {
         use diesel::dsl::now;
-        use diesel::RunQueryDsl;
+        use diesel_async::RunQueryDsl;
 
         diesel::insert_into(readme_renderings::table)
             .values(readme_renderings::version_id.eq(version_id))
             .on_conflict(readme_renderings::version_id)
             .do_update()
             .set(readme_renderings::rendered_at.eq(now))
             .execute(conn)
+            .await
     }
 
     /// Gets the User who ran `cargo publish` for this version, if recorded.

src/tests/version.rs

@@ -11,6 +11,11 @@ async fn record_rerendered_readme_time() {
     let c = CrateBuilder::new("foo_authors", user.id).expect_build(&mut conn);
     let version = VersionBuilder::new("1.0.0").expect_build(c.id, user.id, &mut conn);
 
-    Version::record_readme_rendering(version.id, &mut conn).unwrap();
-    Version::record_readme_rendering(version.id, &mut conn).unwrap();
+    let mut conn = app.async_db_conn().await;
+    Version::record_readme_rendering(version.id, &mut conn)
+        .await
+        .unwrap();
+    Version::record_readme_rendering(version.id, &mut conn)
+        .await
+        .unwrap();
 }

src/worker/jobs/readmes.rs

@@ -5,9 +5,9 @@ use crate::tasks::spawn_blocking;
 use crate::worker::Environment;
 use crates_io_markdown::text_to_html;
 use crates_io_worker::BackgroundJob;
-use diesel_async::async_connection_wrapper::AsyncConnectionWrapper;
+use diesel_async::scoped_futures::ScopedFutureExt;
+use diesel_async::AsyncConnection;
 use std::sync::Arc;
-use tokio::runtime::Handle;
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct RenderAndUploadReadme {
@@ -46,6 +46,7 @@ impl BackgroundJob for RenderAndUploadReadme {
     async fn run(&self, env: Self::Context) -> anyhow::Result<()> {
         use crate::schema::*;
         use diesel::prelude::*;
+        use diesel_async::RunQueryDsl;
 
         info!(version_id = ?self.version_id, "Rendering README");
 
@@ -64,26 +65,25 @@ impl BackgroundJob for RenderAndUploadReadme {
             return Ok(());
         }
 
-        let conn = env.deadpool.get().await?;
-        spawn_blocking(move || {
-            let conn: &mut AsyncConnectionWrapper<_> = &mut conn.into();
-
-            conn.transaction(|conn| {
-                Version::record_readme_rendering(job.version_id, conn)?;
+        let mut conn = env.deadpool.get().await?;
+        conn.transaction(|conn| {
+            async move {
+                Version::record_readme_rendering(job.version_id, conn).await?;
                 let (crate_name, vers): (String, String) = versions::table
                     .find(job.version_id)
                     .inner_join(crates::table)
                     .select((crates::name, versions::num))
-                    .first(conn)?;
+                    .first(conn)
+                    .await?;
 
                 tracing::Span::current().record("krate.name", tracing::field::display(&crate_name));
 
                 let bytes = rendered.into();
-                let future = env.storage.upload_readme(&crate_name, &vers, bytes);
-                Handle::current().block_on(future)?;
+                env.storage.upload_readme(&crate_name, &vers, bytes).await?;
 
                 Ok(())
-            })
+            }
+            .scope_boxed()
         })
         .await
     }