ErrorNoInternet/button
1
0
Fork 0
forked from deadvey/button
Code Pull Requests Activity

perf: remove arc clones, general clones, and unnecessary regex

Browse Source
This commit is contained in:
javalsai
2026-05-30 06:26:35 +02:00
parent e55b698cb3
commit a183b33ce8
4 changed files with 179 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
-39
View File
@@ -2,15 +2,6 @@
# It is not intended for manual editing. # It is not intended for manual editing.
version = 4 version = 4
[[package]]
name = "aho-corasick"
version = "1.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
dependencies = [
"memchr",
]
[[package]] [[package]]
name = "anyhow" name = "anyhow"
version = "1.0.102" version = "1.0.102"
@@ -106,7 +97,6 @@ dependencies = [
"axum", "axum",
"futures", "futures",
"rand 0.10.1", "rand 0.10.1",
"regex",
"serde", "serde",
"serde_json", "serde_json",
"tokio", "tokio",
@@ -677,35 +667,6 @@ dependencies = [
"bitflags", "bitflags",
] ]
[[package]]
name = "regex"
version = "1.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
dependencies = [
"aho-corasick",
"memchr",
"regex-automata",
"regex-syntax",
]
[[package]]
name = "regex-automata"
version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax",
]
[[package]]
name = "regex-syntax"
version = "0.8.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
[[package]] [[package]]
name = "ryu" name = "ryu"
version = "1.0.23" version = "1.0.23"
Cargo.toml
-1
View File
@@ -7,7 +7,6 @@ edition = "2024"
axum = {version="0.8.9",features=["ws"]} axum = {version="0.8.9",features=["ws"]}
futures = "0.3.32" futures = "0.3.32"
rand = "0.10.1" rand = "0.10.1"
regex = "1.12.3"
serde = {version="1.0.228",features=["derive"]} serde = {version="1.0.228",features=["derive"]}
serde_json = "1.0.149" serde_json = "1.0.149"
tokio = {version="1.52.3",features=["full"]} tokio = {version="1.52.3",features=["full"]}
rustfmt.toml
+1
View File
@@ -0,0 +1 @@
hard_tabs = true
src/main.rs
+178 -141
View File
@@ -3,6 +3,7 @@ use std::{
fs, fs,
io::Write, io::Write,
sync::{Arc, Mutex, mpsc}, sync::{Arc, Mutex, mpsc},
ops::{Deref, DerefMut},
}; };
use axum::{ use axum::{
@@ -14,77 +15,91 @@ use axum::{
response::{Html, IntoResponse}, response::{Html, IntoResponse},
routing::get, routing::get,
}; };
use futures::StreamExt as _; use futures::{StreamExt as _};
use rand::random_bool; use rand::random_bool;
use regex::Regex; use serde::{Deserialize, Serialize, de};
use serde::{Deserialize, Serialize};
use serde_json::json; use serde_json::json;
use tokio::time::{Duration, sleep}; use tokio::time::{Duration, sleep};
#[derive(Deserialize,Serialize,Debug,Ord,Eq,PartialEq,PartialOrd,Clone)] #[derive(Deserialize, Serialize, Debug, Ord, Eq, PartialEq, PartialOrd, Clone)]
struct Entry struct Entry {
{
score: u32, score: u32,
person: String, person: String,
} }
enum Leaderboard
{
Hiscores,
Loscores,
Pingscores,
}
#[derive(Clone)] #[derive(Clone)]
struct AppState { struct AppState {
tx: mpsc::Sender<(Entry,Leaderboard)>, tx: mpsc::Sender<LeaderboardUpdate>,
hiscores: Arc<Mutex<Vec<Entry>>>, hiscores: Arc<Mutex<Vec<Entry>>>,
loscores: Arc<Mutex<Vec<Entry>>>, loscores: Arc<Mutex<Vec<Entry>>>,
pingscores: Arc<Mutex<HashMap<String,(u64,u32)>>>, // u64 is reset count and u32 is PB pingscores: Arc<Mutex<HashMap<String,(u64,u32)>>>, // u64 is reset count and u32 is PB
} }
struct LeaderboardUpdate {
name: Arc<str>,
update: LeaderboardUpdateType,
}
enum LeaderboardUpdateType {
Reset { hiscore_pingscore: u32 },
Increment { loscore: u32 },
}
static CHANCE: f64 = 1.0/3.0; static CHANCE: f64 = 1.0/3.0;
const PATH_HISCORES: &str = "hiscores.json";
const PATH_LOSCORES: &str = "loscores.json";
const PATH_PINGSCORES: &str = "pingscores.json";
#[tokio::main] #[tokio::main]
async fn main() { async fn main() {
let file_contents: String = fs::read_to_string("hiscores.json").unwrap(); fn read_file<T: for<'de> de::Deserialize<'de>>(file_path: &str) -> Arc<Mutex<T>> {
let hiscores: Arc<Mutex<Vec<Entry>>> = Arc::new(Mutex::new(serde_json::from_str(&file_contents).unwrap())); let file_contents: String = fs::read_to_string(file_path).unwrap();
let file_contents: String = fs::read_to_string("loscores.json").unwrap(); Arc::new(Mutex::new(serde_json::from_str(&file_contents).unwrap()))
let loscores: Arc<Mutex<Vec<Entry>>> = Arc::new(Mutex::new(serde_json::from_str(&file_contents).unwrap())); }
let file_contents: String = fs::read_to_string("pingscores.json").unwrap();
let pingscores: Arc<Mutex<HashMap<String,(u64,u32)>>> = Arc::new(Mutex::new(serde_json::from_str(&file_contents).unwrap()));
let hiscore_clone1 = Arc::clone(&hiscores);
let loscore_clone1 = Arc::clone(&loscores);
let pingscore_clone1 = Arc::clone(&pingscores);
let (tx, rx) = mpsc::channel::<(Entry,Leaderboard)>(); let hiscores: Arc<Mutex<Vec<Entry>>> = read_file(PATH_HISCORES);
let loscores: Arc<Mutex<Vec<Entry>>> = read_file(PATH_LOSCORES);
let pingscores: Arc<Mutex<HashMap<String, (u64, u32)>>> = read_file(PATH_PINGSCORES);
tokio::spawn( let (tx, rx) = mpsc::channel::<LeaderboardUpdate>();
async move {
handle_hiscores(rx, hiscore_clone1, loscore_clone1, pingscore_clone1); {
} let (hiscores, loscores, pingscores) =
); (hiscores.clone(), loscores.clone(), pingscores.clone());
let pingscore_clone2 = Arc::clone(&pingscores); tokio::spawn(async move {
tokio::spawn( handle_hiscores(rx, &hiscores, &loscores, &pingscores);
async move { });
loop // write pingscores every 30s }
{
sleep(Duration::from_millis(30000)).await; {
let pingscores = pingscore_clone2.lock().unwrap(); let pingscores = pingscores.clone();
let file_contents: String = serde_json::to_string(&pingscores.clone()).unwrap(); tokio::spawn(
drop(pingscores); async move {
let mut file = fs::OpenOptions::new().write(true).truncate(true).open("pingscores.json").unwrap(); loop // write pingscores every 30s
file.write_all(file_contents.as_bytes()).unwrap(); {
file.flush().unwrap(); sleep(Duration::from_millis(30000)).await;
let pingscores = pingscores.lock().unwrap();
let file_contents: String = serde_json::to_string(&pingscores.clone()).unwrap();
drop(pingscores);
let mut file = fs::OpenOptions::new().write(true).truncate(true).open(PATH_PINGSCORES).unwrap();
file.write_all(file_contents.as_bytes()).unwrap();
file.flush().unwrap();
}
} }
} );
); }
let state = AppState { tx,hiscores: Arc::clone(&hiscores),loscores: Arc::clone(&loscores), pingscores: Arc::clone(&pingscores)};
let app = Router::new() let app = Router::new()
.route("/", get(index)) .route("/", get(index))
.route("/ws", get(ws_handler)) .route("/ws", get(ws_handler))
.route("/leaderboard", get(leaderboard)) .route("/leaderboard", get(leaderboard))
.with_state(state); .with_state(AppState {
tx,
hiscores: Arc::clone(&hiscores),
loscores: Arc::clone(&loscores),
pingscores: Arc::clone(&pingscores),
});
let listener = tokio::net::TcpListener::bind("0.0.0.0:8084") let listener = tokio::net::TcpListener::bind("0.0.0.0:8084")
.await .await
@@ -103,66 +118,85 @@ async fn leaderboard() -> Html<&'static str> {
Html(include_str!("../leaderboard.html")) Html(include_str!("../leaderboard.html"))
} }
// receiver: 0 for hiscore, 1 for loscore, 2 for pingscore // receiver: 0 for hiscore, 1 for loscore, 2 for pingscore
fn handle_hiscores(rx: mpsc::Receiver<(Entry, Leaderboard)>, hiscores_arc: Arc<Mutex<Vec<Entry>>>, loscores_arc: Arc<Mutex<Vec<Entry>>>,pingscores_arc: Arc<Mutex<HashMap<String,(u64,u32)>>>,) fn handle_hiscores(
{ rx: mpsc::Receiver<LeaderboardUpdate>,
hiscores: &Mutex<Vec<Entry>>,
loscores: &Mutex<Vec<Entry>>,
pingscores: &Mutex<HashMap<String, (u64, u32)>>,
) {
fn update_scoretable<G: Deref<Target = Vec<Entry>> + DerefMut>(
score_name: &str,
mut scoretable: G,
name: &str,
score: u32,
file_path: &str,
) {
if scoretable.last().is_none_or(|e| score > e.score) {
println!("New {score_name} {score} by {name}");
scoretable.push(Entry {
score,
person: name.to_string(),
});
scoretable.sort();
scoretable.reverse();
scoretable.truncate(20);
let file_contents: String = serde_json::to_string(&*scoretable).unwrap();
drop(scoretable);
let mut file = fs::OpenOptions::new()
.write(true)
.truncate(true)
.open(file_path)
.unwrap();
file.write_all(file_contents.as_bytes()).unwrap();
file.flush().unwrap();
}
}
// Panic galore // Panic galore
let mut hiscores = hiscores_arc.lock().unwrap(); let mut hiscores_lock = hiscores.lock().unwrap();
hiscores.sort(); hiscores_lock.sort();
hiscores.reverse(); hiscores_lock.reverse();
let file_contents: String = serde_json::to_string(&hiscores.clone()).unwrap(); let file_contents: String = serde_json::to_string(&hiscores_lock.clone()).unwrap();
drop(hiscores); drop(hiscores_lock);
let mut file = fs::OpenOptions::new().write(true).truncate(true).open("hiscores.json").unwrap(); let mut file = fs::OpenOptions::new().write(true).truncate(true).open(PATH_HISCORES).unwrap();
file.write_all(file_contents.as_bytes()).unwrap(); file.write_all(file_contents.as_bytes()).unwrap();
file.flush().unwrap(); drop(file);
loop
{ loop {
match rx.recv() let LeaderboardUpdate { name, update } = rx.recv().expect("channel error");
{
Ok((new_entry,Leaderboard::Hiscores)) => match update {
{ LeaderboardUpdateType::Reset { hiscore_pingscore } => {
let mut hiscores = hiscores_arc.lock().unwrap(); // Hiscore
if hiscores.get(19).is_none_or(|hiscore| new_entry.score > hiscore.score) { update_scoretable(
println!("New hiscore {new_entry:?}"); "hiscore",
hiscores.push(new_entry); hiscores.lock().unwrap(),
hiscores.sort(); &name,
hiscores.reverse(); hiscore_pingscore,
hiscores.truncate(20); PATH_HISCORES,
let file_contents: String = serde_json::to_string(&hiscores.clone()).unwrap(); );
drop(hiscores);
let mut file = fs::OpenOptions::new().write(true).truncate(true).open("hiscores.json").unwrap(); // Pingscore
file.write_all(file_contents.as_bytes()).unwrap(); let mut pingscores = pingscores.lock().unwrap();
file.flush().unwrap(); if hiscore_pingscore > pingscores.get(&*name).unwrap_or(&(0, 0)).1
} // pb
},
Ok((new_entry,Leaderboard::Loscores)) =>
{
let mut loscores = loscores_arc.lock().unwrap();
if loscores.get(19).is_none_or(|loscore| new_entry.score > loscore.score) {
println!("New loscore {new_entry:?}");
loscores.push(new_entry);
loscores.sort();
loscores.reverse();
loscores.truncate(20);
let file_contents: String = serde_json::to_string(&loscores.clone()).unwrap();
drop(loscores);
let mut file = fs::OpenOptions::new().write(true).truncate(true).open("loscores.json").unwrap();
file.write_all(file_contents.as_bytes()).unwrap();
file.flush().unwrap();
}
},
Ok((new_entry,Leaderboard::Pingscores)) =>
{
let name = new_entry.person;
let mut pingscores = pingscores_arc.lock().unwrap();
if new_entry.score > pingscores.get(&name).unwrap_or(&(0,0)).1 // pb
{ {
pingscores.entry(name.clone()).or_insert((0,0)).1 = new_entry.score; pingscores.entry(name.to_string()).or_insert((0, 0)).1 = hiscore_pingscore;
println!("{name} new PB: {}",new_entry.score); println!("{name} new PB: {hiscore_pingscore}");
}; };
pingscores.entry(name.clone()).or_insert((0,0)).0 += 1; // reset count pingscores.entry(name.to_string()).or_insert((0, 0)).0 += 1; // reset count
drop(pingscores); drop(pingscores);
} }
Err(error) => println!("{error}"),
LeaderboardUpdateType::Increment { loscore } => {
update_scoretable(
"loscore",
loscores.lock().unwrap(),
&name,
loscore,
PATH_LOSCORES,
);
}
} }
} }
} }
@@ -171,40 +205,46 @@ async fn ws_handler(
ws: WebSocketUpgrade, ws: WebSocketUpgrade,
State(state): State<AppState>, State(state): State<AppState>,
) -> impl IntoResponse { ) -> impl IntoResponse {
ws.on_upgrade(move |socket| { ws.on_upgrade(|socket| async move {
let tx = state.tx.clone(); handle_socket(
let hiscores = Arc::clone(&state.hiscores); socket,
let loscores = Arc::clone(&state.loscores); &state.tx,
let pingscores = Arc::clone(&state.pingscores); &state.hiscores,
async move { &state.loscores,
handle_socket(socket, tx, hiscores, loscores, pingscores).await; &state.pingscores,
} )
.await;
}) })
} }
async fn handle_socket async fn handle_socket(
(
mut socket: WebSocket, mut socket: WebSocket,
tx: mpsc::Sender<(Entry,Leaderboard)>, tx: &mpsc::Sender<LeaderboardUpdate>,
hiscores_arc: Arc<Mutex<Vec<Entry>>>, hiscores: &Mutex<Vec<Entry>>,
loscores_arc: Arc<Mutex<Vec<Entry>>>, loscores: &Mutex<Vec<Entry>>,
pingscores_arc: Arc<Mutex<HashMap<String,(u64,u32)>>>, pingscores: &Mutex<HashMap<String,(u64,u32)>>,
) { ) {
let mut value: u32 = 0; let mut value: u32 = 0;
let msg =
{ let msg = {
let hiscores = hiscores_arc.lock().unwrap(); let hiscores = hiscores.lock().unwrap();
let loscores = loscores_arc.lock().unwrap(); let loscores = loscores.lock().unwrap();
let pingscores = pingscores_arc.lock().unwrap(); let pingscores = pingscores.lock().unwrap();
json!({ "hiscores": &*hiscores, "loscores": &*loscores, "pingscores": &*pingscores}).to_string() json!({ "hiscores": &*hiscores, "loscores": &*loscores, "pingscores": &*pingscores}).to_string()
}; };
let name_message = socket.next().await.unwrap().unwrap();
let name: String = match name_message let name: Arc<str> = match socket.next().await.unwrap().unwrap() {
{ Message::Text(text)
Message::Text(text) => validate_name(text.to_string()), if let text = text.to_string()
_ => "anon".to_string(), && validate_name(&text) =>
{
Arc::from(text.into_boxed_str())
}
_ => Arc::from("anon"),
}; };
println!("Client connected: {name}"); println!("Client connected: {name}");
let mut resets: u32 = 0; let mut resets: u32 = 0;
let mut prev: u32 = 0; let mut prev: u32 = 0;
@@ -216,15 +256,24 @@ async fn handle_socket
match msg { match msg {
Ok(Message::Text(_)) => { Ok(Message::Text(_)) => {
if random_bool(CHANCE) { // reset if random_bool(CHANCE) { // reset
let _ = tx.send((Entry{ person: name.clone(), score: value },Leaderboard::Hiscores)); //hiscores let _ = tx.send(LeaderboardUpdate {
let _ = tx.send((Entry{ person: name.clone(), score: value },Leaderboard::Pingscores)); //pingscores name: name.clone(),
update: LeaderboardUpdateType::Reset {
hiscore_pingscore: value,
},
});
resets += 1; resets += 1;
value = 0 value = 0
} // 1/3 chance of failing } // 1/3 chance of failing
else { else {
value += 1; value += 1;
if prev == 0 { if prev == 0 {
let _ = tx.send((Entry{ person: name.clone(), score: resets },Leaderboard::Loscores));//loscores let _ = tx.send(LeaderboardUpdate {
name: name.clone(),
update: LeaderboardUpdateType::Increment {
loscore: resets,
},
});
resets = 0; resets = 0;
} }
} }
@@ -241,25 +290,13 @@ async fn handle_socket
} }
} }
fn validate_name(input: &str) -> bool {
fn validate_name(input: String) -> String {
let input = input.trim(); let input = input.trim();
if input == "null"
{
return "anon".to_string();
}
// Length check // Length check
if input.is_empty() || input.len() > 32 { if input.is_empty() || input.len() > 32 {
return "anon".to_string(); return false;
} }
// Allow only letters, numbers, _ and - input.chars().all(|c| c.is_ascii_alphanumeric())
let re = Regex::new(r"^[a-zA-Z0-9_-]+$").unwrap();
if re.is_match(input) {
input.to_string()
} else {
"anon".to_string()
}
} }