refactor: remove mutex

Author: omfj

src/main.rs

@@ -3,10 +3,7 @@ mod commands;
 mod queue;
 mod server;
 
-use std::{
-    env,
-    sync::{Arc, Mutex},
-};
+use std::{env, sync::Arc};
 
 use bot::WaffleBot;
 use dotenv::dotenv;
@@ -31,9 +28,7 @@ async fn main() {
     let redis_url = env::var("REDIS_URL").expect("Expected REDIS_URL in environment");
     let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
 
-    let redis = Arc::new(Mutex::new(
-        redis::Client::open(redis_url).expect("Invalid Redis URL"),
-    ));
+    let redis = Arc::new(redis::Client::open(redis_url).expect("Invalid Redis URL"));
     let waffle_queue = Arc::new(WaffleQueue::new(redis));
 
     let waffle_bot = WaffleBot::new(token, waffle_queue.clone());

src/queue.rs

@@ -1,19 +1,19 @@
 use std::sync::{
     atomic::{AtomicBool, Ordering},
-    Arc, Mutex,
+    Arc,
 };
 
 use redis::Commands;
 
 const QUEUE_NAME: &str = "queue";
 
 pub struct WaffleQueue {
-    redis: Arc<Mutex<redis::Client>>,
+    redis: Arc<redis::Client>,
     is_open: AtomicBool,
 }
 
 impl WaffleQueue {
-    pub fn new(redis: Arc<Mutex<redis::Client>>) -> Self {
+    pub fn new(redis: Arc<redis::Client>) -> Self {
         Self {
             redis,
             is_open: AtomicBool::new(false),
@@ -33,7 +33,7 @@ impl WaffleQueue {
     }
 
     pub fn index_of(&self, target: String) -> Option<usize> {
-        let mut con = match self.redis.lock().unwrap().get_connection() {
+        let mut con = match self.redis.get_connection() {
             Ok(c) => c,
             Err(_) => return None,
         };
@@ -47,24 +47,24 @@ impl WaffleQueue {
     }
 
     pub fn size(&self) -> usize {
-        let mut con = self.redis.lock().unwrap().get_connection().unwrap();
+        let mut con = self.redis.get_connection().unwrap();
         con.llen(QUEUE_NAME).unwrap_or(0) as usize
     }
 
     pub fn push(&self, value: String) -> usize {
-        let mut con = self.redis.lock().unwrap().get_connection().unwrap();
+        let mut con = self.redis.get_connection().unwrap();
 
         con.rpush(QUEUE_NAME, value).unwrap_or_default()
     }
 
     pub fn pop(&self) -> Option<String> {
-        let mut con = self.redis.lock().unwrap().get_connection().unwrap();
+        let mut con = self.redis.get_connection().unwrap();
         let result: redis::RedisResult<Vec<String>> = con.lpop(QUEUE_NAME, None);
         result.ok().and_then(|mut vec| vec.pop())
     }
 
     pub fn list(&self) -> Vec<String> {
-        let mut con = self.redis.lock().unwrap().get_connection().unwrap();
+        let mut con = self.redis.get_connection().unwrap();
         con.lrange(QUEUE_NAME, 0, -1).unwrap_or_else(|_| vec![])
     }
 }
@@ -82,7 +82,7 @@ mod tests {
         let host_ip = node.get_host().unwrap();
         let host_port = node.get_host_port_ipv4(6379).unwrap();
         let url = format!("redis://{host_ip}:{host_port}");
-        let client = Arc::new(Mutex::new(redis::Client::open(url).unwrap()));
+        let client = Arc::new(redis::Client::open(url).unwrap());
         let queue = WaffleQueue::new(client);
 
         queue.push("foo".to_string());
@@ -105,7 +105,7 @@ mod tests {
         let host_ip = node.get_host().unwrap();
         let host_port = node.get_host_port_ipv4(6379).unwrap();
         let url = format!("redis://{host_ip}:{host_port}");
-        let client = Arc::new(Mutex::new(redis::Client::open(url).unwrap()));
+        let client = Arc::new(redis::Client::open(url).unwrap());
         let queue = WaffleQueue::new(client);
 
         queue.push("foo".to_string());
@@ -121,7 +121,7 @@ mod tests {
         let host_ip = node.get_host().unwrap();
         let host_port = node.get_host_port_ipv4(6379).unwrap();
         let url = format!("redis://{host_ip}:{host_port}");
-        let client = Arc::new(Mutex::new(redis::Client::open(url).unwrap()));
+        let client = Arc::new(redis::Client::open(url).unwrap());
         let queue = WaffleQueue::new(client);
 
         queue.push("foo".to_string());
@@ -138,7 +138,7 @@ mod tests {
         let host_ip = node.get_host().unwrap();
         let host_port = node.get_host_port_ipv4(6379).unwrap();
         let url = format!("redis://{host_ip}:{host_port}");
-        let client = Arc::new(Mutex::new(redis::Client::open(url).unwrap()));
+        let client = Arc::new(redis::Client::open(url).unwrap());
         let queue = WaffleQueue::new(client);
 
         assert_eq!(queue.size(), 0);