editoast: async use deadpool instead of bb8

Author: Tristramg

editoast/Cargo.lock

@@ -22,7 +22,7 @@ diesel = { version = "2.1", features = [
     "chrono",
     "uuid",
 ] }
-diesel-async = { version = "0.3.1", features = ["postgres", "bb8"] }
+diesel-async = { version = "0.3.1", features = ["postgres", "deadpool"] }
 diesel_json = "0.2.1"
 image = "0.24"
 json-patch = "1.0"

editoast/Cargo.toml

@@ -21,7 +21,7 @@ pub struct PostgresConfig {
     pub psql_port: u16,
     #[derivative(Default(value = "32"))]
     #[arg(long, env, default_value_t = 32)]
-    pub pool_size: u32,
+    pub pool_size: usize,
 }
 
 impl PostgresConfig {

editoast/src/client/postgres_config.rs

@@ -118,14 +118,14 @@ impl EditoastError for JsonPayloadError {
     }
 }
 
-/// Handle bb8 errors
-impl EditoastError for diesel_async::pooled_connection::bb8::RunError {
+/// Handle database pool errors
+impl EditoastError for diesel_async::pooled_connection::deadpool::PoolError {
     fn get_status(&self) -> StatusCode {
         StatusCode::INTERNAL_SERVER_ERROR
     }
 
     fn get_type(&self) -> &'static str {
-        "editoast:BB8Error"
+        "editoast:DatabePoolError"
     }
 }
 

editoast/src/error.rs

@@ -20,14 +20,20 @@ pub mod tests {
     use postgis_diesel::types::LineString;
     use rstest::*;
     use serde_json::json;
+    use std::fmt;
 
-    #[derive(Debug)]
     pub struct TestFixture<T: Delete + Identifiable + Send> {
         pub model: T,
         pub db_pool: Data<DbPool>,
         pub infra: Option<Infra>,
     }
 
+    impl<T: fmt::Debug + Delete + Identifiable + Send> fmt::Debug for TestFixture<T> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(f, "Fixture {:?} {:?}", self.model, self.infra)
+        }
+    }
+
     impl<T: Delete + Identifiable + Send> TestFixture<T> {
         pub fn id(&self) -> i64 {
             self.model.get_id()
@@ -62,52 +68,47 @@ pub mod tests {
     }
 
     #[fixture]
-    pub async fn db_pool() -> Data<DbPool> {
+    pub fn db_pool() -> Data<DbPool> {
         let url = PostgresConfig::default().url();
         let config = AsyncDieselConnectionManager::<diesel_async::AsyncPgConnection>::new(url);
-        let pool = DbPool::builder().build(config).await.unwrap();
+        let pool = DbPool::builder(config).build().unwrap();
         Data::new(pool)
     }
 
     #[fixture]
-    pub async fn fast_rolling_stock(
-        #[future] db_pool: Data<DbPool>,
-    ) -> TestFixture<RollingStockModel> {
+    pub async fn fast_rolling_stock(db_pool: Data<DbPool>) -> TestFixture<RollingStockModel> {
         TestFixture::create(
             serde_json::from_str::<RollingStockModel>(include_str!(
                 "./tests/example_rolling_stock_1.json"
             ))
             .expect("Unable to parse"),
-            db_pool.await,
+            db_pool,
         )
         .await
     }
 
     #[fixture]
-    pub async fn other_rolling_stock(
-        #[future] db_pool: Data<DbPool>,
-    ) -> TestFixture<RollingStockModel> {
+    pub async fn other_rolling_stock(db_pool: Data<DbPool>) -> TestFixture<RollingStockModel> {
         TestFixture::create(
             serde_json::from_str::<RollingStockModel>(include_str!(
                 "./tests/example_rolling_stock_2_energy_sources.json"
             ))
             .expect("Unable to parse"),
-            db_pool.await,
+            db_pool,
         )
         .await
     }
 
     #[fixture]
     pub async fn train_schedule(
-        #[future] db_pool: Data<DbPool>,
+        db_pool: Data<DbPool>,
         #[future] pathfinding: TestFixture<Pathfinding>,
         #[future] timetable: TestFixture<Timetable>,
         #[future] fast_rolling_stock: TestFixture<RollingStockModel>,
     ) -> TestFixture<TrainSchedule> {
         let pathfinding = pathfinding.await;
         let timetable = timetable.await;
         let rolling_stock = fast_rolling_stock.await;
-        let db_pool = db_pool.await;
         let train_schedule = make_train_schedule(
             db_pool.clone(),
             pathfinding.id(),
@@ -159,14 +160,13 @@ pub mod tests {
         let pathfinding = pathfinding(db_pool()).await;
         let rolling_stock = fast_rolling_stock(db_pool()).await;
         let ts_model = make_train_schedule(
-            db_pool().await,
+            db_pool(),
             pathfinding.id(),
             timetable.id(),
             rolling_stock.id(),
         )
         .await;
-        let train_schedule: TestFixture<TrainSchedule> =
-            TestFixture::new(ts_model, db_pool().await);
+        let train_schedule: TestFixture<TrainSchedule> = TestFixture::new(ts_model, db_pool());
         TrainScheduleFixtureSet {
             train_schedule,
             project,
@@ -201,7 +201,7 @@ pub mod tests {
             creation_date: Some(Utc::now().naive_utc()),
             ..Scenario::default()
         };
-        let scenario = TestFixture::create(scenario_model, db_pool().await).await;
+        let scenario = TestFixture::create(scenario_model, db_pool()).await;
         ScenarioFixtureSet {
             project,
             study,
@@ -218,7 +218,7 @@ pub mod tests {
 
     #[fixture]
     pub async fn study_fixture_set(
-        #[future] db_pool: Data<DbPool>,
+        db_pool: Data<DbPool>,
         #[future] project: TestFixture<Project>,
     ) -> StudyFixtureSet {
         let project = project.await;
@@ -237,12 +237,12 @@ pub mod tests {
         };
         StudyFixtureSet {
             project,
-            study: TestFixture::create(study_model, db_pool.await).await,
+            study: TestFixture::create(study_model, db_pool).await,
         }
     }
 
     #[fixture]
-    pub async fn project(#[future] db_pool: Data<DbPool>) -> TestFixture<Project> {
+    pub async fn project(db_pool: Data<DbPool>) -> TestFixture<Project> {
         let project_model = Project {
             name: Some("test_project".into()),
             objectives: Some("".into()),
@@ -253,20 +253,20 @@ pub mod tests {
             creation_date: Some(Utc::now().naive_utc()),
             ..Default::default()
         };
-        TestFixture::create(project_model, db_pool.await).await
+        TestFixture::create(project_model, db_pool).await
     }
 
     #[fixture]
-    pub async fn timetable(#[future] db_pool: Data<DbPool>) -> TestFixture<Timetable> {
+    pub async fn timetable(db_pool: Data<DbPool>) -> TestFixture<Timetable> {
         let timetable_model = Timetable {
             id: None,
             name: Some(String::from("with_electrical_profiles")),
         };
-        TestFixture::create(timetable_model, db_pool.await).await
+        TestFixture::create(timetable_model, db_pool).await
     }
 
     #[fixture]
-    pub async fn document_example(#[future] db_pool: Data<DbPool>) -> TestFixture<Document> {
+    pub async fn document_example(db_pool: Data<DbPool>) -> TestFixture<Document> {
         let img = image::open("src/tests/example_rolling_stock_image_1.gif").unwrap();
         let mut img_bytes: Vec<u8> = Vec::new();
         assert!(img
@@ -275,16 +275,12 @@ pub mod tests {
                 image::ImageOutputFormat::Png
             )
             .is_ok());
-        TestFixture::create(
-            Document::new(String::from("image/png"), img_bytes),
-            db_pool.await,
-        )
-        .await
+        TestFixture::create(Document::new(String::from("image/png"), img_bytes), db_pool).await
     }
 
     #[fixture]
     pub async fn rolling_stock_livery(
-        #[future] db_pool: Data<DbPool>,
+        db_pool: Data<DbPool>,
         #[future] fast_rolling_stock: TestFixture<RollingStockModel>,
         #[future] document_example: TestFixture<Document>,
     ) -> TestFixture<RollingStockLiveryModel> {
@@ -296,29 +292,29 @@ pub mod tests {
             rolling_stock_id: Some(rolling_stock.id()),
             compound_image_id: Some(Some(image.id())),
         };
-        TestFixture::create(rolling_stock_livery, db_pool.await).await
+        TestFixture::create(rolling_stock_livery, db_pool).await
     }
 
     #[fixture]
     pub async fn electrical_profile_set(
-        #[future] db_pool: Data<DbPool>,
+        db_pool: Data<DbPool>,
     ) -> TestFixture<ElectricalProfileSet> {
         TestFixture::create(
             serde_json::from_str::<ElectricalProfileSet>(include_str!(
                 "./tests/electrical_profile_set.json"
             ))
             .expect("Unable to parse"),
-            db_pool.await,
+            db_pool,
         )
         .await
     }
 
     #[fixture]
-    pub async fn empty_infra(#[future] db_pool: Data<DbPool>) -> TestFixture<Infra> {
+    pub async fn empty_infra(db_pool: Data<DbPool>) -> TestFixture<Infra> {
         let infra_form = InfraForm {
             name: String::from("test_infra"),
         };
-        TestFixture::create(Infra::from(infra_form), db_pool.await).await
+        TestFixture::create(Infra::from(infra_form), db_pool).await
     }
 
     async fn make_small_infra(db_pool: Data<DbPool>) -> Infra {
@@ -341,14 +337,12 @@ pub mod tests {
     /// is made, the `editoast/tests/small_infra/small_infra.json` file should be updated
     /// to the latest infra description.
     #[fixture]
-    pub async fn small_infra(#[future] db_pool: Data<DbPool>) -> TestFixture<Infra> {
-        let db_pool = db_pool.await;
+    pub async fn small_infra(db_pool: Data<DbPool>) -> TestFixture<Infra> {
         TestFixture::new(make_small_infra(db_pool.clone()).await, db_pool)
     }
 
     #[fixture]
-    pub async fn pathfinding(#[future] db_pool: Data<DbPool>) -> TestFixture<Pathfinding> {
-        let db_pool = db_pool.await;
+    pub async fn pathfinding(db_pool: Data<DbPool>) -> TestFixture<Pathfinding> {
         let small_infra = make_small_infra(db_pool.clone()).await;
         let pf_cs = PathfindingChangeset {
             infra_id: small_infra.id,
@@ -400,11 +394,10 @@ pub mod tests {
             timetable,
             infra,
         } = scenario_fixture_set().await;
-        let pathfinding = pathfinding.await;
-        let rolling_stock = fast_rolling_stock.await;
-        let db_pool = db_pool.await;
+        let rolling_stock = fast_rolling_stock(db_pool()).await;
+        let pathfinding = pathfinding(db_pool()).await;
         let train_schedule = make_train_schedule(
-            db_pool.clone(),
+            db_pool().clone(),
             pathfinding.id(),
             timetable.id(),
             rolling_stock.id(),
@@ -443,13 +436,13 @@ pub mod tests {
             ..Default::default()
         };
         let simulation_output: SimulationOutput = simulation_output
-            .create(db_pool.clone())
+            .create(db_pool().clone())
             .await
             .unwrap()
             .into();
 
-        let train_schedule = TestFixture::new(train_schedule, db_pool.clone());
-        let simulation_output = TestFixture::new(simulation_output, db_pool);
+        let train_schedule = TestFixture::new(train_schedule, db_pool().clone());
+        let simulation_output = TestFixture::new(simulation_output, db_pool());
         TrainScheduleWithSimulationOutputFixtureSet {
             project,
             study,