Upgrade to diesel 2.0 release candidate

Author: jtgeibel

Cargo.lock

@@ -43,9 +43,9 @@ cookie = { version = "=0.16.0", features = ["secure"] }
 dashmap = { version = "=5.3.4", features = ["raw-api"] }
 derive_deref = "=1.1.1"
 dialoguer = "=0.10.1"
-diesel = { version = "=1.4.8", features = ["postgres", "serde_json", "chrono", "r2d2"] }
-diesel_full_text_search = "=1.0.1"
-diesel_migrations = { version = "=1.4.0", features = ["postgres"] }
+diesel = { version = "2.0.0-rc.0", features = ["postgres", "serde_json", "chrono", "r2d2"] }
+diesel_full_text_search = { version = "2.0.0-rc.0", git = "https://github.com/Emulator000/diesel_full_text_search", rev = "06b3505a3c4fcdd931410c24f945d87f860cdfd6" }
+diesel_migrations = { version = "2.0.0-rc.0", features = ["postgres"] }
 dotenv = "=0.15.0"
 flate2 = "=1.0.24"
 futures-channel = { version = "=0.3.21", default-features = false }
@@ -74,7 +74,7 @@ serde = { version = "=1.0.137", features = ["derive"] }
 serde_json = "=1.0.81"
 sha2 = "=0.10.2"
 spdx = "=0.8.1"
-swirl = { git = "https://github.com/sgrif/swirl.git", rev = "e87cf37" }
+swirl = { git = "https://github.com/jtgeibel/swirl", branch = "diesel2" }
 tar = "=0.4.38"
 tempfile = "=3.3.0"
 thiserror = "=1.0.31"
@@ -94,6 +94,6 @@ tokio = "=1.19.2"
 tower-service = "=0.3.1"
 
 [build-dependencies]
-diesel = { version = "=1.4.8", features = ["postgres"] }
-diesel_migrations = { version = "=1.4.0", features = ["postgres"] }
+diesel = { version = "2.0.0-rc.0", features = ["postgres"] }
+diesel_migrations = { version = "2.0.0-rc.0", features = ["postgres"] }
 dotenv = "=0.15.0"

Cargo.toml

@@ -1,5 +1,5 @@
 use diesel::prelude::*;
-use diesel_migrations::run_pending_migrations;
+use diesel_migrations::{FileBasedMigrations, MigrationHarness};
 use std::env;
 
 fn main() {
@@ -8,9 +8,13 @@ fn main() {
     println!("cargo:rerun-if-changed=migrations/");
     if env::var("PROFILE") == Ok("debug".into()) {
         if let Ok(database_url) = dotenv::var("TEST_DATABASE_URL") {
-            let connection = PgConnection::establish(&database_url)
+            let connection = &mut PgConnection::establish(&database_url)
                 .expect("Could not connect to TEST_DATABASE_URL");
-            run_pending_migrations(&connection).expect("Error running migrations");
+            let migrations = FileBasedMigrations::find_migrations_directory()
+                .expect("Could not find migrations");
+            connection
+                .run_pending_migrations(migrations)
+                .expect("Error running migrations");
         }
     }
 }

build.rs

@@ -19,15 +19,15 @@ pub struct Opts {
 }
 
 pub fn run(opts: Opts) {
-    let conn = db::oneoff_connection().unwrap();
-    conn.transaction::<_, diesel::result::Error, _>(|| {
-        delete(opts, &conn);
+    let conn = &mut db::oneoff_connection().unwrap();
+    conn.transaction::<_, diesel::result::Error, _>(|conn| {
+        delete(opts, conn);
         Ok(())
     })
     .unwrap()
 }
 
-fn delete(opts: Opts, conn: &PgConnection) {
+fn delete(opts: Opts, conn: &mut PgConnection) {
     let krate: Crate = Crate::by_name(&opts.crate_name).first(conn).unwrap();
 
     let config = config::Base::from_environment();

src/admin/delete_crate.rs

@@ -24,15 +24,15 @@ pub struct Opts {
 }
 
 pub fn run(opts: Opts) {
-    let conn = db::oneoff_connection().unwrap();
-    conn.transaction::<_, diesel::result::Error, _>(|| {
-        delete(opts, &conn);
+    let conn = &mut db::oneoff_connection().unwrap();
+    conn.transaction::<_, diesel::result::Error, _>(|conn| {
+        delete(opts, conn);
         Ok(())
     })
     .unwrap()
 }
 
-fn delete(opts: Opts, conn: &PgConnection) {
+fn delete(opts: Opts, conn: &mut PgConnection) {
     let krate: Crate = Crate::by_name(&opts.crate_name).first(conn).unwrap();
     let v: Version = Version::belonging_to(&krate)
         .filter(versions::num.eq(&opts.version))

src/admin/delete_version.rs

@@ -1,7 +1,11 @@
 use anyhow::Error;
+use diesel_migrations::{
+    embed_migrations, EmbeddedMigrations, HarnessWithOutput, MigrationHarness,
+};
 
 static CATEGORIES_TOML: &str = include_str!("../boot/categories.toml");
-diesel_migrations::embed_migrations!("./migrations");
+
+pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations");
 
 #[derive(clap::Parser, Debug, Copy, Clone)]
 #[clap(
@@ -32,13 +36,16 @@ pub fn run(_opts: Opts) -> Result<(), Error> {
     }
 
     // The primary is online, access directly via `DATABASE_URL`.
-    let conn = crate::db::oneoff_connection_with_config(&config)?;
+    let conn = &mut crate::db::oneoff_connection_with_config(&config)?;
 
     println!("==> migrating the database");
-    embedded_migrations::run_with_output(&conn, &mut std::io::stdout())?;
+    // let migrations = ;
+    let mut stdout = std::io::stdout();
+    let mut harness = HarnessWithOutput::new(conn, &mut stdout);
+    harness.run_pending_migrations(MIGRATIONS);
 
     println!("==> synchronizing crate categories");
-    crate::boot::categories::sync_with_connection(CATEGORIES_TOML, &conn).unwrap();
+    crate::boot::categories::sync_with_connection(CATEGORIES_TOML, conn).unwrap();
 
     Ok(())
 }

src/admin/migrate.rs

@@ -14,11 +14,11 @@ pub struct Opts {
 }
 
 pub fn run(opts: Opts) {
-    let conn = db::oneoff_connection().unwrap();
-    conn.transaction(|| update(opts, &conn)).unwrap();
+    let mut conn = db::oneoff_connection().unwrap();
+    conn.transaction(|conn| update(opts, conn)).unwrap();
 }
 
-fn update(opts: Opts, conn: &PgConnection) -> QueryResult<()> {
+fn update(opts: Opts, conn: &mut PgConnection) -> QueryResult<()> {
     use diesel::dsl::*;
 
     for id in opts.version_ids {

src/admin/populate.rs

@@ -9,7 +9,7 @@ use std::{io::Read, path::Path, sync::Arc, thread};
 
 use cargo_registry_markdown::text_to_html;
 use chrono::{TimeZone, Utc};
-use diesel::{dsl::any, prelude::*};
+use diesel::prelude::*;
 use flate2::read::GzDecoder;
 use reqwest::{blocking::Client, header};
 use tar::{self, Archive};
@@ -39,7 +39,7 @@ pub struct Opts {
 
 pub fn run(opts: Opts) -> anyhow::Result<()> {
     let base_config = Arc::new(config::Base::from_environment());
-    let conn = db::oneoff_connection().unwrap();
+    let conn = &mut db::oneoff_connection().unwrap();
 
     let start_time = Utc::now();
 
@@ -70,7 +70,7 @@ pub fn run(opts: Opts) -> anyhow::Result<()> {
         query = query.filter(crates::name.eq(crate_name));
     }
 
-    let version_ids: Vec<i32> = query.load(&conn).expect("error loading version ids");
+    let version_ids: Vec<i32> = query.load(conn).expect("error loading version ids");
 
     let total_versions = version_ids.len();
     println!("Rendering {total_versions} versions");
@@ -95,14 +95,14 @@ pub fn run(opts: Opts) -> anyhow::Result<()> {
 
         let versions: Vec<(Version, String)> = versions::table
             .inner_join(crates::table)
-            .filter(versions::id.eq(any(version_ids_chunk)))
+            .filter(versions::id.eq_any(version_ids_chunk))
             .select((versions::all_columns, crates::name))
-            .load(&conn)
+            .load(conn)
             .expect("error loading versions");
 
         let mut tasks = Vec::with_capacity(page_size as usize);
         for (version, krate_name) in versions {
-            Version::record_readme_rendering(version.id, &conn)
+            Version::record_readme_rendering(version.id, conn)
                 .context("Couldn't record rendering time")?;
 
             let client = client.clone();

src/admin/render_readmes.rs

@@ -21,15 +21,15 @@ pub struct Opts {
 }
 
 pub fn run(opts: Opts) {
-    let conn = db::oneoff_connection().unwrap();
-    conn.transaction::<_, diesel::result::Error, _>(|| {
-        transfer(opts, &conn);
+    let conn = &mut db::oneoff_connection().unwrap();
+    conn.transaction::<_, diesel::result::Error, _>(|conn| {
+        transfer(opts, conn);
         Ok(())
     })
     .unwrap()
 }
 
-fn transfer(opts: Opts, conn: &PgConnection) {
+fn transfer(opts: Opts, conn: &mut PgConnection) {
     let from: User = users::table
         .filter(users::gh_login.eq(opts.from_user))
         .first(conn)

src/admin/transfer_crates.rs

@@ -13,8 +13,8 @@ pub struct Opts {
 }
 
 pub fn run(opts: Opts) -> AppResult<()> {
-    let conn = db::oneoff_connection()?;
-    let user = User::find_by_api_token(&conn, &opts.api_token)?;
+    let conn = &mut db::oneoff_connection()?;
+    let user = User::find_by_api_token(conn, &opts.api_token)?;
     println!("The token belongs to user {}", user.gh_login);
     Ok(())
 }

src/admin/verify_token.rs

@@ -18,25 +18,25 @@ fn main() -> Result<()> {
             let count: i64 = background_jobs
                 .filter(job_type.eq("update_downloads"))
                 .count()
-                .get_result(&conn)
+                .get_result(conn)
                 .unwrap();
 
             if count > 0 {
                 println!("Did not enqueue update_downloads, existing job already in progress");
                 Ok(())
             } else {
-                Ok(worker::update_downloads().enqueue(&conn)?)
+                Ok(worker::update_downloads().enqueue(conn)?)
             }
         }
         "dump_db" => {
             let database_url = args.next().unwrap_or_else(|| env("READ_ONLY_REPLICA_URL"));
             let target_name = args
                 .next()
                 .unwrap_or_else(|| String::from("db-dump.tar.gz"));
-            Ok(worker::dump_db(database_url, target_name).enqueue(&conn)?)
+            Ok(worker::dump_db(database_url, target_name).enqueue(conn)?)
         }
-        "daily_db_maintenance" => Ok(worker::daily_db_maintenance().enqueue(&conn)?),
-        "squash_index" => Ok(worker::squash_index().enqueue(&conn)?),
+        "daily_db_maintenance" => Ok(worker::daily_db_maintenance().enqueue(conn)?),
+        "squash_index" => Ok(worker::squash_index().enqueue(conn)?),
         other => Err(anyhow!("Unrecognized job type `{}`", other)),
     }
 }

src/bin/enqueue-job.rs

@@ -13,9 +13,9 @@ use diesel::prelude::*;
 fn main() -> Result<()> {
     let conn = db::oneoff_connection()?;
 
-    check_failing_background_jobs(&conn)?;
-    check_stalled_update_downloads(&conn)?;
-    check_spam_attack(&conn)?;
+    check_failing_background_jobs(conn)?;
+    check_stalled_update_downloads(conn)?;
+    check_spam_attack(conn)?;
     Ok(())
 }
 
@@ -27,7 +27,7 @@ fn main() -> Result<()> {
 ///
 /// Within the default 15 minute time, a job should have already had several
 /// failed retry attempts.
-fn check_failing_background_jobs(conn: &PgConnection) -> Result<()> {
+fn check_failing_background_jobs(conn: &mut PgConnection) -> Result<()> {
     use cargo_registry::schema::background_jobs::dsl::*;
     use diesel::dsl::*;
     use diesel::sql_types::Integer;
@@ -69,7 +69,7 @@ fn check_failing_background_jobs(conn: &PgConnection) -> Result<()> {
 }
 
 /// Check for an `update_downloads` job that has run longer than expected
-fn check_stalled_update_downloads(conn: &PgConnection) -> Result<()> {
+fn check_stalled_update_downloads(conn: &mut PgConnection) -> Result<()> {
     use cargo_registry::schema::background_jobs::dsl::*;
     use chrono::{DateTime, NaiveDateTime, Utc};
 
@@ -106,7 +106,7 @@ fn check_stalled_update_downloads(conn: &PgConnection) -> Result<()> {
 }
 
 /// Check for known spam patterns
-fn check_spam_attack(conn: &PgConnection) -> Result<()> {
+fn check_spam_attack(conn: &mut PgConnection) -> Result<()> {
     use cargo_registry::sql::canon_crate_name;
     use diesel::dsl::*;