Использование функции для осуществления операций в базе данных вместо ручного блокирования мьютекса.

.gitignore

@@ -4,3 +4,4 @@ schedule.json
 teachers.json
 
 .env*
+/*-firebase-adminsdk-*.json

.idea/schedule-parser-rusted.iml

@@ -10,6 +10,7 @@
       <excludeFolder url="file://$MODULE_DIR$/actix-macros/target" />
       <excludeFolder url="file://$MODULE_DIR$/actix-test/target" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
+      <excludeFolder url="file://$MODULE_DIR$/.idea/dataSources" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />

src/app_state.rs

@@ -7,8 +7,7 @@ use diesel::{Connection, PgConnection};
 use sha1::{Digest, Sha1};
 use std::env;
 use std::hash::Hash;
-use std::ops::DerefMut;
+use std::sync::Mutex;
-use std::sync::{Mutex, MutexGuard};
 
 #[derive(Clone)]
 pub struct Schedule {
@@ -74,23 +73,6 @@ impl AppState {
     }
 }
 
-impl AppState {
-    /// Получение объекта соединения с базой данных PostgreSQL
-    pub fn connection(&self) -> MutexGuard<PgConnection> {
-        self.database.lock().unwrap()
-    }
-
-    pub fn lock_connection<T, F>(&self, f: F) -> T
-    where
-        F: FnOnce(&mut PgConnection) -> T,
-    {
-        let mut lock = self.connection();
-        let conn = lock.deref_mut();
-
-        f(conn)
-    }
-}
-
 /// Создание нового объекта web::Data<AppState>
 pub fn app_state() -> web::Data<AppState> {
     web::Data::new(AppState::new())

src/database/driver.rs

@@ -1,118 +1,112 @@
 pub mod users {
+    use crate::app_state::AppState;
     use crate::database::models::User;
     use crate::database::schema::users::dsl::users;
     use crate::database::schema::users::dsl::*;
+    use actix_web::web;
+    use diesel::SelectableHelper;
     use diesel::{insert_into, ExpressionMethods, QueryResult};
-    use diesel::{PgConnection, SelectableHelper};
     use diesel::{QueryDsl, RunQueryDsl};
-    use std::ops::DerefMut;
+    use crate::utility::mutex::MutexScope;
-    use std::sync::Mutex;
 
-    pub fn get(connection: &Mutex<PgConnection>, _id: &String) -> QueryResult<User> {
+    pub fn get(state: &web::Data<AppState>, _id: &String) -> QueryResult<User> {
-        let mut lock = connection.lock().unwrap();
+        state.database.scope(|conn| {
-        let con = lock.deref_mut();
+            users
-
+                .filter(id.eq(_id))
-        users
+                .select(User::as_select())
-            .filter(id.eq(_id))
+                .first(conn)
-            .select(User::as_select())
+        })
-            .first(con)
     }
 
-    pub fn get_by_username(
+    pub fn get_by_username(state: &web::Data<AppState>, _username: &String) -> QueryResult<User> {
-        connection: &Mutex<PgConnection>,
+        state.database.scope(|conn| {
-        _username: &String,
+            users
-    ) -> QueryResult<User> {
+                .filter(username.eq(_username))
-        let mut lock = connection.lock().unwrap();
+                .select(User::as_select())
-        let con = lock.deref_mut();
+                .first(conn)
-
+        })
-        users
-            .filter(username.eq(_username))
-            .select(User::as_select())
-            .first(con)
     }
 
-    pub fn get_by_vk_id(connection: &Mutex<PgConnection>, _vk_id: i32) -> QueryResult<User> {
+    //noinspection RsTraitObligations
-        let mut lock = connection.lock().unwrap();
+    pub fn get_by_vk_id(state: &web::Data<AppState>, _vk_id: i32) -> QueryResult<User> {
-        let con = lock.deref_mut();
+        state.database.scope(|conn| {
-
+            users
-        users
+                .filter(vk_id.eq(_vk_id))
-            .filter(vk_id.eq(_vk_id))
+                .select(User::as_select())
-            .select(User::as_select())
+                .first(conn)
-            .first(con)
+        })
     }
 
-    pub fn contains_by_username(connection: &Mutex<PgConnection>, _username: &String) -> bool {
+    //noinspection DuplicatedCode
-        let mut lock = connection.lock().unwrap();
+    pub fn contains_by_username(state: &web::Data<AppState>, _username: &String) -> bool {
-        let con = lock.deref_mut();
+        // и как это нахуй сократить блять примеров нихуя нет, нихуя не работает
-
+        // как меня этот раст заебал уже
-        match users
+        state.database.scope(|conn| {
-            .filter(username.eq(_username))
+            match users
-            .count()
+                .filter(username.eq(_username))
-            .get_result::<i64>(con)
+                .count()
-        {
+                .get_result::<i64>(conn)
-            Ok(count) => count > 0,
+            {
-            Err(_) => false,
+                Ok(count) => count > 0,
-        }
+                Err(_) => false,
+            }
+        })
     }
 
-    pub fn contains_by_vk_id(connection: &Mutex<PgConnection>, _vk_id: i32) -> bool {
+    //noinspection DuplicatedCode
-        let mut lock = connection.lock().unwrap();
+    //noinspection RsTraitObligations
-        let con = lock.deref_mut();
+    pub fn contains_by_vk_id(state: &web::Data<AppState>, _vk_id: i32) -> bool {
-
+        state.database.scope(|conn| {
-        match users
+            match users
-            .filter(vk_id.eq(_vk_id))
+                .filter(vk_id.eq(_vk_id))
-            .count()
+                .count()
-            .get_result::<i64>(con)
+                .get_result::<i64>(conn)
-        {
+            {
-            Ok(count) => count > 0,
+                Ok(count) => count > 0,
-            Err(_) => false,
+                Err(_) => false,
-        }
+            }
+        })
     }
 
-    pub fn insert(connection: &Mutex<PgConnection>, user: &User) -> QueryResult<usize> {
+    pub fn insert(state: &web::Data<AppState>, user: &User) -> QueryResult<usize> {
-        let mut lock = connection.lock().unwrap();
+        state.database.scope(|conn| insert_into(users).values(user).execute(conn))
-        let con = lock.deref_mut();
-
-        insert_into(users).values(user).execute(con)
     }
 
     #[cfg(test)]
-    pub fn delete_by_username(connection: &Mutex<PgConnection>, _username: &String) -> bool {
+    pub fn delete_by_username(state: &web::Data<AppState>, _username: &String) -> bool {
-        let mut lock = connection.lock().unwrap();
+        state.database.scope(|conn| {
-        let con = lock.deref_mut();
+            match diesel::delete(users.filter(username.eq(_username))).execute(conn) {
-
+                Ok(count) => count > 0,
-        match diesel::delete(users.filter(username.eq(_username))).execute(con) {
+                Err(_) => false,
-            Ok(count) => count > 0,
+            }
-            Err(_) => false,
+        })
-        }
     }
 
     #[cfg(test)]
-    pub fn insert_or_ignore(connection: &Mutex<PgConnection>, user: &User) -> QueryResult<usize> {
+    pub fn insert_or_ignore(state: &web::Data<AppState>, user: &User) -> QueryResult<usize> {
-        let mut lock = connection.lock().unwrap();
+        state.database.scope(|conn| {
-        let con = lock.deref_mut();
+            insert_into(users)
-
+                .values(user)
-        insert_into(users)
+                .on_conflict_do_nothing()
-            .values(user)
+                .execute(conn)
-            .on_conflict_do_nothing()
+        })
-            .execute(con)
     }
 }
 
 pub mod fcm {
+    use crate::app_state::AppState;
     use crate::database::models::{User, FCM};
+    use actix_web::web;
     use diesel::QueryDsl;
     use diesel::RunQueryDsl;
-    use diesel::{BelongingToDsl, PgConnection, QueryResult, SelectableHelper};
+    use diesel::{BelongingToDsl, QueryResult, SelectableHelper};
-    use std::ops::DerefMut;
+    use crate::utility::mutex::MutexScope;
-    use std::sync::Mutex;
 
-    pub fn from_user(connection: &Mutex<PgConnection>, user: &User) -> QueryResult<FCM> {
+    pub fn from_user(state: &web::Data<AppState>, user: &User) -> QueryResult<FCM> {
-        let mut lock = connection.lock().unwrap();
+        state.database.scope(|conn| {
-        let con = lock.deref_mut();
+            FCM::belonging_to(&user)
-
+                .select(FCM::as_select())
-        FCM::belonging_to(&user)
+                .get_result(conn)
-            .select(FCM::as_select())
+        })
-            .get_result(con)
     }
 }

src/extractors/authorized_user.rs

@@ -63,7 +63,7 @@ impl FromRequestSync for User {
 
         let app_state = req.app_data::<web::Data<AppState>>().unwrap();
 
-        driver::users::get(&app_state.database, &user_id).map_err(|_| Error::NoUser.into())
+        driver::users::get(&app_state, &user_id).map_err(|_| Error::NoUser.into())
     }
 }
 
@@ -100,7 +100,7 @@ impl<const FCM: bool> FromRequestSync for UserExtractor<{ FCM }> {
 
         Ok(Self {
             fcm: if FCM {
-                driver::fcm::from_user(&app_state.database, &user).ok()
+                driver::fcm::from_user(&app_state, &user).ok()
             } else {
                 None
             },

src/routes/auth/sign_in.rs

@@ -5,10 +5,10 @@ use crate::routes::auth::shared::parse_vk_id;
 use crate::routes::auth::sign_in::schema::SignInData::{Default, Vk};
 use crate::routes::schema::user::UserResponse;
 use crate::routes::schema::{IntoResponseAsError, ResponseError};
-use crate::{utility, AppState};
+use crate::utility::mutex::MutexScope;
+use crate::{AppState, utility};
 use actix_web::{post, web};
 use diesel::SaveChangesDsl;
-use std::ops::DerefMut;
 use web::Json;
 
 async fn sign_in_combined(
@@ -16,8 +16,8 @@ async fn sign_in_combined(
     app_state: &web::Data<AppState>,
 ) -> Result<UserResponse, ErrorCode> {
     let user = match &data {
-        Default(data) => driver::users::get_by_username(&app_state.database, &data.username),
+        Default(data) => driver::users::get_by_username(&app_state, &data.username),
-        Vk(id) => driver::users::get_by_vk_id(&app_state.database, *id),
+        Vk(id) => driver::users::get_by_vk_id(&app_state, *id),
     };
 
     match user {
@@ -35,13 +35,12 @@ async fn sign_in_combined(
                 }
             }
 
-            let mut lock = app_state.connection();
-            let conn = lock.deref_mut();
-
             user.access_token = utility::jwt::encode(&user.id);
 
-            user.save_changes::<User>(conn)
+            app_state.database.scope(|conn| {
-                .expect("Failed to update user");
+                user.save_changes::<User>(conn)
+                    .expect("Failed to update user")
+            });
 
             Ok(user.into())
         }
@@ -56,7 +55,9 @@ async fn sign_in_combined(
 ))]
 #[post("/sign-in")]
 pub async fn sign_in(data: Json<Request>, app_state: web::Data<AppState>) -> ServiceResponse {
-    sign_in_combined(Default(data.into_inner()), &app_state).await.into()
+    sign_in_combined(Default(data.into_inner()), &app_state)
+        .await
+        .into()
 }
 
 #[utoipa::path(responses(
@@ -64,7 +65,10 @@ pub async fn sign_in(data: Json<Request>, app_state: web::Data<AppState>) -> Ser
     (status = NOT_ACCEPTABLE, body = ResponseError<ErrorCode>)
 ))]
 #[post("/sign-in-vk")]
-pub async fn sign_in_vk(data_json: Json<vk::Request>, app_state: web::Data<AppState>) -> ServiceResponse {
+pub async fn sign_in_vk(
+    data_json: Json<vk::Request>,
+    app_state: web::Data<AppState>,
+) -> ServiceResponse {
     let data = data_json.into_inner();
 
     match parse_vk_id(&data.access_token) {
@@ -176,7 +180,7 @@ mod tests {
 
         let app_state = static_app_state();
         driver::users::insert_or_ignore(
-            &app_state.database,
+            &app_state,
             &User {
                 id: id.clone(),
                 username,

src/routes/auth/sign_up.rs

@@ -28,19 +28,19 @@ async fn sign_up_combined(
     }
 
     // If user with specified username already exists.
-    if driver::users::contains_by_username(&app_state.database, &data.username) {
+    if driver::users::contains_by_username(&app_state, &data.username) {
         return Err(ErrorCode::UsernameAlreadyExists);
     }
 
     // If user with specified VKID already exists.
     if let Some(id) = data.vk_id {
-        if driver::users::contains_by_vk_id(&app_state.database, id) {
+        if driver::users::contains_by_vk_id(&app_state, id) {
             return Err(ErrorCode::VkAlreadyExists);
         }
     }
 
     let user = data.into();
-    driver::users::insert(&app_state.database, &user).unwrap();
+    driver::users::insert(&app_state, &user).unwrap();
 
     Ok(UserResponse::from(&user)).into()
 }
@@ -281,7 +281,7 @@ mod tests {
         test_env();
 
         let app_state = static_app_state();
-        driver::users::delete_by_username(&app_state.database, &"test::sign_up_valid".to_string());
+        driver::users::delete_by_username(&app_state, &"test::sign_up_valid".to_string());
 
         // test
 
@@ -303,7 +303,7 @@ mod tests {
 
         let app_state = static_app_state();
         driver::users::delete_by_username(
-            &app_state.database,
+            &app_state,
             &"test::sign_up_multiple".to_string(),
         );
 

src/routes/fcm/update_callback.rs

@@ -1,6 +1,7 @@
 use crate::app_state::AppState;
 use crate::database::models::User;
 use crate::extractors::base::SyncExtractor;
+use crate::utility::mutex::MutexScope;
 use actix_web::{HttpResponse, Responder, post, web};
 use diesel::SaveChangesDsl;
 
@@ -18,7 +19,10 @@ async fn update_callback(
 
     user.version = version.into_inner();
 
-    match app_state.lock_connection(|con| user.save_changes::<User>(con)) {
+    match app_state
+        .database
+        .scope(|conn| user.save_changes::<User>(conn))
+    {
         Ok(_) => HttpResponse::Ok(),
         Err(e) => {
             eprintln!("Failed to update user: {}", e);

src/utility/mod.rs

@@ -1,3 +1,4 @@
 pub mod jwt;
 pub mod error;
 pub mod hasher;
+pub mod mutex;

src/utility/mutex.rs

@@ -0,0 +1,21 @@
+use std::ops::DerefMut;
+use std::sync::Mutex;
+
+pub trait MutexScope<T, ScopeFn, ScopeFnOutput>
+where
+    ScopeFn: FnOnce(&mut T) -> ScopeFnOutput,
+{
+    fn scope(&self, f: ScopeFn) -> ScopeFnOutput;
+}
+
+impl<T, ScopeFn, ScopeFnOutput> MutexScope<T, ScopeFn, ScopeFnOutput> for Mutex<T>
+where
+    ScopeFn: FnOnce(&mut T) -> ScopeFnOutput,
+{
+    fn scope(&self, f: ScopeFn) -> ScopeFnOutput {
+        let mut lock = self.lock().unwrap();
+        let inner = lock.deref_mut();
+        
+        f(inner)
+    }
+}