i hate programming :(((((((((( >_<

Cargo.lock

@@ -28,7 +28,6 @@ dependencies = [
  "actix-codec",
  "actix-rt",
  "actix-service",
- "actix-tls",
  "actix-utils",
  "ahash",
  "base64",
@@ -122,25 +121,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "actix-tls"
-version = "3.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac453898d866cdbecdbc2334fe1738c747b4eba14a677261f2b768ba05329389"
-dependencies = [
- "actix-rt",
- "actix-service",
- "actix-utils",
- "futures-core",
- "impl-more",
- "openssl",
- "pin-project-lite",
- "tokio",
- "tokio-openssl",
- "tokio-util",
- "tracing",
-]
-
 [[package]]
 name = "actix-utils"
 version = "3.0.1"
@@ -164,7 +144,6 @@ dependencies = [
  "actix-rt",
  "actix-server",
  "actix-service",
- "actix-tls",
  "actix-utils",
  "actix-web-codegen",
  "ahash",
@@ -2323,17 +2302,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "tokio-openssl"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59df6849caa43bb7567f9a36f863c447d95a11d5903c9cc334ba32576a27eadd"
-dependencies = [
- "openssl",
- "openssl-sys",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.26.0"

src/main.rs

@@ -190,6 +190,7 @@ macro_rules! lock_onto_mutex {
                     break value;
                 }
                 Err(_) => {
+                    $mutex.clear_poison();
                     actix_web::rt::time::sleep(std::time::Duration::from_millis(15)).await;
                 }
             }

src/router/clear_rate.rs

@@ -167,11 +167,13 @@ fn get_json() -> JsonValue {
 }
 
 async fn get_clearrate_json() -> JsonValue {
-    let mut result = crate::lock_onto_mutex!(CACHED_DATA);
+    let cache = {
-    if result.is_none() {
+        let mut result = crate::lock_onto_mutex!(CACHED_DATA);
-        result.replace(get_json());
+        if result.is_none() {
-    }
+            result.replace(get_json());
-    let cache = result.as_ref().unwrap();
+        }
+        result.as_ref().unwrap().clone()
+    };
     let rv = cache["cache"].clone();
     if cache["last_updated"].as_u64().unwrap() + (60 * 60) < global::timestamp() {
         let mut result = crate::lock_onto_mutex!(CACHED_DATA);

src/sql.rs

@@ -5,23 +5,8 @@ use json::{JsonValue, array};
 use crate::router::clear_rate::Live;
 
 pub struct SQLite {
-    engine: Mutex<Connection>
+    engine: Mutex<Connection>,
-}
+    sleep_duration: u64
-
-// This is duplicated, for ease of people wanting to use this file in their project
-macro_rules! lock_onto_mutex {
-    ($mutex:expr) => {{
-        loop {
-            match $mutex.lock() {
-                Ok(value) => {
-                    break value;
-                }
-                Err(_) => {
-                    std::thread::sleep(std::time::Duration::from_millis(10));
-                }
-            }
-        }
-    }};
 }
 
 impl SQLite {
@@ -29,60 +14,98 @@ impl SQLite {
         let conn = Connection::open(crate::get_data_path(path)).unwrap();
         conn.execute("PRAGMA foreign_keys = ON;", ()).unwrap();
         let instance = SQLite {
-            engine: Mutex::new(conn)
+            engine: Mutex::new(conn),
+            sleep_duration: 10
         };
         setup(&instance);
         instance
     }
     pub fn lock_and_exec(&self, command: &str, args: &[&dyn ToSql]) {
-        let conn = lock_onto_mutex!(self.engine);
+        loop {
-        conn.execute(command, args).unwrap();
+            match self.engine.lock() {
+                Ok(conn) => {
+                    conn.execute(command, args).unwrap();
+                    return;
+                }
+                Err(_) => {
+                    self.engine.clear_poison();
+                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
+                }
+            }
+        }
     }
     pub fn lock_and_select(&self, command: &str, args: &[&dyn ToSql]) -> Result<String, rusqlite::Error> {
-        let conn = lock_onto_mutex!(self.engine);
+        loop {
-        let mut stmt = conn.prepare(command)?;
+            match self.engine.lock() {
-        return stmt.query_row(args, |row| {
+                Ok(conn) => {
-            match row.get::<usize, i64>(0) {
+                    let mut stmt = conn.prepare(command)?;
-                Ok(val) => Ok(val.to_string()),
+                    return stmt.query_row(args, |row| {
-                Err(_) => row.get(0)
+                        match row.get::<usize, i64>(0) {
+                            Ok(val) => Ok(val.to_string()),
+                                          Err(_) => row.get(0)
+                        }
+                    });
+                }
+                Err(_) => {
+                    self.engine.clear_poison();
+                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
+                }
             }
-        });
+        }
     }
     pub fn lock_and_select_all(&self, command: &str, args: &[&dyn ToSql]) -> Result<JsonValue, rusqlite::Error> {
-        let conn = lock_onto_mutex!(self.engine);
+        loop {
-        let mut stmt = conn.prepare(command)?;
+            match self.engine.lock() {
-        let map = stmt.query_map(args, |row| {
+                Ok(conn) => {
-            match row.get::<usize, i64>(0) {
+                    let mut stmt = conn.prepare(command)?;
-                Ok(val) => Ok(val.to_string()),
+                    let map = stmt.query_map(args, |row| {
-                Err(_) => row.get(0)
+                        match row.get::<usize, i64>(0) {
+                            Ok(val) => Ok(val.to_string()),
+                                             Err(_) => row.get(0)
+                        }
+                    })?;
+                    let mut rv = array![];
+                    for val in map {
+                        let res = val?;
+                        match res.clone().parse::<i64>() {
+                            Ok(v) => rv.push(v).unwrap(),
+                            Err(_) => rv.push(res).unwrap()
+                        };
+                    }
+                    return Ok(rv);
+                }
+                Err(_) => {
+                    self.engine.clear_poison();
+                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
+                }
             }
-        })?;
-        let mut rv = array![];
-        for val in map {
-            let res = val?;
-            match res.clone().parse::<i64>() {
-                Ok(v) => rv.push(v).unwrap(),
-                Err(_) => rv.push(res).unwrap()
-            };
         }
-        return Ok(rv);
     }
     pub fn get_live_data(&self, id: i64) -> Result<Live, rusqlite::Error> {
-        let conn = lock_onto_mutex!(self.engine);
+        loop {
-        let mut stmt = conn.prepare("SELECT * FROM lives WHERE live_id=?1")?;
+            match self.engine.lock() {
-        return stmt.query_row(params!(id), |row| {
+                Ok(conn) => {
-            Ok(Live {
+                    let mut stmt = conn.prepare("SELECT * FROM lives WHERE live_id=?1")?;
-                live_id: row.get(0)?,
+                    return stmt.query_row(params!(id), |row| {
-                normal_failed: row.get(1)?,
+                        Ok(Live {
-                normal_pass: row.get(2)?,
+                            live_id: row.get(0)?,
-                hard_failed: row.get(3)?,
+                           normal_failed: row.get(1)?,
-                hard_pass: row.get(4)?,
+                           normal_pass: row.get(2)?,
-                expert_failed: row.get(5)?,
+                           hard_failed: row.get(3)?,
-                expert_pass: row.get(6)?,
+                           hard_pass: row.get(4)?,
-                master_failed: row.get(7)?,
+                           expert_failed: row.get(5)?,
-                master_pass: row.get(8)?,
+                           expert_pass: row.get(6)?,
-            })
+                           master_failed: row.get(7)?,
-        });
+                           master_pass: row.get(8)?,
+                        })
+                    });
+                }
+                Err(_) => {
+                    self.engine.clear_poison();
+                    std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration));
+                }
+            }
+        }
     }
     pub fn create_store_v2(&self, table: &str) {
         self.lock_and_exec(table, params!());