416 lines
13 KiB
Rust
416 lines
13 KiB
Rust
use axum::{
|
|
extract::{Path, Query, State},
|
|
response::{Html, IntoResponse},
|
|
};
|
|
use chrono::{DateTime, Utc};
|
|
use reqwest::StatusCode;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{collections::HashMap, sync::Arc};
|
|
use tera::Context;
|
|
|
|
use crate::{AppState, TEMPLATES};
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct SortParams {
|
|
pub sort: Option<String>,
|
|
pub order: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct Report {
|
|
pub id: u64,
|
|
pub mac_address: String,
|
|
pub timestamp: String,
|
|
pub slimes: HashMap<String, Vec<String>>,
|
|
pub benchmark: Benchmark,
|
|
pub client_version: String,
|
|
pub signature: String,
|
|
}
|
|
|
|
#[derive(serde::Serialize)]
|
|
pub struct ReportRow {
|
|
pub id: u64,
|
|
pub score: u64,
|
|
pub single_score: u64,
|
|
pub multi_score: u64,
|
|
pub cores: u32,
|
|
pub ram: String,
|
|
pub ram_raw: f32,
|
|
pub os: String,
|
|
pub hostname: String,
|
|
pub time_ago: String,
|
|
pub timestamp: String,
|
|
pub signature: String,
|
|
pub is_new: bool,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct Benchmark {
|
|
pub logical_cores: u32,
|
|
pub multi_thread: ScoreDetail,
|
|
pub single_thread: ScoreDetail,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct ScoreDetail {
|
|
pub score: u64,
|
|
}
|
|
|
|
fn format_time_ago(timestamp: &str) -> String {
|
|
let Ok(ts) = DateTime::parse_from_rfc3339(timestamp) else {
|
|
return "unknown".into();
|
|
};
|
|
let now = Utc::now();
|
|
let diff = now.signed_duration_since(ts.with_timezone(&Utc));
|
|
|
|
if diff.num_days() > 0 {
|
|
format!("{}d ago", diff.num_days())
|
|
} else if diff.num_hours() > 0 {
|
|
format!("{}h ago", diff.num_hours())
|
|
} else if diff.num_minutes() > 0 {
|
|
format!("{}min ago", diff.num_minutes())
|
|
} else {
|
|
"just now".into()
|
|
}
|
|
}
|
|
|
|
fn is_recent(timestamp: &str) -> bool {
|
|
DateTime::parse_from_rfc3339(timestamp)
|
|
.map(|ts| {
|
|
let now = Utc::now();
|
|
let diff = now.signed_duration_since(ts.with_timezone(&Utc));
|
|
diff.num_hours() < 24 && diff.num_seconds() >= 0
|
|
})
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
fn parse_total_ram(ram_str: &str) -> String {
|
|
let total_part = ram_str.split('/').last().unwrap_or("").trim();
|
|
let digits: String = total_part.chars().filter(|c| c.is_ascii_digit()).collect();
|
|
if let Ok(mb) = digits.parse::<f32>() {
|
|
format!("{}GB", (mb / 1024.0).round())
|
|
} else {
|
|
"Unknown".into()
|
|
}
|
|
}
|
|
|
|
fn parse_total_ram_raw(ram_str: &str) -> f32 {
|
|
let total_part = ram_str.split('/').last().unwrap_or("").trim();
|
|
let digits: String = total_part.chars().filter(|c| c.is_ascii_digit()).collect();
|
|
digits.parse::<f32>().unwrap_or(0.0) / 1024.0
|
|
}
|
|
|
|
pub async fn home_handler(
|
|
State(state): State<Arc<AppState>>,
|
|
Query(params): Query<SortParams>,
|
|
) -> Result<impl IntoResponse, (StatusCode, String)> {
|
|
let response = reqwest::get("https://alatreon.org/slimes?limit=1000")
|
|
.await
|
|
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
|
|
|
let raw_reports = response.json::<Vec<Report>>().await.map_err(|e| {
|
|
(
|
|
StatusCode::INTERNAL_SERVER_ERROR,
|
|
format!("JSON Error: {}", e),
|
|
)
|
|
})?;
|
|
|
|
let mut reports: Vec<ReportRow> = raw_reports
|
|
.into_iter()
|
|
.map(|s| ReportRow {
|
|
id: s.id,
|
|
score: (s.benchmark.multi_thread.score + s.benchmark.single_thread.score) / 2,
|
|
single_score: s.benchmark.single_thread.score,
|
|
multi_score: s.benchmark.multi_thread.score,
|
|
cores: s.benchmark.logical_cores,
|
|
ram: s
|
|
.slimes
|
|
.get("RAM")
|
|
.and_then(|v| v.first())
|
|
.map(|r| parse_total_ram(r))
|
|
.unwrap_or_else(|| "-".into()),
|
|
ram_raw: s
|
|
.slimes
|
|
.get("RAM")
|
|
.and_then(|v| v.first())
|
|
.map(|r| parse_total_ram_raw(r))
|
|
.unwrap_or_else(|| 0.0),
|
|
os: s
|
|
.slimes
|
|
.get("OS")
|
|
.and_then(|v| v.first())
|
|
.cloned()
|
|
.unwrap_or_else(|| "Unknown".into()),
|
|
hostname: s
|
|
.slimes
|
|
.get("Hostname")
|
|
.and_then(|v| v.first())
|
|
.cloned()
|
|
.unwrap_or_else(|| "-".into()),
|
|
signature: s.signature,
|
|
timestamp: s.timestamp.clone(),
|
|
time_ago: format_time_ago(&s.timestamp),
|
|
is_new: is_recent(&s.timestamp),
|
|
})
|
|
.collect();
|
|
|
|
let sort_field = params.sort.unwrap_or_else(|| "score".to_string());
|
|
let order = params.order.unwrap_or_else(|| "desc".to_string());
|
|
reports.sort_by(|a, b| {
|
|
let cmp = match sort_field.as_str() {
|
|
"single" => a.single_score.cmp(&b.single_score),
|
|
"multi" => a.multi_score.cmp(&b.multi_score),
|
|
"ram" => a
|
|
.ram_raw
|
|
.partial_cmp(&b.ram_raw)
|
|
.unwrap_or(std::cmp::Ordering::Equal),
|
|
"threads" => a.cores.cmp(&b.cores),
|
|
"time" => a.timestamp.cmp(&b.timestamp),
|
|
_ => a.score.cmp(&b.score),
|
|
};
|
|
if order == "asc" { cmp } else { cmp.reverse() }
|
|
});
|
|
|
|
let mut context = Context::new();
|
|
context.insert("reports", &reports);
|
|
context.insert("title", &state.app_name);
|
|
context.insert("current_sort", &sort_field);
|
|
context.insert("current_order", &order);
|
|
context.insert("current_page", "leaderboard");
|
|
context.insert("prefix", "");
|
|
|
|
match TEMPLATES.render("index.html", &context) {
|
|
Ok(html) => Ok(Html(html)),
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
pub async fn report_details_handler(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(id): Path<u64>,
|
|
) -> Result<impl IntoResponse, (StatusCode, String)> {
|
|
let url = format!("https://alatreon.org/slimes/{}", id);
|
|
|
|
let report = reqwest::get(url)
|
|
.await
|
|
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
|
|
.json::<Report>()
|
|
.await
|
|
.map_err(|e| (StatusCode::NOT_FOUND, format!("Report not found: {}", e)))?;
|
|
|
|
let mut context = Context::new();
|
|
context.insert("report", &report);
|
|
context.insert("title", &format!("Report #{} | {}", id, state.app_name));
|
|
context.insert("time_ago", &format_time_ago(&report.timestamp));
|
|
context.insert(
|
|
"score",
|
|
&((report.benchmark.multi_thread.score + report.benchmark.single_thread.score) / 2),
|
|
);
|
|
context.insert("current_page", "details");
|
|
context.insert("prefix", "../");
|
|
|
|
match TEMPLATES.render("details.html", &context) {
|
|
Ok(html) => Ok(Html(html)),
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
async fn get_processed_reports() -> Result<Vec<ReportRow>, (StatusCode, String)> {
|
|
let response = reqwest::get("https://alatreon.org/slimes?limit=10000")
|
|
.await
|
|
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
|
|
|
let raw_reports = response.json::<Vec<Report>>().await.map_err(|e| {
|
|
(
|
|
StatusCode::INTERNAL_SERVER_ERROR,
|
|
format!("JSON Error: {}", e),
|
|
)
|
|
})?;
|
|
|
|
Ok(raw_reports
|
|
.into_iter()
|
|
.map(|s| {
|
|
let ram_raw = s
|
|
.slimes
|
|
.get("RAM")
|
|
.and_then(|v| v.first())
|
|
.map(|r| parse_total_ram_raw(r))
|
|
.unwrap_or(0.0);
|
|
ReportRow {
|
|
id: s.id,
|
|
score: (s.benchmark.multi_thread.score + s.benchmark.single_thread.score) / 2,
|
|
single_score: s.benchmark.single_thread.score,
|
|
multi_score: s.benchmark.multi_thread.score,
|
|
cores: s.benchmark.logical_cores,
|
|
ram: s
|
|
.slimes
|
|
.get("RAM")
|
|
.and_then(|v| v.first())
|
|
.map(|r| parse_total_ram(r))
|
|
.unwrap_or_else(|| "-".into()),
|
|
ram_raw,
|
|
os: s
|
|
.slimes
|
|
.get("OS")
|
|
.and_then(|v| v.first())
|
|
.cloned()
|
|
.unwrap_or_else(|| "Unknown".into()),
|
|
hostname: s
|
|
.slimes
|
|
.get("Hostname")
|
|
.and_then(|v| v.first())
|
|
.cloned()
|
|
.unwrap_or_else(|| "-".into()),
|
|
signature: s.signature,
|
|
timestamp: s.timestamp.clone(),
|
|
time_ago: format_time_ago(&s.timestamp),
|
|
is_new: is_recent(&s.timestamp),
|
|
}
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
pub struct AnalyticsData {
|
|
pub os_labels: Vec<String>,
|
|
pub os_scores: Vec<u64>,
|
|
pub os_max_labels: Vec<String>,
|
|
pub os_max_scores: Vec<u64>,
|
|
pub os_min_labels: Vec<String>,
|
|
pub os_min_scores: Vec<u64>,
|
|
pub os_count_labels: Vec<String>,
|
|
pub os_count_values: Vec<u32>,
|
|
pub dist_labels: Vec<String>,
|
|
pub dist_counts: Vec<u32>,
|
|
pub avg_score_per_gb: f32,
|
|
pub avg_score_per_thread: f32,
|
|
pub total_reports: usize,
|
|
}
|
|
|
|
pub async fn analytics_handler(
|
|
State(state): State<Arc<AppState>>,
|
|
) -> Result<impl IntoResponse, (StatusCode, String)> {
|
|
let reports = get_processed_reports().await?;
|
|
if reports.is_empty() {
|
|
return Err((StatusCode::NOT_FOUND, "No data available".into()));
|
|
}
|
|
|
|
// Average score per OS
|
|
let mut os_map: HashMap<String, (u64, u32)> = HashMap::new();
|
|
for r in &reports {
|
|
let entry = os_map.entry(r.os.clone()).or_insert((0, 0));
|
|
entry.0 += r.score;
|
|
entry.1 += 1;
|
|
}
|
|
let mut os_stats: Vec<(String, u64)> = os_map
|
|
.clone()
|
|
.into_iter()
|
|
.map(|(os, (sum, count))| (os, sum / count as u64))
|
|
.collect();
|
|
os_stats.sort_by(|a, b| b.1.cmp(&a.1));
|
|
|
|
// Highest score per OS
|
|
let mut os_max_map: HashMap<String, u64> = HashMap::new();
|
|
for r in &reports {
|
|
let entry = os_max_map.entry(r.os.clone()).or_insert(0);
|
|
if r.score > *entry {
|
|
*entry = r.score;
|
|
}
|
|
}
|
|
let mut os_max_stats: Vec<(String, u64)> = os_max_map.into_iter().collect();
|
|
os_max_stats.sort_by(|a, b| b.1.cmp(&a.1));
|
|
|
|
// Lowest score per OS
|
|
let mut os_min_map: HashMap<String, u64> = HashMap::new();
|
|
for r in &reports {
|
|
os_min_map
|
|
.entry(r.os.clone())
|
|
.and_modify(|e| {
|
|
if r.score < *e {
|
|
*e = r.score;
|
|
}
|
|
})
|
|
.or_insert(r.score);
|
|
}
|
|
|
|
let mut os_min_stats: Vec<(String, u64)> = os_min_map.into_iter().collect();
|
|
os_min_stats.sort_by(|a, b| b.1.cmp(&a.1));
|
|
|
|
// Count of each OS
|
|
let mut os_counts: Vec<(String, u32)> = os_map
|
|
.iter()
|
|
.map(|(os, (_, count))| (os.clone(), *count))
|
|
.collect();
|
|
os_counts.sort_by(|a, b| b.1.cmp(&a.1));
|
|
|
|
// Score distribution
|
|
let min_score = reports.iter().map(|r| r.score).min().unwrap_or(0);
|
|
let max_score = reports.iter().map(|r| r.score).max().unwrap_or(0);
|
|
|
|
let range = (max_score - min_score).max(1);
|
|
let bin_width = range as f32 / 10.0;
|
|
|
|
let mut dist_counts = vec![0u32; 10];
|
|
let mut dist_labels = vec![String::new(); 10];
|
|
|
|
for i in 0..10 {
|
|
let start = min_score + (i as f32 * bin_width) as u64;
|
|
let end = min_score + ((i + 1) as f32 * bin_width) as u64;
|
|
dist_labels[i] = format!("{}-{}", start, end);
|
|
}
|
|
|
|
for r in &reports {
|
|
let mut bin_idx = ((r.score - min_score) as f32 / bin_width).floor() as usize;
|
|
if bin_idx >= 10 {
|
|
bin_idx = 9;
|
|
}
|
|
dist_counts[bin_idx] += 1;
|
|
}
|
|
|
|
// Ratios
|
|
let total_reports = reports.len();
|
|
let avg_score_per_gb = reports
|
|
.iter()
|
|
.filter(|r| r.ram_raw > 0.0)
|
|
.map(|r| r.score as f32 / r.ram_raw)
|
|
.sum::<f32>()
|
|
/ total_reports as f32;
|
|
let avg_score_per_thread = reports
|
|
.iter()
|
|
.filter(|r| r.cores > 0)
|
|
.map(|r| r.score as f32 / r.cores as f32)
|
|
.sum::<f32>()
|
|
/ total_reports as f32;
|
|
|
|
let data = AnalyticsData {
|
|
os_labels: os_stats.iter().map(|x| x.0.clone()).collect(),
|
|
os_scores: os_stats.iter().map(|x| x.1).collect(),
|
|
os_max_labels: os_max_stats.iter().map(|x| x.0.clone()).collect(),
|
|
os_max_scores: os_max_stats.iter().map(|x| x.1).collect(),
|
|
os_min_labels: os_min_stats.iter().map(|x| x.0.clone()).collect(),
|
|
os_min_scores: os_min_stats.iter().map(|x| x.1).collect(),
|
|
os_count_labels: os_counts.iter().map(|x| x.0.clone()).collect(),
|
|
os_count_values: os_counts.iter().map(|x| x.1).collect(),
|
|
dist_labels,
|
|
dist_counts,
|
|
avg_score_per_gb,
|
|
avg_score_per_thread,
|
|
total_reports,
|
|
};
|
|
|
|
let json_data = serde_json::to_string(&data)
|
|
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
|
|
|
let mut context = Context::new();
|
|
context.insert("title", &format!("Analytics | {}", state.app_name));
|
|
context.insert("json_data", &json_data);
|
|
context.insert("data", &data);
|
|
context.insert("current_page", "analytics");
|
|
context.insert("prefix", "");
|
|
|
|
match TEMPLATES.render("analytics.html", &context) {
|
|
Ok(html) => Ok(Html(html)),
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|