switch to R2D2 pool

src/database.rs

@@ -1,16 +1,5 @@
 use diesel::pg::PgConnection;
-use diesel::prelude::*;
 use diesel::r2d2::{ConnectionManager, Pool};
-use dotenv::dotenv;
-use std::env;
-
-pub fn establish_connection() -> PgConnection {
-    dotenv().ok();
-
-    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
-    PgConnection::establish(&database_url)
-        .unwrap_or_else(|e| panic!("Error connecting to database {}: {}", database_url, e))
-}
 
 pub fn get_connection_pool(url: &str) -> Pool<ConnectionManager<PgConnection>> {
     let manager = ConnectionManager::<PgConnection>::new(url);

src/reader/add.rs

@@ -1,15 +1,22 @@
 use actix_web::{web, HttpResponse};
-use diesel::RunQueryDsl;
+use diesel::{
+    r2d2::{ConnectionManager, Pool},
+    PgConnection, RunQueryDsl,
+};
 
 use crate::{
-    database::establish_connection, json_serialization::new_feed::NewFeedSchema,
+    json_serialization::new_feed::NewFeedSchema, models::feed::new_feed::NewFeed, schema::feed,
-    models::feed::new_feed::NewFeed, schema::feed,
 };
 
 use super::feeds;
 
-pub async fn add(new_feed: web::Json<NewFeedSchema>) -> HttpResponse {
+pub async fn add(
-    let mut connection = establish_connection();
+    new_feed: web::Json<NewFeedSchema>,
+    pool: web::Data<Pool<ConnectionManager<PgConnection>>>,
+) -> HttpResponse {
+    let pool_arc = pool.get_ref().clone();
+    let mut connection = pool_arc.get().expect("Failed to get database connection");
+
     let title: String = new_feed.title.clone();
     let url: String = new_feed.url.clone();
     let user_id: i32 = new_feed.user_id;

src/reader/mark_read.rs

@@ -1,14 +1,21 @@
 use crate::schema::feed_item::{id, read};
 use crate::{
-    database::establish_connection, json_serialization::read_feed_item::ReadItem,
+    json_serialization::read_feed_item::ReadItem, models::feed_item::rss_feed_item::FeedItem,
-    models::feed_item::rss_feed_item::FeedItem, schema::feed_item,
+    schema::feed_item,
 };
 use actix_web::{web, HttpRequest, HttpResponse, Responder};
-use diesel::RunQueryDsl;
+use diesel::r2d2::{ConnectionManager, Pool};
 use diesel::{ExpressionMethods, QueryDsl};
+use diesel::{PgConnection, RunQueryDsl};
+
+pub async fn mark_read(
+    _req: HttpRequest,
+    path: web::Path<ReadItem>,
+    pool: web::Data<Pool<ConnectionManager<PgConnection>>>,
+) -> impl Responder {
+    let pool_arc = pool.get_ref().clone();
+    let mut connection = pool_arc.get().expect("Failed to get database connection");
 
-pub async fn mark_read(_req: HttpRequest, path: web::Path<ReadItem>) -> impl Responder {
-    let mut connection = establish_connection();
     log::info!("Id: {}", path.id);
     let feed_items: Vec<FeedItem> = feed_item::table
         .filter(id.eq(path.id))

src/reader/sync.rs

@@ -4,17 +4,15 @@ use crate::models::feed::rss_feed::Feed;
 use crate::models::feed_item::new_feed_item::NewFeedItem;
 use crate::models::feed_item::rss_feed_item::FeedItem;
 use crate::schema::feed_item::{feed_id, title};
-use crate::{
+use crate::schema::{
-    database::establish_connection,
-    schema::{
     feed::{self, user_id},
     feed_item,
-    },
 };
 use actix_web::{web, HttpRequest, HttpResponse, Responder};
 use chrono::{DateTime, Local, NaiveDateTime};
 use dateparser::parse;
 use diesel::prelude::*;
+use diesel::r2d2::{ConnectionManager, Pool};
 use rss::Item;
 use scraper::{Html, Selector};
 
@@ -104,8 +102,13 @@ fn create_feed_item(item: Item, feed: &Feed, connection: &mut PgConnection) {
     }
 }
 
-pub async fn sync(_req: HttpRequest, data: web::Json<JsonUser>) -> impl Responder {
+pub async fn sync(
-    let mut connection: diesel::PgConnection = establish_connection();
+    _req: HttpRequest,
+    data: web::Json<JsonUser>,
+    pool: web::Data<Pool<ConnectionManager<PgConnection>>>,
+) -> impl Responder {
+    let pool_arc = pool.get_ref().clone();
+    let mut connection = pool_arc.get().expect("Failed to get database connection");
 
     let req_user_id: i32 = data.user_id;
 

src/views/auth/login.rs

@@ -1,4 +1,3 @@
-use crate::database::establish_connection;
 use crate::diesel;
 use crate::json_serialization::login::Login;
 use crate::models::user::rss_user::User;
@@ -6,13 +5,18 @@ use crate::schema::users;
 use crate::{auth::jwt::JwtToken, schema::users::username};
 use actix_web::{web, HttpResponse};
 use diesel::prelude::*;
+use diesel::r2d2::{ConnectionManager, Pool};
+
+pub async fn login(
+    credentials: web::Json<Login>,
+    pool: web::Data<Pool<ConnectionManager<PgConnection>>>,
+) -> HttpResponse {
+    let pool_arc = pool.get_ref().clone();
+    let mut connection = pool_arc.get().expect("Failed to get database connection");
 
-pub async fn login(credentials: web::Json<Login>) -> HttpResponse {
     let username_cred: String = credentials.username.clone();
     let password: String = credentials.password.clone();
 
-    let mut connection = establish_connection();
-
     let users: Vec<User> = users::table
         .filter(username.eq(username_cred.as_str()))
         .load::<User>(&mut connection)

src/views/users/create.rs

@@ -1,13 +1,20 @@
-use crate::database::establish_connection;
 use crate::diesel;
 use crate::json_serialization::new_user::NewUserSchema;
 use crate::models::user::new_user::NewUser;
 use crate::schema::users;
 use actix_web::{web, HttpResponse};
-use diesel::prelude::*;
+use diesel::{
+    prelude::*,
+    r2d2::{ConnectionManager, Pool},
+};
+
+pub async fn create(
+    new_user: web::Json<NewUserSchema>,
+    pool: web::Data<Pool<ConnectionManager<PgConnection>>>,
+) -> HttpResponse {
+    let pool_arc = pool.get_ref().clone();
+    let mut connection = pool_arc.get().expect("Failed to get database connection");
 
-pub async fn create(new_user: web::Json<NewUserSchema>) -> HttpResponse {
-    let mut connection = establish_connection();
     let name: String = new_user.name.clone();
     let email: String = new_user.email.clone();
     let new_password: String = new_user.password.clone();