From 83571e03c2321c07894802b935eaaf4798958844 Mon Sep 17 00:00:00 2001 From: Ethan O'Brien <77750390+ethanaobrien@users.noreply.github.com> Date: Sat, 4 May 2024 14:03:19 -0500 Subject: [PATCH] Remove duplicate database related code --- src/main.rs | 1 + src/router/clear_rate.rs | 158 ++++++----------------------------- src/router/gree.rs | 73 +++-------------- src/router/userdata/mod.rs | 163 ++++++++++--------------------------- src/sql.rs | 107 ++++++++++++++++++++++++ 5 files changed, 188 insertions(+), 314 deletions(-) create mode 100644 src/sql.rs diff --git a/src/main.rs b/src/main.rs index d476476..d8ff7f1 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,6 @@ mod encryption; mod router; +mod sql; use json::object; use actix_web::{ get, diff --git a/src/router/clear_rate.rs b/src/router/clear_rate.rs index 28b695b..4785ed4 100644 --- a/src/router/clear_rate.rs +++ b/src/router/clear_rate.rs @@ -1,106 +1,31 @@ use json::{object, array, JsonValue}; use crate::router::global; use actix_web::{HttpResponse, HttpRequest}; -use rusqlite::{Connection, params, ToSql}; -use std::sync::{Mutex, MutexGuard}; +use rusqlite::params; +use std::sync::Mutex; use lazy_static::lazy_static; use std::thread; use crate::encryption; +use crate::sql::SQLite; lazy_static! { - static ref ENGINE: Mutex> = Mutex::new(None); -} -fn init(engine: &mut MutexGuard<'_, Option>) { - let conn = Connection::open("live_statistics.db").unwrap(); - conn.execute("PRAGMA foreign_keys = ON;", ()).unwrap(); - - engine.replace(conn); -} -fn lock_and_exec(command: &str, args: &[&dyn ToSql]) { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - conn.execute(command, args).unwrap(); - return; - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} -fn lock_and_select(command: &str, args: &[&dyn ToSql]) -> Result { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - let mut stmt = conn.prepare(command)?; - return stmt.query_row(args, |row| { - match row.get::(0) { - Ok(val) => Ok(val.to_string()), - Err(_) => row.get(0) - } - }); - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} -fn lock_and_select_all(command: &str, args: &[&dyn ToSql]) -> Result { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - let mut stmt = conn.prepare(command)?; - let map = stmt.query_map(args, |row| { - match row.get::(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::() { - Ok(v) => rv.push(v).unwrap(), - Err(_) => rv.push(res).unwrap() - }; - } - return Ok(rv); - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } + static ref DATABASE: SQLite = SQLite::new("live_statistics.db"); } -struct Live { - live_id: i32, - normal_failed: i64, - normal_pass: i64, - hard_failed: i64, - hard_pass: i64, - expert_failed: i64, - expert_pass: i64, - master_failed: i64, - master_pass: i64, +pub struct Live { + pub live_id: i32, + pub normal_failed: i64, + pub normal_pass: i64, + pub hard_failed: i64, + pub hard_pass: i64, + pub expert_failed: i64, + pub expert_pass: i64, + pub master_failed: i64, + pub master_pass: i64, } fn create_store() { - lock_and_exec("CREATE TABLE IF NOT EXISTS lives ( + DATABASE.lock_and_exec("CREATE TABLE IF NOT EXISTS lives ( live_id INT NOT NULL PRIMARY KEY, normal_failed BIGINT NOT NULL, normal_pass BIGINT NOT NULL, @@ -113,39 +38,8 @@ fn create_store() { )", params!()); } -fn get_live_data(id: i64) -> Result { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - - let mut stmt = conn.prepare("SELECT * FROM lives WHERE live_id=?1")?; - return Ok(stmt.query_row(params!(id), |row| { - Ok(Live { - live_id: row.get(0)?, - normal_failed: row.get(1)?, - normal_pass: row.get(2)?, - hard_failed: row.get(3)?, - hard_pass: row.get(4)?, - expert_failed: row.get(5)?, - expert_pass: row.get(6)?, - master_failed: row.get(7)?, - master_pass: row.get(8)?, - }) - })?); - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} - fn update_live_score(id: i64, uid: i64, score: i64) { - lock_and_exec("CREATE TABLE IF NOT EXISTS scores ( + DATABASE.lock_and_exec("CREATE TABLE IF NOT EXISTS scores ( live_id INT NOT NULL PRIMARY KEY, score_data TEXT NOT NULL )", params!()); @@ -153,7 +47,7 @@ fn update_live_score(id: i64, uid: i64, score: i64) { return; } - let info = lock_and_select("SELECT score_data FROM scores WHERE live_id=?1", params!(id)).unwrap_or(String::from("[]")); + let info = DATABASE.lock_and_select("SELECT score_data FROM scores WHERE live_id=?1", params!(id)).unwrap_or(String::from("[]")); let scores = json::parse(&info).unwrap(); let mut result = array![]; @@ -189,17 +83,17 @@ fn update_live_score(id: i64, uid: i64, score: i64) { } if added { - if lock_and_select("SELECT live_id FROM scores WHERE live_id=?1", params!(id)).is_ok() { - lock_and_exec("UPDATE scores SET score_data=?1 WHERE live_id=?2", params!(json::stringify(result), id)); + if DATABASE.lock_and_select("SELECT live_id FROM scores WHERE live_id=?1", params!(id)).is_ok() { + DATABASE.lock_and_exec("UPDATE scores SET score_data=?1 WHERE live_id=?2", params!(json::stringify(result), id)); } else { - lock_and_exec("INSERT INTO scores (score_data, live_id) VALUES (?1, ?2)", params!(json::stringify(result), id)); + DATABASE.lock_and_exec("INSERT INTO scores (score_data, live_id) VALUES (?1, ?2)", params!(json::stringify(result), id)); } } } pub fn live_completed(id: i64, level: i32, failed: bool, score: i64, uid: i64) { update_live_score(id, uid, score); - match get_live_data(id) { + match DATABASE.get_live_data(id) { Ok(info) => { let value = format!("{}_{}", if 1 == level { "normal" } else if 2 == level { "hard" } else if 3 == level { "expert" } else { "master" }, @@ -214,10 +108,10 @@ pub fn live_completed(id: i64, level: i32, failed: bool, score: i64, uid: i64) { else if 4 == level && failed { info.master_failed } else if 4 == level && !failed { info.master_pass } else { return; }; - lock_and_exec(&format!("UPDATE lives SET {}=?1 WHERE live_id=?2", value), params!(new_info + 1, info.live_id)); + DATABASE.lock_and_exec(&format!("UPDATE lives SET {}=?1 WHERE live_id=?2", value), params!(new_info + 1, info.live_id)); }, Err(_) => { - lock_and_exec("INSERT INTO lives (live_id, normal_failed, normal_pass, hard_failed, hard_pass, expert_failed, expert_pass, master_failed, master_pass) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", params!( + DATABASE.lock_and_exec("INSERT INTO lives (live_id, normal_failed, normal_pass, hard_failed, hard_pass, expert_failed, expert_pass, master_failed, master_pass) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", params!( id, if 1 == level && failed { 1 } else { 0 }, if 1 == level && !failed { 1 } else { 0 }, @@ -257,11 +151,11 @@ fn get_pass_percent(failed: i64, pass: i64) -> String { } fn get_json() -> JsonValue { - let lives = lock_and_select_all("SELECT live_id FROM lives", params!()).unwrap(); + let lives = DATABASE.lock_and_select_all("SELECT live_id FROM lives", params!()).unwrap(); let mut rates = array![]; let mut ids = array![]; for (_i, id) in lives.members().enumerate() { - let info = get_live_data(id.as_i64().unwrap()); + let info = DATABASE.get_live_data(id.as_i64().unwrap()); if !info.is_ok() { continue; } @@ -334,7 +228,7 @@ pub fn ranking(_req: HttpRequest, body: String) -> HttpResponse { let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap(); let live = body["master_live_id"].as_i64().unwrap(); - let info = lock_and_select("SELECT score_data FROM scores WHERE live_id=?1", params!(live)).unwrap_or(String::from("[]")); + let info = DATABASE.lock_and_select("SELECT score_data FROM scores WHERE live_id=?1", params!(live)).unwrap_or(String::from("[]")); let scores = json::parse(&info).unwrap(); let mut rank = array![]; diff --git a/src/router/gree.rs b/src/router/gree.rs index fe6f3f8..52d515f 100644 --- a/src/router/gree.rs +++ b/src/router/gree.rs @@ -4,14 +4,14 @@ use base64::{Engine as _, engine::general_purpose}; use std::collections::HashMap; use sha1::Sha1; use substring::Substring; -use json::object; +use json::{object, JsonValue}; use hmac::{Hmac, Mac}; use crate::router::userdata; use crate::encryption; use crate::router::user::{code_to_uid, uid_to_code}; +use crate::sql::SQLite; -use rusqlite::{Connection, params, ToSql}; -use std::sync::{Mutex, MutexGuard}; +use rusqlite::params; use lazy_static::lazy_static; use uuid::Uuid; @@ -21,85 +21,38 @@ use openssl::hash::MessageDigest; use openssl::sign::Verifier; lazy_static! { - static ref ENGINE: Mutex> = Mutex::new(None); + static ref DATABASE: SQLite = SQLite::new("gree.db"); } -fn init(engine: &mut MutexGuard<'_, Option>) { - let conn = Connection::open("gree.db").unwrap(); - conn.execute("PRAGMA foreign_keys = ON;", ()).unwrap(); - engine.replace(conn); -} -fn lock_and_exec(command: &str, args: &[&dyn ToSql]) { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - conn.execute(command, args).unwrap(); - return; - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} -fn lock_and_select(command: &str, args: &[&dyn ToSql]) -> Result { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - let mut stmt = conn.prepare(command)?; - return stmt.query_row(args, |row| { - match row.get::(0) { - Ok(val) => Ok(val.to_string()), - Err(_) => row.get(0) - } - }); - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} -fn create_store_v2(table: &str) { - lock_and_exec(table, params!()); -} fn uuid_exists(uuid: &str) -> bool { - let data = lock_and_select("SELECT uuid FROM uuids WHERE uuid=?1", params!(uuid)); + let data = DATABASE.lock_and_select("SELECT uuid FROM uuids WHERE uuid=?1", params!(uuid)); data.is_ok() } fn get_new_uuid() -> String { - create_store_v2("CREATE TABLE IF NOT EXISTS uuids ( + DATABASE.create_store_v2("CREATE TABLE IF NOT EXISTS uuids ( uuid TEXT NOT NULL PRIMARY KEY )"); let id = format!("{}", Uuid::new_v4()); if uuid_exists(&id) { return get_new_uuid(); } - lock_and_exec("INSERT INTO uuids (uuid) VALUES (?1)", params!(&id)); + DATABASE.lock_and_exec("INSERT INTO uuids (uuid) VALUES (?1)", params!(&id)); id } pub fn import_user(uid: i64) -> String { let token = get_new_uuid(); - lock_and_exec( + DATABASE.lock_and_exec( "INSERT INTO users (cert, uuid, user_id) VALUES (?1, ?2, ?3)", params!("none", token, uid) ); token } fn update_cert(uid: i64, cert: &str) { - lock_and_exec("UPDATE users SET cert=?1 WHERE user_id=?2", params!(cert, uid)); + DATABASE.lock_and_exec("UPDATE users SET cert=?1 WHERE user_id=?2", params!(cert, uid)); } fn create_acc(cert: &str) -> String { - create_store_v2("CREATE TABLE IF NOT EXISTS users ( + DATABASE.create_store_v2("CREATE TABLE IF NOT EXISTS users ( cert TEXT NOT NULL, uuid TEXT NOT NULL, user_id BIGINT NOT NULL PRIMARY KEY @@ -107,7 +60,7 @@ fn create_acc(cert: &str) -> String { let uuid = get_new_uuid(); let user = userdata::get_acc(&uuid); let user_id = user["user"]["id"].as_i64().unwrap(); - lock_and_exec( + DATABASE.lock_and_exec( "INSERT INTO users (cert, uuid, user_id) VALUES (?1, ?2, ?3)", params!(cert, uuid, user_id) ); @@ -143,7 +96,7 @@ pub fn get_uuid(headers: &HeaderMap, body: &str) -> String { return String::new(); } - let cert = lock_and_select("SELECT cert FROM users WHERE user_id=?1;", params!(uid)).unwrap(); + let cert = DATABASE.lock_and_select("SELECT cert FROM users WHERE user_id=?1;", params!(uid)).unwrap(); let data = format!("{}{}{}{}{}", uid, "sk1bdzb310n0s9tl", version, timestamp, body); let encoded = general_purpose::STANDARD.encode(data.as_bytes()); @@ -151,7 +104,7 @@ pub fn get_uuid(headers: &HeaderMap, body: &str) -> String { let decoded = general_purpose::STANDARD.decode(login).unwrap_or(vec![]); if verify_signature(&decoded, &encoded.as_bytes(), &cert.as_bytes()) { - return lock_and_select("SELECT uuid FROM users WHERE user_id=?1;", params!(uid)).unwrap(); + return DATABASE.lock_and_select("SELECT uuid FROM users WHERE user_id=?1;", params!(uid)).unwrap(); } else { return String::new(); } diff --git a/src/router/userdata/mod.rs b/src/router/userdata/mod.rs index fb3bffa..b043773 100644 --- a/src/router/userdata/mod.rs +++ b/src/router/userdata/mod.rs @@ -1,5 +1,4 @@ -use rusqlite::{Connection, params, ToSql}; -use std::sync::{Mutex, MutexGuard}; +use rusqlite::params; use lazy_static::lazy_static; use json::{JsonValue, array, object}; use crate::router::global; @@ -7,109 +6,29 @@ use uuid::Uuid; use rand::Rng; use sha2::{Digest, Sha256}; use base64::{Engine as _, engine::general_purpose}; +use crate::sql::SQLite; lazy_static! { - static ref ENGINE: Mutex> = Mutex::new(None); + static ref DATABASE: SQLite = SQLite::new("userdata.db"); static ref NEW_USER: JsonValue = { json::parse(include_str!("new_user.json")).unwrap() }; } -fn init(engine: &mut MutexGuard<'_, Option>) { - let conn = Connection::open("userdata.db").unwrap(); - conn.execute("PRAGMA foreign_keys = ON;", ()).unwrap(); - - engine.replace(conn); -} -fn lock_and_exec(command: &str, args: &[&dyn ToSql]) { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - conn.execute(command, args).unwrap(); - return; - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} - -fn lock_and_select(command: &str, args: &[&dyn ToSql]) -> Result { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - let mut stmt = conn.prepare(command)?; - return stmt.query_row(args, |row| { - match row.get::(0) { - Ok(val) => Ok(val.to_string()), - Err(_) => row.get(0) - } - }); - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} -fn lock_and_select_all(command: &str, args: &[&dyn ToSql]) -> Result { - loop { - match ENGINE.lock() { - Ok(mut result) => { - if result.is_none() { - init(&mut result); - } - let conn = result.as_ref().unwrap(); - let mut stmt = conn.prepare(command)?; - let map = stmt.query_map(args, |row| { - match row.get::(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::() { - Ok(v) => rv.push(v).unwrap(), - Err(_) => rv.push(res).unwrap() - }; - } - return Ok(rv); - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(15)); - } - } - } -} -fn create_store_v2(table: &str) { - lock_and_exec(table, params!()); -} - fn create_token_store() { - create_store_v2("CREATE TABLE IF NOT EXISTS tokens ( + DATABASE.create_store_v2("CREATE TABLE IF NOT EXISTS tokens ( user_id BIGINT NOT NULL PRIMARY KEY, token TEXT NOT NULL )"); } fn create_migration_store() { - create_store_v2("CREATE TABLE IF NOT EXISTS migration ( + DATABASE.create_store_v2("CREATE TABLE IF NOT EXISTS migration ( token TEXT NOT NULL PRIMARY KEY, password TEXT NOT NULL )"); } fn create_users_store() { - create_store_v2("CREATE TABLE IF NOT EXISTS users ( + DATABASE.create_store_v2("CREATE TABLE IF NOT EXISTS users ( user_id BIGINT NOT NULL PRIMARY KEY, userdata TEXT NOT NULL, userhome TEXT NOT NULL, @@ -123,7 +42,7 @@ fn create_users_store() { fn acc_exists(uid: i64) -> bool { create_users_store(); - lock_and_select("SELECT user_id FROM users WHERE user_id=?1", params!(uid)).is_ok() + DATABASE.lock_and_select("SELECT user_id FROM users WHERE user_id=?1", params!(uid)).is_ok() } fn get_key(auth_key: &str) -> i64 { let uid = get_uid(&auth_key); @@ -140,7 +59,7 @@ fn get_key(auth_key: &str) -> i64 { key } fn uid_exists(uid: i64) -> bool { - let data = lock_and_select("SELECT user_id FROM users WHERE user_id=?1", params!(uid)); + let data = DATABASE.lock_and_select("SELECT user_id FROM users WHERE user_id=?1", params!(uid)); data.is_ok() } @@ -162,7 +81,7 @@ fn create_acc(uid: i64, login: &str) { new_user["user"]["id"] = uid.into(); new_user["stamina"]["last_updated_time"] = global::timestamp().into(); - lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", params!( + DATABASE.lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", params!( uid, json::stringify(new_user), include_str!("new_user_home.json"), @@ -174,13 +93,13 @@ fn create_acc(uid: i64, login: &str) { )); create_token_store(); - lock_and_exec("DELETE FROM tokens WHERE token=?1", params!(login)); - lock_and_exec("INSERT INTO tokens (user_id, token) VALUES (?1, ?2)", params!(uid, login)); + DATABASE.lock_and_exec("DELETE FROM tokens WHERE token=?1", params!(login)); + DATABASE.lock_and_exec("INSERT INTO tokens (user_id, token) VALUES (?1, ?2)", params!(uid, login)); } fn get_uid(token: &str) -> i64 { create_token_store(); - let data = lock_and_select("SELECT user_id FROM tokens WHERE token = ?1;", params!(token)); + let data = DATABASE.lock_and_select("SELECT user_id FROM tokens WHERE token = ?1;", params!(token)); if !data.is_ok() { return 0; } @@ -190,7 +109,7 @@ fn get_uid(token: &str) -> i64 { fn get_login_token(uid: i64) -> String { create_token_store(); - let data = lock_and_select("SELECT token FROM tokens WHERE user_id=?1", params!(uid)); + let data = DATABASE.lock_and_select("SELECT token FROM tokens WHERE user_id=?1", params!(uid)); if !data.is_ok() { return String::new(); } @@ -200,7 +119,7 @@ fn get_login_token(uid: i64) -> String { fn get_data(auth_key: &str, row: &str) -> JsonValue { let key = get_key(&auth_key); - let result = lock_and_select(&format!("SELECT {} FROM users WHERE user_id=?1", row), params!(key)); + let result = DATABASE.lock_and_select(&format!("SELECT {} FROM users WHERE user_id=?1", row), params!(key)); json::parse(&result.unwrap()).unwrap() } @@ -268,11 +187,11 @@ pub fn get_acc_friends(auth_key: &str) -> JsonValue { pub fn save_data(auth_key: &str, row: &str, data: JsonValue) { let key = get_key(&auth_key); - lock_and_exec(&format!("UPDATE users SET {}=?1 WHERE user_id=?2", row), params!(json::stringify(data), key)); + DATABASE.lock_and_exec(&format!("UPDATE users SET {}=?1 WHERE user_id=?2", row), params!(json::stringify(data), key)); } pub fn save_acc(auth_key: &str, data: JsonValue) { - lock_and_exec("UPDATE users SET friend_request_disabled=?1 WHERE user_id=?2", params!(data["user"]["friend_request_disabled"].as_i32().unwrap(), get_key(&auth_key))); + DATABASE.lock_and_exec("UPDATE users SET friend_request_disabled=?1 WHERE user_id=?2", params!(data["user"]["friend_request_disabled"].as_i32().unwrap(), get_key(&auth_key))); save_data(auth_key, "userdata", data); } pub fn save_acc_home(auth_key: &str, data: JsonValue) { @@ -331,7 +250,7 @@ fn verify_password(password: &str, salted_hash: &str) -> bool { pub fn get_acc_transfer(uid: i64, token: &str, password: &str) -> JsonValue { create_migration_store(); - let data = lock_and_select("SELECT password FROM migration WHERE token=?1", params!(token)); + let data = DATABASE.lock_and_select("SELECT password FROM migration WHERE token=?1", params!(token)); if !data.is_ok() { return object!{success: false}; } @@ -347,8 +266,8 @@ pub fn get_acc_transfer(uid: i64, token: &str, password: &str) -> JsonValue { pub fn save_acc_transfer(token: &str, password: &str) { create_migration_store(); - lock_and_exec("DELETE FROM migration WHERE token=?1", params!(token)); - lock_and_exec("INSERT INTO migration (token, password) VALUES (?1, ?2)", params!(token, hash_password(password))); + DATABASE.lock_and_exec("DELETE FROM migration WHERE token=?1", params!(token)); + DATABASE.lock_and_exec("INSERT INTO migration (token, password) VALUES (?1, ?2)", params!(token, hash_password(password))); } pub fn get_name_and_rank(uid: i64) -> JsonValue { @@ -366,7 +285,7 @@ pub fn get_name_and_rank(uid: i64) -> JsonValue { user_rank: 1 } } - let result = lock_and_select("SELECT userdata FROM users WHERE user_id=?1", params!(uid)); + let result = DATABASE.lock_and_select("SELECT userdata FROM users WHERE user_id=?1", params!(uid)); let data = json::parse(&result.unwrap()).unwrap(); return object!{ @@ -386,7 +305,7 @@ pub fn get_acc_from_uid(uid: i64) -> JsonValue { if uid == 0 || !acc_exists(uid) { return object!{"error": true} } - let result = lock_and_select("SELECT userdata FROM users WHERE user_id=?1", params!(uid)); + let result = DATABASE.lock_and_select("SELECT userdata FROM users WHERE user_id=?1", params!(uid)); json::parse(&result.unwrap()).unwrap() } @@ -396,11 +315,11 @@ pub fn friend_request(uid: i64, requestor: i64) { return; } let uid = get_uid(&login_token); - let friends = lock_and_select("SELECT friends FROM users WHERE user_id=?1", params!(uid)); + let friends = DATABASE.lock_and_select("SELECT friends FROM users WHERE user_id=?1", params!(uid)); let mut friends = json::parse(&friends.unwrap()).unwrap(); if !friends["pending_user_id_list"].contains(requestor) { friends["pending_user_id_list"].push(requestor).unwrap(); - lock_and_exec("UPDATE users SET friends=?1 WHERE user_id=?2", params!(json::stringify(friends), uid)); + DATABASE.lock_and_exec("UPDATE users SET friends=?1 WHERE user_id=?2", params!(json::stringify(friends), uid)); } } @@ -410,7 +329,7 @@ pub fn friend_request_approve(uid: i64, requestor: i64, accepted: bool, key: &st return; } let uid = get_uid(&login_token); - let friends = lock_and_select("SELECT friends FROM users WHERE user_id=?1", params!(uid)); + let friends = DATABASE.lock_and_select("SELECT friends FROM users WHERE user_id=?1", params!(uid)); let mut friends = json::parse(&friends.unwrap()).unwrap(); let index = friends[key].members().into_iter().position(|r| *r.to_string() == requestor.to_string()); if !index.is_none() { @@ -423,7 +342,7 @@ pub fn friend_request_approve(uid: i64, requestor: i64, accepted: bool, key: &st if accepted && !friends["friend_user_id_list"].contains(requestor) { friends["friend_user_id_list"].push(requestor).unwrap(); } - lock_and_exec("UPDATE users SET friends=?1 WHERE user_id=?2", params!(json::stringify(friends), uid)); + DATABASE.lock_and_exec("UPDATE users SET friends=?1 WHERE user_id=?2", params!(json::stringify(friends), uid)); } pub fn friend_request_disabled(uid: i64) -> bool { @@ -432,7 +351,7 @@ pub fn friend_request_disabled(uid: i64) -> bool { return true; } let uid = get_uid(&login_token); - let user = lock_and_select("SELECT userdata FROM users WHERE user_id=?1", params!(uid)); + let user = DATABASE.lock_and_select("SELECT userdata FROM users WHERE user_id=?1", params!(uid)); let user = json::parse(&user.unwrap()).unwrap(); user["user"]["friend_request_disabled"].to_string() == "1" } @@ -443,24 +362,24 @@ pub fn friend_remove(uid: i64, requestor: i64) { return; } let uid = get_uid(&login_token); - let friends = lock_and_select("SELECT friends FROM users WHERE user_id=?1", params!(uid)); + let friends = DATABASE.lock_and_select("SELECT friends FROM users WHERE user_id=?1", params!(uid)); let mut friends = json::parse(&friends.unwrap()).unwrap(); let index = friends["friend_user_id_list"].members().into_iter().position(|r| *r.to_string() == requestor.to_string()); if !index.is_none() { friends["friend_user_id_list"].array_remove(index.unwrap()); } - lock_and_exec("UPDATE users SET friends=?1 WHERE user_id=?2", params!(json::stringify(friends), uid)); + DATABASE.lock_and_exec("UPDATE users SET friends=?1 WHERE user_id=?2", params!(json::stringify(friends), uid)); } pub fn get_random_uids(count: i32) -> JsonValue { if count <= 0 { return array![]; } - lock_and_select_all(&format!("SELECT user_id FROM users WHERE friend_request_disabled=?1 ORDER BY RANDOM() LIMIT {}", count), params!(0)).unwrap() + DATABASE.lock_and_select_all(&format!("SELECT user_id FROM users WHERE friend_request_disabled=?1 ORDER BY RANDOM() LIMIT {}", count), params!(0)).unwrap() } fn create_webui_store() { - create_store_v2("CREATE TABLE IF NOT EXISTS webui ( + DATABASE.create_store_v2("CREATE TABLE IF NOT EXISTS webui ( user_id BIGINT NOT NULL PRIMARY KEY, token TEXT NOT NULL, last_login BIGINT NOT NULL @@ -469,7 +388,7 @@ fn create_webui_store() { fn create_webui_token() -> String { let token = format!("{}", Uuid::new_v4()); - if lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).is_ok() { + if DATABASE.lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).is_ok() { return create_webui_token(); } token @@ -478,7 +397,7 @@ fn create_webui_token() -> String { pub fn webui_login(uid: i64, password: &str) -> Result { create_webui_store(); create_migration_store(); - let pass = lock_and_select("SELECT password FROM migration WHERE token=?1", params!(crate::router::user::uid_to_code(uid.to_string()))).unwrap_or(String::new()); + let pass = DATABASE.lock_and_select("SELECT password FROM migration WHERE token=?1", params!(crate::router::user::uid_to_code(uid.to_string()))).unwrap_or(String::new()); if !verify_password(password, &pass) { if acc_exists(uid) && pass == "" { return Err(String::from("Migration token not set. Set token in game settings.")); @@ -488,8 +407,8 @@ pub fn webui_login(uid: i64, password: &str) -> Result { let new_token = create_webui_token(); - lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid)); - lock_and_exec("INSERT INTO webui (user_id, token, last_login) VALUES (?1, ?2, ?3)", params!(uid, new_token, global::timestamp())); + DATABASE.lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid)); + DATABASE.lock_and_exec("INSERT INTO webui (user_id, token, last_login) VALUES (?1, ?2, ?3)", params!(uid, new_token, global::timestamp())); Ok(new_token) } @@ -509,7 +428,7 @@ pub fn webui_import_user(user: JsonValue) -> Result { user["sif_cards"] = array![]; } - lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", params!( + DATABASE.lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", params!( uid, json::stringify(user["userdata"].clone()), json::stringify(user["home"].clone()), @@ -527,7 +446,7 @@ pub fn webui_import_user(user: JsonValue) -> Result { token = format!("{}", Uuid::new_v4()); } - lock_and_exec("INSERT INTO tokens (user_id, token) VALUES (?1, ?2)", params!(uid, token)); + DATABASE.lock_and_exec("INSERT INTO tokens (user_id, token) VALUES (?1, ?2)", params!(uid, token)); let mig = crate::router::user::uid_to_code(uid.to_string()); save_acc_transfer(&mig, &user["password"].to_string()); @@ -539,7 +458,7 @@ pub fn webui_import_user(user: JsonValue) -> Result { } fn webui_login_token(token: &str) -> Option { - let uid = lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).unwrap_or(String::new()); + let uid = DATABASE.lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).unwrap_or(String::new()); if uid == String::new() || token == "" { return None; } @@ -547,14 +466,14 @@ fn webui_login_token(token: &str) -> Option { if uid == 0 { return None; } - let last_login = lock_and_select("SELECT last_login FROM webui WHERE user_id=?1", params!(uid)).unwrap_or(String::new()).parse::().unwrap_or(0); + let last_login = DATABASE.lock_and_select("SELECT last_login FROM webui WHERE user_id=?1", params!(uid)).unwrap_or(String::new()).parse::().unwrap_or(0); let limit = 24 * 60 * 60; //1 day //Expired token if (global::timestamp() as i64) > last_login + limit { - lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid)); + DATABASE.lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid)); return None; } - let login_token = lock_and_select("SELECT token FROM tokens WHERE user_id=?1", params!(uid)).unwrap_or(String::new()); + let login_token = DATABASE.lock_and_select("SELECT token FROM tokens WHERE user_id=?1", params!(uid)).unwrap_or(String::new()); if login_token == String::new() { return None; } @@ -595,5 +514,5 @@ pub fn webui_start_loginbonus(bonus_id: i64, token: &str) -> JsonValue { } pub fn webui_logout(token: &str) { - lock_and_exec("DELETE FROM webui WHERE token=?1", params!(token)); + DATABASE.lock_and_exec("DELETE FROM webui WHERE token=?1", params!(token)); } diff --git a/src/sql.rs b/src/sql.rs new file mode 100644 index 0000000..199593e --- /dev/null +++ b/src/sql.rs @@ -0,0 +1,107 @@ +use rusqlite::{Connection, params, ToSql}; +use std::sync::Mutex; +use json::{JsonValue, array}; +use crate::router::clear_rate::Live; + +pub struct SQLite { + engine: Mutex, + sleep_duration: u64 +} + +impl SQLite { + pub fn new(path: &str) -> SQLite { + let conn = Connection::open(path).unwrap(); + conn.execute("PRAGMA foreign_keys = ON;", ()).unwrap(); + + SQLite { + engine: Mutex::new(conn), + sleep_duration: 10 + } + } + pub fn lock_and_exec(&self, command: &str, args: &[&dyn ToSql]) { + loop { + match self.engine.lock() { + Ok(conn) => { + conn.execute(command, args).unwrap(); + return; + } + Err(_) => { + std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration)); + } + } + } + } + pub fn lock_and_select(&self, command: &str, args: &[&dyn ToSql]) -> Result { + loop { + match self.engine.lock() { + Ok(conn) => { + let mut stmt = conn.prepare(command)?; + return stmt.query_row(args, |row| { + match row.get::(0) { + Ok(val) => Ok(val.to_string()), + Err(_) => row.get(0) + } + }); + } + Err(_) => { + std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration)); + } + } + } + } + pub fn lock_and_select_all(&self, command: &str, args: &[&dyn ToSql]) -> Result { + loop { + match self.engine.lock() { + Ok(conn) => { + let mut stmt = conn.prepare(command)?; + let map = stmt.query_map(args, |row| { + match row.get::(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::() { + Ok(v) => rv.push(v).unwrap(), + Err(_) => rv.push(res).unwrap() + }; + } + return Ok(rv); + } + Err(_) => { + std::thread::sleep(std::time::Duration::from_millis(self.sleep_duration)); + } + } + } + } + pub fn get_live_data(&self, id: i64) -> Result { + loop { + match self.engine.lock() { + Ok(conn) => { + let mut stmt = conn.prepare("SELECT * FROM lives WHERE live_id=?1")?; + return Ok(stmt.query_row(params!(id), |row| { + Ok(Live { + live_id: row.get(0)?, + normal_failed: row.get(1)?, + normal_pass: row.get(2)?, + hard_failed: row.get(3)?, + hard_pass: row.get(4)?, + expert_failed: row.get(5)?, + expert_pass: row.get(6)?, + master_failed: row.get(7)?, + master_pass: row.get(8)?, + }) + })?); + } + Err(_) => { + 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!()); + } +}