Bug fixed hopefully

Author: fatfingers23

Diff for: Cargo.lock

@@ -40,6 +40,7 @@ actix-cors = "0.6.4"
 celery = "0.5.5"
 mockall = "0.11.4"
 async-trait = { version = "0.1.73", features = [] }
+redis = { version = "0.23.3", features = ["json"] }
 
 
 [dev-dependencies]

Diff for: trackscape-discord-api/Cargo.toml

@@ -1,4 +1,3 @@
-use crate::cache::Cache;
 use crate::websocket_server::DiscordToClanChatMessage;
 use crate::{handler, ChatServerHandle};
 use actix_web::web::Data;
@@ -13,12 +12,12 @@ use tokio::task::spawn_local;
 use trackscape_discord_shared::database::BotMongoDb;
 use trackscape_discord_shared::ge_api::ge_api::get_item_mapping;
 use trackscape_discord_shared::helpers::hash_string;
-use trackscape_discord_shared::jobs::job_helpers::get_redis_client;
 use trackscape_discord_shared::jobs::CeleryJobQueue;
 use trackscape_discord_shared::osrs_broadcast_extractor::osrs_broadcast_extractor::{
     get_wiki_clan_rank_image_url, ClanMessage,
 };
 use trackscape_discord_shared::osrs_broadcast_handler::OSRSBroadcastHandler;
+use trackscape_discord_shared::redis_helpers::{fetch_redis, write_to_cache_with_seconds};
 use trackscape_discord_shared::wiki_api::wiki_api::get_quests_and_difficulties;
 use web::Json;
 
@@ -79,7 +78,7 @@ async fn new_discord_message(
 async fn new_clan_chats(
     req: HttpRequest,
     discord_http_client: Data<Http>,
-    cache: Data<Cache>,
+    redis_client: Data<redis::Client>,
     new_chat: Json<Vec<ClanMessage>>,
     mongodb: Data<BotMongoDb>,
     celery: Data<Arc<Celery>>,
@@ -127,12 +126,18 @@ async fn new_clan_chats(
         //Checks to make sure the message has not already been process since multiple people could be submitting them
         let message_content_hash =
             hash_string(format!("{}{}", chat.message.clone(), chat.sender.clone()));
-        match cache.get_value(message_content_hash.clone()).await {
-            Some(_) => continue,
-            None => {
-                cache
-                    .set_value(message_content_hash.clone(), "true".to_string())
-                    .await;
+
+        let mut redis_connection = redis_client
+            .get_connection()
+            .expect("Could not connect to redis");
+
+        let redis_key = format!("MessageHashes:{}", message_content_hash);
+        match fetch_redis::<String>(&mut redis_connection, &redis_key).await {
+            Ok(_) => {
+                continue;
+            }
+            Err(_) => {
+                write_to_cache_with_seconds(&mut redis_connection, &redis_key, true, 10).await
             }
         }
 
@@ -143,6 +148,7 @@ async fn new_clan_chats(
         }
 
         if registered_guild.clan_name.clone().unwrap() != chat.clan_name {
+            error!("Clan name does not match the clan name saved in the database");
             continue;
         }
 
@@ -213,9 +219,6 @@ async fn new_clan_chats(
 
         let league_world = chat.is_league_world.unwrap_or(false);
 
-        // TODO: Load this from Redis
-        let mut redis_connection = get_redis_client().unwrap();
-
         let item_mapping_from_redis = get_item_mapping(&mut redis_connection).await;
 
         let quests_from_redis = get_quests_and_difficulties(&mut redis_connection).await;

Diff for: trackscape-discord-api/src/cache.rs

@@ -1,11 +1,9 @@
 extern crate dotenv;
 
-mod cache;
 mod controllers;
 mod handler;
 mod websocket_server;
 
-use crate::cache::Cache;
 use crate::controllers::bot_info_controller::info_controller;
 use crate::controllers::chat_controller::chat_controller;
 use actix_cors::Cors;
@@ -18,7 +16,6 @@ use shuttle_actix_web::ShuttleActixWeb;
 use std::env;
 use std::sync::atomic::AtomicI64;
 use std::sync::Mutex;
-use std::time::Duration;
 use tokio::spawn;
 use trackscape_discord_shared::database::{BotMongoDb, MongoDb};
 use trackscape_discord_shared::ge_api::ge_api::get_item_mapping;
@@ -61,7 +58,10 @@ async fn actix_web() -> ShuttleActixWeb<impl FnOnce(&mut ServiceConfig) + Send +
     }
 
     let db = BotMongoDb::new_db_instance(mongodb_url).await;
-    let mut redis_conn = get_redis_client().unwrap();
+    let redis_client = get_redis_client();
+    let mut redis_conn = redis_client
+        .get_connection()
+        .expect("Could not connect to redis");
 
     info!("Loading startup data from the web");
     let ge_mapping_request = get_item_mapping(&mut redis_conn).await;
@@ -84,12 +84,6 @@ async fn actix_web() -> ShuttleActixWeb<impl FnOnce(&mut ServiceConfig) + Send +
         }
     }
 
-    let mut cache = Cache::new(Duration::from_secs(10));
-    let cache_clone = cache.clone();
-    spawn(async move {
-        cache.clean_expired().await;
-    });
-
     #[allow(clippy::mutex_atomic)] // it's intentional.
     let connected_websockets_counter = Data::new(Mutex::new(0usize));
     let connected_discord_servers = Data::new(AtomicI64::new(0));
@@ -117,10 +111,10 @@ async fn actix_web() -> ShuttleActixWeb<impl FnOnce(&mut ServiceConfig) + Send +
         .app_data(web::Data::new(server_tx.clone()))
         .app_data(connected_websockets_counter)
         .app_data(connected_discord_servers)
-        .app_data(web::Data::new(cache_clone))
         .app_data(web::Data::new(HttpBuilder::new(discord_token).build()))
         .app_data(web::Data::new(db))
         .app_data(web::Data::new(celery.clone()))
+        .app_data(web::Data::new(redis_client.clone()))
         .default_service(web::route().guard(guard::Not(guard::Get())).to(index));
     };
 

Diff for: trackscape-discord-api/src/controllers/chat_controller.rs

@@ -1,5 +1,5 @@
 use crate::database::{BotMongoDb, MongoDb};
-use redis::{Connection, RedisResult};
+use redis::{Client, Connection, RedisResult};
 use serde::Serialize;
 use std::env;
 
@@ -10,13 +10,18 @@ pub async fn get_mongodb() -> BotMongoDb {
     BotMongoDb::new_db_instance(mongodb_url).await
 }
 
-pub fn get_redis_client() -> RedisResult<Connection> {
+pub fn get_redis_connection() -> RedisResult<Connection> {
     let redis_url = env::var("REDIS_ADDR").expect("REDIS_ADDR not set!");
     redis::Client::open(redis_url)
         .expect("Could not connect to redis")
         .get_connection()
 }
 
+pub fn get_redis_client() -> Client {
+    let redis_url = env::var("REDIS_ADDR").expect("REDIS_ADDR not set!");
+    redis::Client::open(redis_url).expect("Could not connect to redis")
+}
+
 pub async fn write_to_cache<T: Serialize>(
     redis_connection: &mut Connection,
     redis_key: String,

Diff for: trackscape-discord-api/src/main.rs

@@ -1,5 +1,5 @@
 use crate::database::clan_mates::{name_compare, ClanMates};
-use crate::jobs::job_helpers::{get_mongodb, get_redis_client};
+use crate::jobs::job_helpers::{get_mongodb, get_redis_connection};
 use crate::wom::{get_latest_name_change, get_wom_client, ApiLimiter};
 use celery::prelude::*;
 use log::info;
@@ -10,7 +10,7 @@ pub async fn name_change() -> TaskResult<()> {
     info!("Running name change job");
     let wom_client = get_wom_client();
     let mongodb = get_mongodb().await;
-    let mut redis_connection = get_redis_client().expect("Failed to get redis client.");
+    let mut redis_connection = get_redis_connection().expect("Failed to get redis client.");
 
     let mut limiter = ApiLimiter::new();
 

Diff for: trackscape-discord-shared/src/jobs/job_helpers.rs

@@ -1,4 +1,4 @@
-use super::job_helpers::get_redis_client;
+use super::job_helpers::get_redis_connection;
 use redis::{Commands, RedisResult};
 
 pub mod pb_command;
@@ -11,7 +11,7 @@ pub async fn get_runelite_api_url() -> Result<String, anyhow::Error> {
 }
 
 async fn get_runelite_version() -> Result<String, anyhow::Error> {
-    let mut redis_connection = get_redis_client().unwrap();
+    let mut redis_connection = get_redis_connection().unwrap();
     let version_key = "runelite_version";
     let exists: RedisResult<bool> = redis_connection.exists(version_key);
     match exists {

Diff for: trackscape-discord-shared/src/jobs/name_change_job.rs

@@ -1,5 +1,5 @@
 use crate::database::clan_mates::{ClanMateModel, ClanMates};
-use crate::jobs::job_helpers::{get_mongodb, get_redis_client, write_to_cache};
+use crate::jobs::job_helpers::{get_mongodb, get_redis_connection, write_to_cache};
 use crate::wom::{get_latest_name_change, get_wom_client};
 use celery::prelude::*;
 use redis::{Commands, RedisResult};
@@ -12,7 +12,7 @@ pub async fn update_create_clanmate(
     rank: String,
     guild_id: u64,
 ) -> TaskResult<i32> {
-    let mut redis_connection = get_redis_client().expect("Failed to get redis client.");
+    let mut redis_connection = get_redis_connection().expect("Failed to get redis client.");
     let redis_key = format!("players:{}", player_name.clone());
     let exists: RedisResult<bool> = redis_connection.exists(redis_key.clone());
 

Diff for: trackscape-discord-shared/src/jobs/runelite_commands/mod.rs

@@ -46,6 +46,18 @@ pub async fn fetch_redis_json_object<T: for<'a> Deserialize<'a>>(
     Ok(val)
 }
 
+pub async fn fetch_redis<T: redis::FromRedisValue>(
+    redis_connection: &mut Connection,
+    redis_key: &str,
+) -> Result<T, RedisFetchErrors> {
+    let val = redis::cmd("GET")
+        .arg(redis_key)
+        .query::<T>(redis_connection)
+        .map_err(|_| RedisFetchErrors::FromDbError)?;
+
+    Ok(val)
+}
+
 pub enum RedisFetchErrors {
     FromDbError,
     ParseError,