Compiler improvements (#753)

* basic redis add * toml; reverted unnecessary changes * merge issues * increased test connections --------- Co-authored-by: Geometrically <[email protected]>
modrinth · Nov 20, 2023 · dfba6c7 · dfba6c7
1 parent e06a77a
commit dfba6c7
Show file tree

Hide file tree

Showing 22 changed files with 307 additions and 140 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -109,3 +109,9 @@ derive-new = "0.5.9"
 
 [dev-dependencies]
 actix-http = "3.4.0"
+
+[profile.dev]
+opt-level = 0                # Minimal optimization, speeds up compilation
+lto = false                  # Disables Link Time Optimization
+incremental = true           # Enables incremental compilation
+codegen-units = 16           # Higher number can improve compile times but reduce runtime performance
diff --git a/src/database/models/categories.rs b/src/database/models/categories.rs
@@ -90,6 +90,8 @@ impl Category {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
+
         let res: Option<Vec<Category>> = redis
             .get_deserialized_from_json(TAGS_NAMESPACE, "category")
             .await?;
@@ -155,6 +157,8 @@ impl DonationPlatform {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
+
         let res: Option<Vec<DonationPlatform>> = redis
             .get_deserialized_from_json(TAGS_NAMESPACE, "donation_platform")
             .await?;
@@ -209,6 +213,8 @@ impl ReportType {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
+
         let res: Option<Vec<String>> = redis
             .get_deserialized_from_json(TAGS_NAMESPACE, "report_type")
             .await?;
@@ -257,6 +263,8 @@ impl ProjectType {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
+
         let res: Option<Vec<String>> = redis
             .get_deserialized_from_json(TAGS_NAMESPACE, "project_type")
             .await?;

diff --git a/src/database/models/collection_item.rs b/src/database/models/collection_item.rs
@@ -157,6 +157,8 @@ impl Collection {
     {
         use futures::TryStreamExt;
 
+        let mut redis = redis.connect().await?;
+
         if collection_ids.is_empty() {
             return Ok(Vec::new());
         }
@@ -166,7 +168,10 @@ impl Collection {
 
         if !collection_ids.is_empty() {
             let collections = redis
-                .multi_get::<String, _>(COLLECTIONS_NAMESPACE, collection_ids.iter().map(|x| x.0))
+                .multi_get::<String>(
+                    COLLECTIONS_NAMESPACE,
+                    collection_ids.iter().map(|x| x.0.to_string()),
+                )
                 .await?;
 
             for collection in collections {
@@ -240,6 +245,8 @@ impl Collection {
     }
 
     pub async fn clear_cache(id: CollectionId, redis: &RedisPool) -> Result<(), DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         redis.delete(COLLECTIONS_NAMESPACE, id.0).await?;
         Ok(())
     }

diff --git a/src/database/models/flow_item.rs b/src/database/models/flow_item.rs
@@ -58,6 +58,8 @@ impl Flow {
         expires: Duration,
         redis: &RedisPool,
     ) -> Result<String, DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         let flow = ChaCha20Rng::from_entropy()
             .sample_iter(&Alphanumeric)
             .take(32)
@@ -71,6 +73,8 @@ impl Flow {
     }
 
     pub async fn get(id: &str, redis: &RedisPool) -> Result<Option<Flow>, DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         redis.get_deserialized_from_json(FLOWS_NAMESPACE, id).await
     }
 
@@ -91,6 +95,8 @@ impl Flow {
     }
 
     pub async fn remove(id: &str, redis: &RedisPool) -> Result<Option<()>, DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         redis.delete(FLOWS_NAMESPACE, id).await?;
         Ok(Some(()))
     }

diff --git a/src/database/models/image_item.rs b/src/database/models/image_item.rs
@@ -180,6 +180,7 @@ impl Image {
     {
         use futures::TryStreamExt;
 
+        let mut redis = redis.connect().await?;
         if image_ids.is_empty() {
             return Ok(Vec::new());
         }
@@ -191,7 +192,7 @@ impl Image {
 
         if !image_ids.is_empty() {
             let images = redis
-                .multi_get::<String, _>(IMAGES_NAMESPACE, image_ids)
+                .multi_get::<String>(IMAGES_NAMESPACE, image_ids.iter().map(|x| x.to_string()))
                 .await?;
             for image in images {
                 if let Some(image) = image.and_then(|x| serde_json::from_str::<Image>(&x).ok()) {
@@ -246,6 +247,8 @@ impl Image {
     }
 
     pub async fn clear_cache(id: ImageId, redis: &RedisPool) -> Result<(), DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         redis.delete(IMAGES_NAMESPACE, id.0).await?;
         Ok(())
     }

diff --git a/src/database/models/loader_fields.rs b/src/database/models/loader_fields.rs
@@ -44,6 +44,7 @@ impl Game {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
         let cached_games: Option<Vec<Game>> = redis
             .get_deserialized_from_json(GAMES_LIST_NAMESPACE, "games")
             .await?;
@@ -95,6 +96,7 @@ impl Loader {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
         let cached_id: Option<i32> = redis.get_deserialized_from_json(LOADER_ID, name).await?;
         if let Some(cached_id) = cached_id {
             return Ok(Some(LoaderId(cached_id)));
@@ -124,6 +126,7 @@ impl Loader {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
         let cached_loaders: Option<Vec<Loader>> = redis
             .get_deserialized_from_json(LOADERS_LIST_NAMESPACE, "all")
             .await?;
@@ -318,9 +321,11 @@ impl LoaderField {
     {
         type RedisLoaderFieldTuple = (LoaderId, Vec<LoaderField>);
 
+        let mut redis = redis.connect().await?;
+
         let mut loader_ids = loader_ids.to_vec();
         let cached_fields: Vec<RedisLoaderFieldTuple> = redis
-            .multi_get::<String, _>(LOADER_FIELDS_NAMESPACE, loader_ids.iter().map(|x| x.0))
+            .multi_get::<String>(LOADER_FIELDS_NAMESPACE, loader_ids.iter().map(|x| x.0))
             .await?
             .into_iter()
             .flatten()
@@ -399,6 +404,8 @@ impl LoaderFieldEnum {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
+
         let cached_enum = redis
             .get_deserialized_from_json(LOADER_FIELD_ENUMS_ID_NAMESPACE, enum_name)
             .await?;
@@ -488,12 +495,13 @@ impl LoaderFieldEnumValue {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
         let mut found_enums = Vec::new();
         let mut remaining_enums: Vec<LoaderFieldEnumId> = loader_field_enum_ids.to_vec();
 
         if !remaining_enums.is_empty() {
             let enums = redis
-                .multi_get::<String, _>(
+                .multi_get::<String>(
                     LOADER_FIELD_ENUM_VALUES_NAMESPACE,
                     loader_field_enum_ids.iter().map(|x| x.0),
                 )

diff --git a/src/database/models/notification_item.rs b/src/database/models/notification_item.rs
@@ -174,8 +174,10 @@ impl Notification {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
     {
+        let mut redis = redis.connect().await?;
+
         let cached_notifications: Option<Vec<Notification>> = redis
-            .get_deserialized_from_json(USER_NOTIFICATIONS_NAMESPACE, user_id.0)
+            .get_deserialized_from_json(USER_NOTIFICATIONS_NAMESPACE, &user_id.0.to_string())
             .await?;
 
         if let Some(notifications) = cached_notifications {
@@ -319,6 +321,8 @@ impl Notification {
         user_ids: impl IntoIterator<Item = &UserId>,
         redis: &RedisPool,
     ) -> Result<(), DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         redis
             .delete_many(
                 user_ids

diff --git a/src/database/models/organization_item.rs b/src/database/models/organization_item.rs
@@ -103,6 +103,8 @@ impl Organization {
     {
         use futures::stream::TryStreamExt;
 
+        let mut redis = redis.connect().await?;
+
         if organization_strings.is_empty() {
             return Ok(Vec::new());
         }
@@ -120,11 +122,12 @@ impl Organization {
 
         organization_ids.append(
             &mut redis
-                .multi_get::<i64, _>(
+                .multi_get::<i64>(
                     ORGANIZATIONS_TITLES_NAMESPACE,
                     organization_strings
                         .iter()
-                        .map(|x| x.to_string().to_lowercase()),
+                        .map(|x| x.to_string().to_lowercase())
+                        .collect::<Vec<_>>(),
                 )
                 .await?
                 .into_iter()
@@ -134,7 +137,10 @@ impl Organization {
 
         if !organization_ids.is_empty() {
             let organizations = redis
-                .multi_get::<String, _>(ORGANIZATIONS_NAMESPACE, organization_ids)
+                .multi_get::<String>(
+                    ORGANIZATIONS_NAMESPACE,
+                    organization_ids.iter().map(|x| x.to_string()),
+                )
                 .await?;
 
             for organization in organizations {
@@ -197,8 +203,8 @@ impl Organization {
                 redis
                     .set(
                         ORGANIZATIONS_TITLES_NAMESPACE,
-                        organization.title.to_lowercase(),
-                        organization.id.0,
+                        &organization.title.to_lowercase(),
+                        &organization.id.0.to_string(),
                         None,
                     )
                     .await?;
@@ -318,6 +324,8 @@ impl Organization {
         title: Option<String>,
         redis: &RedisPool,
     ) -> Result<(), super::DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         redis
             .delete_many([
                 (ORGANIZATIONS_NAMESPACE, Some(id.0.to_string())),

diff --git a/src/database/models/pat_item.rs b/src/database/models/pat_item.rs
@@ -89,6 +89,8 @@ impl PersonalAccessToken {
     {
         use futures::TryStreamExt;
 
+        let mut redis = redis.connect().await?;
+
         if pat_strings.is_empty() {
             return Ok(Vec::new());
         }
@@ -106,7 +108,7 @@ impl PersonalAccessToken {
 
         pat_ids.append(
             &mut redis
-                .multi_get::<i64, _>(
+                .multi_get::<i64>(
                     PATS_TOKENS_NAMESPACE,
                     pat_strings.iter().map(|x| x.to_string()),
                 )
@@ -118,7 +120,7 @@ impl PersonalAccessToken {
 
         if !pat_ids.is_empty() {
             let pats = redis
-                .multi_get::<String, _>(PATS_NAMESPACE, pat_ids)
+                .multi_get::<String>(PATS_NAMESPACE, pat_ids.iter().map(|x| x.to_string()))
                 .await?;
             for pat in pats {
                 if let Some(pat) =
@@ -174,8 +176,8 @@ impl PersonalAccessToken {
                 redis
                     .set(
                         PATS_TOKENS_NAMESPACE,
-                        pat.access_token.clone(),
-                        pat.id.0,
+                        &pat.access_token,
+                        &pat.id.0.to_string(),
                         None,
                     )
                     .await?;
@@ -194,8 +196,10 @@ impl PersonalAccessToken {
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let mut redis = redis.connect().await?;
+
         let res = redis
-            .get_deserialized_from_json::<Vec<i64>, _>(PATS_USERS_NAMESPACE, user_id.0)
+            .get_deserialized_from_json::<Vec<i64>>(PATS_USERS_NAMESPACE, &user_id.0.to_string())
             .await?;
 
         if let Some(res) = res {
@@ -220,8 +224,8 @@ impl PersonalAccessToken {
         redis
             .set(
                 PATS_USERS_NAMESPACE,
-                user_id.0,
-                serde_json::to_string(&db_pats)?,
+                &user_id.0.to_string(),
+                &serde_json::to_string(&db_pats)?,
                 None,
             )
             .await?;
@@ -232,6 +236,8 @@ impl PersonalAccessToken {
         clear_pats: Vec<(Option<PatId>, Option<String>, Option<UserId>)>,
         redis: &RedisPool,
     ) -> Result<(), DatabaseError> {
+        let mut redis = redis.connect().await?;
+
         if clear_pats.is_empty() {
             return Ok(());
         }