blade/SCOPENET-MC
1
1 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rework BlueMap claiming and expand ranks guilds chat and warps

Browse Source
This commit is contained in:
scoped committed 2026-09-30 18:09:18 -04:00
1 parent 434ed5338a
commit 6a2944a88e
68 files changed
+1453 -2500
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

panel/server/src/config.rs
-9
View File
@@ -14,12 +14,6 @@ pub struct Config {
pub max_upload_mb: usize,
pub public_url: Option<String>,
pub trusted_proxies: Vec<std::net::IpAddr>,
/// Vantage generator binary (defaults to `vantage` on PATH or /opt/vantage).
pub vantage_bin: Option<PathBuf>,
/// Minecraft client assets directory handed to Vantage.
pub vantage_assets: Option<PathBuf>,
/// Extra arguments appended to `vantage server`.
pub vantage_args: Vec<String>,
}
fn var(name: &str) -> Option<String> {
@@ -41,9 +35,6 @@ impl Config {
trusted_proxies: var("SCOPENET_TRUSTED_PROXIES")
.map(|s| s.split(',').map(|v| v.trim().parse().expect("SCOPENET_TRUSTED_PROXIES must contain IP addresses")).collect())
.unwrap_or_default(),
vantage_bin: var("SCOPENET_VANTAGE_BIN").map(Into::into),
vantage_assets: var("SCOPENET_VANTAGE_ASSETS").map(Into::into),
vantage_args: var("SCOPENET_VANTAGE_ARGS").map(|s| s.split_whitespace().map(str::to_owned).collect()).unwrap_or_default(),
}
}
panel/server/src/db.rs
+12
View File
@@ -707,6 +707,18 @@ const MIGRATIONS: &[&str] = &[
);
CREATE INDEX guild_invites_target ON guild_invites(target_uuid, status);
"#,
// Player initiated guild applications.
r#"
CREATE TABLE guild_join_requests (
guild_id TEXT NOT NULL REFERENCES guilds(id) ON DELETE CASCADE,
uuid TEXT NOT NULL,
name TEXT NOT NULL,
message TEXT NOT NULL DEFAULT '',
created_at TEXT NOT NULL,
PRIMARY KEY (guild_id, uuid)
);
CREATE INDEX guild_join_requests_player ON guild_join_requests(uuid);
"#,
];
pub async fn connect(data_dir: &Path) -> Result<SqlitePool> {
panel/server/src/lib.rs
+1 -1
View File
@@ -63,7 +63,7 @@ pub async fn build_state_with_keys(cfg: config::Config, db: sqlx::SqlitePool, yg
keys: Arc::new(auth::Keys::new(&secret)),
http: scopenet_core::http::client(),
login_guard: Arc::new(auth::LoginGuard::default()),
livemap: Arc::new(livemap::LiveMap::new(&cfg.data_dir, cfg.vantage_bin.clone(), cfg.vantage_assets.clone(), cfg.vantage_args.clone())),
livemap: Arc::new(livemap::LiveMap::new(&cfg.data_dir)),
cfg: Arc::new(cfg),
})
}
panel/server/src/livemap.rs
+5 -277
View File
@@ -1,20 +1,10 @@
//! Central live map.
//!
//! Game servers (the SCOPENET plugin/mod) push the chunks that changed and
//! their players' positions to the panel. The panel keeps a mirror of each
//! server's Anvil region files under `<data>/livemap/<server>/world`, runs a
//! Vantage `server` sidecar over that mirror on demand, and proxies the
//! sidecar to authenticated launcher/admin sessions. Nobody has to run
//! Vantage next to their Minecraft server.
//! Live player positions and the legacy world mirror received from game servers.
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque};
use std::collections::HashMap;
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use tokio::io::{AsyncBufReadExt, BufReader};
pub const SECTOR: usize = 4096;
const HEADER: usize = 2 * SECTOR;
@@ -244,17 +234,6 @@ struct Snapshot {
}
// ---------------------------------------------------------------------------
// Sidecar supervisor
// ---------------------------------------------------------------------------
struct Sidecar {
child: tokio::process::Child,
port: u16,
token: String,
last_used: Instant,
log: std::sync::Arc<Mutex<VecDeque<String>>>,
}
#[derive(Default, Clone, Serialize)]
pub struct ServerStats {
pub chunks_received: u64,
@@ -264,50 +243,19 @@ pub struct ServerStats {
pub struct LiveMap {
root: PathBuf,
bin: Option<PathBuf>,
assets: Option<PathBuf>,
extra_args: Vec<String>,
players: Mutex<HashMap<i64, Snapshot>>,
stats: Mutex<HashMap<i64, ServerStats>>,
sidecars: tokio::sync::Mutex<HashMap<(i64, Dim), Sidecar>>,
last_error: Mutex<HashMap<(i64, Dim), String>>,
write_lock: tokio::sync::Mutex<()>,
players_written: Mutex<HashMap<i64, Instant>>,
}
fn find_bin(configured: Option<&Path>) -> Option<PathBuf> {
let candidates: Vec<PathBuf> = match configured {
Some(p) => vec![p.to_path_buf()],
None => {
let mut v: Vec<PathBuf> =
std::env::var_os("PATH").map(|p| std::env::split_paths(&p).map(|d| d.join("vantage")).collect()).unwrap_or_default();
v.push("/opt/vantage/vantage".into());
v
}
};
candidates.into_iter().find(|p| p.is_file())
}
impl LiveMap {
pub fn new(data_dir: &Path, bin: Option<PathBuf>, assets: Option<PathBuf>, extra_args: Vec<String>) -> Self {
let assets = assets.or_else(|| {
let p = data_dir.join("livemap").join("assets");
p.is_dir().then_some(p)
});
pub fn new(data_dir: &Path) -> Self {
Self {
root: data_dir.join("livemap"),
bin: find_bin(bin.as_deref()),
assets,
extra_args,
players: Mutex::default(),
stats: Mutex::default(),
sidecars: Default::default(),
last_error: Mutex::default(),
write_lock: Default::default(),
players_written: Mutex::default(),
}
}
pub fn server_dir(&self, id: i64) -> PathBuf {
self.root.join(id.to_string())
}
@@ -322,23 +270,6 @@ impl LiveMap {
w.join(dim.folder()).join("region")
}
}
fn cache_dir(&self, id: i64, dim: Dim) -> PathBuf {
self.server_dir(id).join("cache").join(dim.slug())
}
fn players_file(&self, id: i64) -> PathBuf {
self.server_dir(id).join("players.json")
}
pub fn generator_ready(&self) -> (bool, bool) {
(self.bin.is_some(), self.assets.as_ref().is_some_and(|a| a.is_dir()))
}
pub fn generator_path(&self) -> Option<String> {
self.bin.as_ref().map(|p| p.display().to_string())
}
pub fn assets_path(&self) -> Option<String> {
self.assets.as_ref().map(|p| p.display().to_string())
}
// ---- ingest ----
/// Write a batch of chunks into the server's mirror. Returns how many
@@ -394,20 +325,9 @@ impl LiveMap {
}
pub fn set_players(&self, id: i64, players: Vec<LivePlayer>) {
self.players.lock().unwrap().insert(id, Snapshot { at: Instant::now(), players: players.clone() });
self.players.lock().unwrap().insert(id, Snapshot { at: Instant::now(), players });
self.stats.lock().unwrap().entry(id).or_default().last_players_at = Some(crate::db::now());
// Vantage reads this file to decide what to pre-render; throttle it.
let mut written = self.players_written.lock().unwrap();
if written.get(&id).is_none_or(|t| t.elapsed() > Duration::from_secs(5)) {
written.insert(id, Instant::now());
let doc = players_doc(&players, None);
let path = self.players_file(id);
if std::fs::create_dir_all(self.server_dir(id)).is_ok() {
let _ = std::fs::write(path, doc.to_string());
}
}
}
/// Drop a player from every server's live roster (account deleted).
pub fn forget_player(&self, uuid: &str) {
for snap in self.players.lock().unwrap().values_mut() {
@@ -419,11 +339,6 @@ impl LiveMap {
self.players.lock().unwrap().get(&id).filter(|s| s.at.elapsed() < PLAYERS_FRESH).map(|s| s.players.clone()).unwrap_or_default()
}
/// `players.json` for one dimension (BlueMap-compatible, which Vantage reads).
pub fn players_json(&self, id: i64, dim: Dim) -> serde_json::Value {
players_doc(&self.live_players(id), Some(dim))
}
pub fn stats(&self, id: i64) -> ServerStats {
self.stats.lock().unwrap().get(&id).cloned().unwrap_or_default()
}
@@ -446,157 +361,8 @@ impl LiveMap {
serde_json::json!({ "level_dat": self.world_dir(id).join("level.dat").is_file(), "dimensions": dims })
}
pub async fn sidecars_running(&self, id: i64) -> Vec<String> {
self.sidecars.lock().await.keys().filter(|(s, _)| *s == id).map(|(_, d)| d.slug().to_string()).collect()
}
pub fn last_error(&self, id: i64) -> Option<String> {
let errs = self.last_error.lock().unwrap();
Dim::ALL.iter().find_map(|d| errs.get(&(id, *d)).cloned())
}
// ---- sidecars ----
/// Make sure a Vantage sidecar is serving this server/dimension and
/// return its loopback port and bearer token.
pub async fn ensure_sidecar(&self, id: i64, dim: Dim) -> Result<(u16, String), String> {
let bin = self.bin.clone().ok_or("The Vantage generator isn't installed on this panel. See docs/live-map.md.")?;
let assets = self
.assets
.clone()
.filter(|a| a.is_dir())
.ok_or("Minecraft client assets for Vantage aren't configured. See docs/live-map.md.")?;
let world = self.world_dir(id);
if !world.join("level.dat").is_file() || !self.region_dir(id, dim).is_dir() {
return Err("Waiting for the game server to upload this world.".into());
}
let mut sidecars = self.sidecars.lock().await;
if let Some(s) = sidecars.get_mut(&(id, dim)) {
if matches!(s.child.try_wait(), Ok(None)) {
s.last_used = Instant::now();
return Ok((s.port, s.token.clone()));
}
sidecars.remove(&(id, dim));
}
let port = {
let l = std::net::TcpListener::bind("127.0.0.1:0").map_err(|e| e.to_string())?;
l.local_addr().map_err(|e| e.to_string())?.port()
};
let token = {
use rand::RngCore;
let mut b = [0u8; 32];
rand::thread_rng().fill_bytes(&mut b);
hex::encode(b)
};
let cache = self.cache_dir(id, dim);
tokio::fs::create_dir_all(&cache).await.map_err(|e| e.to_string())?;
let players = self.players_file(id);
if !players.exists() {
let _ = std::fs::write(&players, players_doc(&[], None).to_string());
}
let mut cmd = tokio::process::Command::new(&bin);
cmd.arg("server")
.arg(&world)
.arg("--assets")
.arg(&assets)
.arg("--out")
.arg(&cache)
.args(["--host", "127.0.0.1", "--port"])
.arg(port.to_string())
.arg("--players-file")
.arg(&players)
.args(["--dimension", dim.slug()])
.args(&self.extra_args)
.env("VANTAGE_SERVER_TOKEN", &token)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
let mut child = cmd.spawn().map_err(|e| format!("couldn't start the Vantage generator: {e}"))?;
let log: std::sync::Arc<Mutex<VecDeque<String>>> = Default::default();
if let Some(out) = child.stdout.take() {
tail(out, log.clone());
}
if let Some(err) = child.stderr.take() {
tail(err, log.clone());
}
let mut sidecar = Sidecar { child, port, token: token.clone(), last_used: Instant::now(), log };
// Wait for it to answer health checks.
let client = reqwest::Client::new();
let url = format!("http://127.0.0.1:{port}/v1/health");
let deadline = Instant::now() + Duration::from_secs(30);
loop {
if let Ok(Some(status)) = sidecar.child.try_wait() {
let tail = sidecar
.log
.lock()
.unwrap()
.iter()
.rev()
.take(4)
.cloned()
.collect::<Vec<_>>()
.into_iter()
.rev()
.collect::<Vec<_>>()
.join(" | ");
let msg = format!("Vantage exited ({status}) {tail}");
self.last_error.lock().unwrap().insert((id, dim), msg.clone());
return Err(msg);
}
if client.get(&url).timeout(Duration::from_secs(2)).send().await.is_ok_and(|r| r.status().is_success()) {
break;
}
if Instant::now() > deadline {
let _ = sidecar.child.start_kill();
let msg = "Vantage didn't become ready within 30 seconds".to_string();
self.last_error.lock().unwrap().insert((id, dim), msg.clone());
return Err(msg);
}
tokio::time::sleep(Duration::from_millis(250)).await;
}
self.last_error.lock().unwrap().remove(&(id, dim));
sidecars.insert((id, dim), sidecar);
Ok((port, token))
}
/// Stop sidecars nobody has looked at recently.
pub async fn reap_idle(&self) {
let mut sidecars = self.sidecars.lock().await;
let idle: Vec<_> = sidecars.iter().filter(|(_, s)| s.last_used.elapsed() > IDLE_STOP).map(|(k, _)| *k).collect();
for key in idle {
if let Some(mut s) = sidecars.remove(&key) {
let _ = s.child.start_kill();
tracing::info!("stopped idle live-map generator for server {} ({})", key.0, key.1.slug());
}
}
}
pub fn spawn_reaper(self: &std::sync::Arc<Self>) {
let me = std::sync::Arc::downgrade(self);
tokio::spawn(async move {
loop {
tokio::time::sleep(Duration::from_secs(60)).await;
let Some(lm) = me.upgrade() else { break };
lm.reap_idle().await;
}
});
}
/// Stop every sidecar of a server and delete its mirror and caches.
/// Clear the legacy world mirror and current player positions.
pub async fn reset(&self, id: i64) -> std::io::Result<()> {
{
let mut sidecars = self.sidecars.lock().await;
let keys: Vec<_> = sidecars.keys().filter(|(s, _)| *s == id).copied().collect();
for k in keys {
if let Some(mut s) = sidecars.remove(&k) {
let _ = s.child.kill().await;
}
}
}
let _guard = self.write_lock.lock().await;
self.players.lock().unwrap().remove(&id);
self.stats.lock().unwrap().remove(&id);
@@ -606,44 +372,6 @@ impl LiveMap {
}
}
}
fn tail<R: tokio::io::AsyncRead + Unpin + Send + 'static>(r: R, log: std::sync::Arc<Mutex<VecDeque<String>>>) {
tokio::spawn(async move {
let mut lines = BufReader::new(r).lines();
while let Ok(Some(line)) = lines.next_line().await {
let mut l = log.lock().unwrap();
if l.len() >= 30 {
l.pop_front();
}
l.push_back(line.chars().take(300).collect());
}
});
}
fn players_doc(players: &[LivePlayer], dim: Option<Dim>) -> serde_json::Value {
let list: Vec<_> = players
.iter()
.map(|p| {
let here = dim.is_none_or(|d| Dim::parse(&p.dimension).unwrap_or(Dim::Overworld) == d);
serde_json::json!({
"uuid": p.uuid,
"name": p.name,
"foreign": !here,
"position": { "x": p.x, "y": p.y, "z": p.z },
"rotation": { "pitch": p.pitch, "yaw": p.yaw, "roll": 0 },
})
})
.collect();
serde_json::json!({ "players": list })
}
/// Sidecar port and token for the proxy, without starting anything.
impl LiveMap {
pub async fn sidecar_log(&self, id: i64, dim: Dim) -> Vec<String> {
self.sidecars.lock().await.get(&(id, dim)).map(|s| s.log.lock().unwrap().iter().cloned().collect()).unwrap_or_default()
}
}
#[cfg(test)]
mod tests {
use super::*;
panel/server/src/main.rs
-1
View File
@@ -22,7 +22,6 @@ async fn main() -> anyhow::Result<()> {
let bind = cfg.bind.clone();
let state = build_state(cfg, pool).await?;
bootstrap_admin(&state).await?;
state.livemap.spawn_reaper();
scopenet_panel::routes::discord::spawn_worker(state.clone());
let listener = tokio::net::TcpListener::bind(&bind).await?;
panel/server/src/routes/dev_api.rs
+2 -2
View File
@@ -65,7 +65,7 @@ pub async fn player_info(GameServer(server): GameServer, State(state): State<App
quests.insert(period.into(), json!({ "total": ids.len(), "completed": done, "claimed": claimed }));
}
drop(conn); // give the connection back before the pool is used again
let rank: Option<(String, String, String)> = sqlx::query_as("SELECT primary_group, display, prefix FROM player_ranks WHERE server_id = ? AND uuid = ?").bind(server.id).bind(&uuid).fetch_optional(&state.db).await?;
let rank: Option<(String, String, String, String)> = sqlx::query_as("SELECT primary_group, display, prefix, suffix FROM player_ranks WHERE server_id = ? AND uuid = ?").bind(server.id).bind(&uuid).fetch_optional(&state.db).await?;
let online: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM server_online WHERE uuid = ?)").bind(&uuid).fetch_one(&state.db).await?;
Ok(Json(json!({
@@ -87,7 +87,7 @@ pub async fn player_info(GameServer(server): GameServer, State(state): State<App
"friends": friends,
"achievements": achievements,
"quests": quests,
"rank": rank.map(|(primary, display, prefix)| json!({ "group": primary, "display": display, "prefix": prefix })),
"rank": rank.map(|(primary, display, prefix, suffix)| json!({ "group": primary, "display": display, "prefix": prefix, "suffix": suffix })),
})))
}
panel/server/src/routes/discord.rs
+36 -7
View File
@@ -2,7 +2,8 @@
//! sync, an invite link for launchers, and optional webhook announcements.
//!
//! Everything here is opt-in and needs the bot token and server ID saved in
//! Settings. Sync only ever *adds* membership, in the direction the admin picks.
//! Settings. Group mappings only add membership in the chosen direction;
//! managed level-title roles are replaced when a player's rank changes.
use crate::auth::{AdminUser, AuthUser};
use crate::error::{AppError, AppResult};
@@ -22,6 +23,8 @@ const API: &str = "https://discord.com/api/v10";
pub struct DiscordSettings {
/// `off`, `discord_to_panel`, `panel_to_discord` or `both`.
pub role_sync: String,
/// Discord role used until the first mapped rank title is earned.
pub base_role_id: String,
/// Shown to players in the launcher.
pub invite_url: String,
/// Announcements go here. Empty turns them off.
@@ -33,7 +36,7 @@ pub struct DiscordSettings {
impl Default for DiscordSettings {
fn default() -> Self {
Self { role_sync: "off".into(), invite_url: String::new(), webhook_url: String::new(), notify_achievements: true, notify_guilds: true, notify_members: false }
Self { role_sync: "off".into(), base_role_id: String::new(), invite_url: String::new(), webhook_url: String::new(), notify_achievements: true, notify_guilds: true, notify_members: false }
}
}
@@ -54,7 +57,7 @@ pub fn valid_invite(url: &str) -> bool {
fn view(s: &DiscordSettings) -> Value {
json!({
"role_sync": s.role_sync, "invite_url": s.invite_url,
"role_sync": s.role_sync, "base_role_id": s.base_role_id, "invite_url": s.invite_url,
"webhook_set": !s.webhook_url.is_empty(),
"notify_achievements": s.notify_achievements, "notify_guilds": s.notify_guilds, "notify_members": s.notify_members,
})
@@ -72,6 +75,8 @@ pub async fn get_settings(_: AdminUser, State(state): State<AppState>) -> AppRes
#[derive(Deserialize)]
pub struct SettingsInput {
role_sync: String,
#[serde(default)]
base_role_id: String,
invite_url: String,
/// Omitted or empty keeps the saved webhook; `"-"` clears it.
#[serde(default)]
@@ -85,6 +90,9 @@ pub async fn put_settings(_: AdminUser, State(state): State<AppState>, Json(i):
if !["off", "discord_to_panel", "panel_to_discord", "both"].contains(&i.role_sync.as_str()) {
return Err(AppError::bad_request("unknown role sync mode"));
}
if !i.base_role_id.is_empty() && (!i.base_role_id.bytes().all(|b| b.is_ascii_digit()) || i.base_role_id.len() > 24) {
return Err(AppError::bad_request("Base Discord role ID must contain digits only"));
}
let old = load(&state).await?;
let webhook = match i.webhook_url.trim() {
"" => old.webhook_url.clone(),
@@ -100,6 +108,7 @@ pub async fn put_settings(_: AdminUser, State(state): State<AppState>, Json(i):
}
let next = DiscordSettings {
role_sync: i.role_sync,
base_role_id: i.base_role_id,
invite_url: invite,
webhook_url: webhook,
notify_achievements: i.notify_achievements,
@@ -197,6 +206,7 @@ pub struct SyncReport {
pub not_in_server: u32,
pub groups_added: u32,
pub roles_added: u32,
pub roles_removed: u32,
pub failed: u32,
}
@@ -212,11 +222,13 @@ pub async fn sync_all(state: &AppState) -> AppResult<SyncReport> {
return Err(AppError::bad_request("save a Discord bot token and server ID in Settings first"));
}
let mapping: Vec<(i64, String)> = sqlx::query_as("SELECT id, discord_role FROM groups WHERE discord_role <> ''").fetch_all(&state.db).await?;
if mapping.is_empty() {
let rank_roles: Vec<(i64, String)> = sqlx::query_as("SELECT level_req, json_extract(reward_data, '$.discord_role_id') FROM level_rewards WHERE level_type='global' AND reward_type='title' AND json_extract(reward_data, '$.discord_role_id') IS NOT NULL AND json_extract(reward_data, '$.discord_role_id') <> '' ORDER BY level_req DESC")
.fetch_all(&state.db).await?;
if mapping.is_empty() && rank_roles.is_empty() && settings.base_role_id.is_empty() {
return Ok(report);
}
let linked: Vec<(i64, String)> = sqlx::query_as("SELECT user_id, provider_id FROM account_connections WHERE provider = 'discord'").fetch_all(&state.db).await?;
for (user_id, discord_id) in linked {
let linked: Vec<(i64, String, String)> = sqlx::query_as("SELECT c.user_id, c.provider_id, u.uuid FROM account_connections c JOIN users u ON u.id=c.user_id WHERE c.provider = 'discord'").fetch_all(&state.db).await?;
for (user_id, discord_id, uuid) in linked {
report.checked += 1;
let resp = bot_request(state, reqwest::Method::GET, format!("{API}/guilds/{}/members/{discord_id}", c.discord_guild_id), &c.discord_bot_token).send().await;
let resp = match resp {
@@ -235,6 +247,7 @@ pub async fn sync_all(state: &AppState) -> AppResult<SyncReport> {
report.failed += 1;
break;
}
if !resp.status().is_success() { report.failed += 1; continue; }
let Ok(member) = resp.json::<Value>().await else {
report.failed += 1;
continue;
@@ -242,11 +255,17 @@ pub async fn sync_all(state: &AppState) -> AppResult<SyncReport> {
let roles: Vec<String> = member["roles"].as_array().map(|a| a.iter().filter_map(|r| r.as_str().map(String::from)).collect()).unwrap_or_default();
let groups: Vec<i64> = sqlx::query_scalar("SELECT group_id FROM user_groups WHERE user_id = ?").bind(user_id).fetch_all(&state.db).await?;
let p = plan(&settings.role_sync, &mapping, &roles, &groups);
let xp: i64 = sqlx::query_scalar("SELECT global_xp FROM user_levels WHERE uuid=?").bind(&uuid).fetch_optional(&state.db).await?.unwrap_or(0);
let level = crate::progression::level_from_xp(xp).0;
let chosen = rank_roles.iter().find(|(required,_)| *required <= level).map(|(_,role)| role.clone())
.or_else(|| (!settings.base_role_id.is_empty()).then(|| settings.base_role_id.clone()));
for g in p.add_groups {
sqlx::query("INSERT OR IGNORE INTO user_groups (user_id, group_id) VALUES (?, ?)").bind(user_id).bind(g).execute(&state.db).await?;
report.groups_added += 1;
}
for role in p.add_roles {
// A level title takes precedence over mapped panel groups on Discord.
let wanted_roles = if let Some(role) = &chosen { if roles.contains(role) { Vec::new() } else { vec![role.clone()] } } else { p.add_roles };
for role in wanted_roles {
let done = bot_request(state, reqwest::Method::PUT, format!("{API}/guilds/{}/members/{discord_id}/roles/{role}", c.discord_guild_id), &c.discord_bot_token)
.header("Content-Length", "0")
.send()
@@ -257,6 +276,16 @@ pub async fn sync_all(state: &AppState) -> AppResult<SyncReport> {
}
tokio::time::sleep(Duration::from_millis(250)).await;
}
if let Some(chosen) = chosen {
let mut managed: Vec<String> = rank_roles.iter().map(|(_, role)| role.clone()).collect();
if !settings.base_role_id.is_empty() { managed.push(settings.base_role_id.clone()); }
managed.sort(); managed.dedup();
for role in managed.into_iter().filter(|r| r != &chosen && roles.contains(r)) {
let done = bot_request(state, reqwest::Method::DELETE, format!("{API}/guilds/{}/members/{discord_id}/roles/{role}", c.discord_guild_id), &c.discord_bot_token).send().await;
match done { Ok(r) if r.status().is_success() => report.roles_removed += 1, _ => report.failed += 1 }
tokio::time::sleep(Duration::from_millis(250)).await;
}
}
tokio::time::sleep(Duration::from_millis(120)).await;
}
Ok(report)
panel/server/src/routes/guilds.rs
+139 -24
View File
@@ -437,13 +437,7 @@ pub async fn update_guild(
State(state): State<AppState>,
Json(payload): Json<UpdateGuildPayload>,
) -> AppResult<Json<Value>> {
let role: Option<String> = sqlx::query_scalar("SELECT role FROM guild_members WHERE guild_id = ? AND uuid = ?")
.bind(&id)
.bind(&auth.uuid)
.fetch_optional(&state.db)
.await?;
let is_officer_or_leader = role.as_deref().is_some_and(|r| r == "leader" || r == "officer");
let is_officer_or_leader = guild_can(&state, &id, &auth.uuid, "manage").await?;
if !is_officer_or_leader {
return Err(AppError::forbidden("Only guild officers or leaders can update guild details"));
}
@@ -472,6 +466,132 @@ pub struct AddMemberPayload {
pub username: String,
}
#[derive(Deserialize)]
pub struct JoinRequestPayload { #[serde(default)] pub message: String }
pub async fn request_join(auth: AuthUser, Path(id): Path<String>, State(state): State<AppState>, Json(payload): Json<JoinRequestPayload>) -> AppResult<Json<Value>> {
let instance: Option<String> = sqlx::query_scalar("SELECT instance_id FROM guilds WHERE id = ?").bind(&id).fetch_optional(&state.db).await?;
let instance = instance.ok_or_else(|| AppError::not_found("guild not found"))?;
let in_guild: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM guild_members gm JOIN guilds g ON g.id = gm.guild_id WHERE gm.uuid = ? AND g.instance_id = ?)")
.bind(&auth.uuid).bind(&instance).fetch_one(&state.db).await?;
if in_guild { return Err(AppError::bad_request("Leave your current guild before requesting to join another")); }
let name: String = sqlx::query_scalar("SELECT username FROM users WHERE id = ?").bind(auth.id).fetch_one(&state.db).await?;
sqlx::query("INSERT INTO guild_join_requests(guild_id,uuid,name,message,created_at) VALUES(?,?,?,?,?) ON CONFLICT(guild_id,uuid) DO UPDATE SET message=excluded.message,created_at=excluded.created_at")
.bind(&id).bind(&auth.uuid).bind(&name).bind(payload.message.trim().chars().take(300).collect::<String>()).bind(crate::db::now()).execute(&state.db).await?;
Ok(Json(json!({"ok":true})))
}
pub async fn list_join_requests(auth: AuthUser, Path(id): Path<String>, State(state): State<AppState>) -> AppResult<Json<Value>> {
if !guild_can(&state, &id, &auth.uuid, "invite").await? { return Err(AppError::forbidden("Your guild role cannot review requests")); }
let rows: Vec<(String,String,String,String)> = sqlx::query_as("SELECT uuid,name,message,created_at FROM guild_join_requests WHERE guild_id=? ORDER BY created_at DESC")
.bind(&id).fetch_all(&state.db).await?;
Ok(Json(json!(rows.into_iter().map(|(uuid,name,message,created_at)| json!({"uuid":uuid,"name":name,"message":message,"created_at":created_at})).collect::<Vec<_>>())))
}
#[derive(Deserialize)]
pub struct JoinDecision { pub accept: bool }
pub async fn respond_join_request(auth: AuthUser, Path((id, uuid)): Path<(String,String)>, State(state): State<AppState>, Json(decision): Json<JoinDecision>) -> AppResult<Json<Value>> {
if !guild_can(&state, &id, &auth.uuid, "invite").await? { return Err(AppError::forbidden("Your guild role cannot review requests")); }
let mut tx = state.db.begin().await?;
let name: Option<String> = sqlx::query_scalar("SELECT name FROM guild_join_requests WHERE guild_id=? AND uuid=?")
.bind(&id).bind(&uuid).fetch_optional(&mut *tx).await?;
let name = name.ok_or_else(|| AppError::not_found("request not found"))?;
if decision.accept {
sqlx::query("INSERT INTO guild_members(guild_id,uuid,name,role,joined_at) VALUES(?,?,?,'member',?)")
.bind(&id).bind(&uuid).bind(&name).bind(crate::db::now()).execute(&mut *tx).await.map_err(|_| AppError::bad_request("Player has already joined a guild"))?;
sqlx::query("DELETE FROM guild_join_requests WHERE uuid=?").bind(&uuid).execute(&mut *tx).await?;
} else {
sqlx::query("DELETE FROM guild_join_requests WHERE guild_id=? AND uuid=?").bind(&id).bind(&uuid).execute(&mut *tx).await?;
}
tx.commit().await?;
Ok(Json(json!({"ok":true})))
}
#[derive(Deserialize)]
pub struct GuildRoleInput {
pub name: String,
#[serde(default)] pub priority: i64,
#[serde(default)] pub can_invite: bool,
#[serde(default)] pub can_kick: bool,
#[serde(default)] pub can_claim: bool,
#[serde(default)] pub can_post: bool,
#[serde(default)] pub can_manage: bool,
}
async fn guild_can(state: &AppState, guild_id: &str, uuid: &str, action: &str) -> AppResult<bool> {
let role: Option<String> = sqlx::query_scalar("SELECT role FROM guild_members WHERE guild_id=? AND uuid=?")
.bind(guild_id).bind(uuid).fetch_optional(&state.db).await?;
let Some(role) = role else { return Ok(false); };
if role == "leader" || role == "officer" { return Ok(true); }
if role == "member" { return Ok(matches!(action, "claim" | "post")); }
let column = match action { "invite" => "can_invite", "kick" => "can_kick", "claim" => "can_claim", "post" => "can_post", "manage" => "can_manage", _ => return Ok(false) };
let allowed: Option<i64> = sqlx::query_scalar(&format!("SELECT {column} FROM guild_roles WHERE guild_id=? AND name=?"))
.bind(guild_id).bind(&role).fetch_optional(&state.db).await?;
Ok(allowed.unwrap_or(0) != 0)
}
async fn require_guild_leader(state: &AppState, guild_id: &str, uuid: &str) -> AppResult<()> {
let role: Option<String> = sqlx::query_scalar("SELECT role FROM guild_members WHERE guild_id=? AND uuid=?")
.bind(guild_id).bind(uuid).fetch_optional(&state.db).await?;
if role.as_deref() != Some("leader") { return Err(AppError::forbidden("Only the guild leader can manage roles")); }
Ok(())
}
pub async fn list_guild_roles(auth: AuthUser, Path(id): Path<String>, State(state): State<AppState>) -> AppResult<Json<Value>> {
let member: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM guild_members WHERE guild_id=? AND uuid=?)")
.bind(&id).bind(&auth.uuid).fetch_one(&state.db).await?;
if !member { return Err(AppError::forbidden("Guild membership is required")); }
let roles: Vec<(i64,String,i64,i64,i64,i64,i64,i64)> = sqlx::query_as("SELECT id,name,priority,can_invite,can_kick,can_claim,can_post,can_manage FROM guild_roles WHERE guild_id=? ORDER BY priority DESC,name")
.bind(&id).fetch_all(&state.db).await?;
Ok(Json(json!(roles.into_iter().map(|(id,name,priority,invite,kick,claim,post,manage)| json!({"id":id,"name":name,"priority":priority,"can_invite":invite!=0,"can_kick":kick!=0,"can_claim":claim!=0,"can_post":post!=0,"can_manage":manage!=0})).collect::<Vec<_>>())))
}
pub async fn create_guild_role(auth: AuthUser, Path(id): Path<String>, State(state): State<AppState>, Json(role): Json<GuildRoleInput>) -> AppResult<Json<Value>> {
require_guild_leader(&state, &id, &auth.uuid).await?;
let name = role.name.trim();
if name.len() < 2 || name.len() > 24 || !name.chars().all(|c| c.is_alphanumeric() || c == ' ' || c == '-' || c == '_')
|| ["leader","officer","member"].iter().any(|r| r.eq_ignore_ascii_case(name)) {
return Err(AppError::bad_request("Role names must be 2–24 letters, numbers, spaces, hyphens or underscores, and cannot be a built-in role"));
}
let duplicate: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM guild_roles WHERE guild_id=? AND name=? COLLATE NOCASE)")
.bind(&id).bind(name).fetch_one(&state.db).await?;
if duplicate { return Err(AppError::conflict("A role with this name already exists")); }
let inserted = sqlx::query("INSERT INTO guild_roles(guild_id,name,priority,can_invite,can_kick,can_claim,can_post,can_manage) VALUES(?,?,?,?,?,?,?,?)")
.bind(&id).bind(name).bind(role.priority.clamp(0,100)).bind(role.can_invite).bind(role.can_kick).bind(role.can_claim).bind(role.can_post).bind(role.can_manage)
.execute(&state.db).await?;
Ok(Json(json!({"ok":true,"id":inserted.last_insert_rowid()})))
}
#[derive(Deserialize)]
pub struct AssignRole { pub role: String }
pub async fn assign_guild_role(auth: AuthUser, Path((id, uuid)): Path<(String,String)>, State(state): State<AppState>, Json(input): Json<AssignRole>) -> AppResult<Json<Value>> {
require_guild_leader(&state, &id, &auth.uuid).await?;
if input.role == "leader" { return Err(AppError::bad_request("Use leadership transfer to assign the leader role")); }
if input.role != "member" && input.role != "officer" {
let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM guild_roles WHERE guild_id=? AND name=?)")
.bind(&id).bind(&input.role).fetch_one(&state.db).await?;
if !exists { return Err(AppError::bad_request("Role does not belong to this guild")); }
}
let done = sqlx::query("UPDATE guild_members SET role=? WHERE guild_id=? AND uuid=? AND role<>'leader'")
.bind(&input.role).bind(&id).bind(&uuid).execute(&state.db).await?;
if done.rows_affected() == 0 { return Err(AppError::not_found("member not found or is guild leader")); }
Ok(Json(json!({"ok":true})))
}
pub async fn delete_guild_role(auth: AuthUser, Path((id, role_id)): Path<(String,i64)>, State(state): State<AppState>) -> AppResult<Json<Value>> {
require_guild_leader(&state, &id, &auth.uuid).await?;
let name: Option<String> = sqlx::query_scalar("SELECT name FROM guild_roles WHERE guild_id=? AND id=?")
.bind(&id).bind(role_id).fetch_optional(&state.db).await?;
let name = name.ok_or_else(|| AppError::not_found("role not found"))?;
let mut tx = state.db.begin().await?;
sqlx::query("UPDATE guild_members SET role='member' WHERE guild_id=? AND role=?").bind(&id).bind(&name).execute(&mut *tx).await?;
sqlx::query("DELETE FROM guild_roles WHERE guild_id=? AND id=?").bind(&id).bind(role_id).execute(&mut *tx).await?;
tx.commit().await?;
Ok(Json(json!({"ok":true})))
}
/// Add / Invite member to guild.
pub async fn add_guild_member(
auth: AuthUser,
@@ -479,13 +599,7 @@ pub async fn add_guild_member(
State(state): State<AppState>,
Json(payload): Json<AddMemberPayload>,
) -> AppResult<Json<Value>> {
let role: Option<String> = sqlx::query_scalar("SELECT role FROM guild_members WHERE guild_id = ? AND uuid = ?")
.bind(&id)
.bind(&auth.uuid)
.fetch_optional(&state.db)
.await?;
if !role.as_deref().is_some_and(|r| r == "leader" || r == "officer") {
if !guild_can(&state, &id, &auth.uuid, "invite").await? {
return Err(AppError::forbidden("Only guild leaders or officers can invite members"));
}
@@ -536,7 +650,7 @@ pub async fn remove_guild_member(
.await?;
let is_self = auth.uuid == target_uuid;
let is_leader_or_officer = caller_role.as_deref().is_some_and(|r| r == "leader" || r == "officer");
let is_leader_or_officer = guild_can(&state, &guild_id, &auth.uuid, "kick").await?;
if !is_self && !is_leader_or_officer {
return Err(AppError::forbidden("Cannot kick member without officer privileges"));
@@ -573,8 +687,8 @@ pub async fn create_guild_post(
.fetch_one(&state.db)
.await?;
if !in_guild {
return Err(AppError::forbidden("Must be a guild member to post"));
if !in_guild || !guild_can(&state, &id, &auth.uuid, "post").await? {
return Err(AppError::forbidden("Your guild role cannot post"));
}
let now = chrono::Utc::now().to_rfc3339();
@@ -622,8 +736,8 @@ pub async fn claim_chunk(
.fetch_optional(&state.db)
.await?;
if role.is_none() {
return Err(AppError::forbidden("You are not a member of this guild"));
if role.is_none() || !guild_can(&state, &guild_id, &auth.uuid, "claim").await? {
return Err(AppError::forbidden("Your guild role cannot claim land"));
}
let max_claims: i64 = sqlx::query_scalar("SELECT max_claims FROM guilds WHERE id = ?").bind(&guild_id).fetch_one(&state.db).await?;
@@ -694,8 +808,8 @@ pub async fn unclaim_chunk(
.fetch_optional(&state.db)
.await?;
if role.is_none() {
return Err(AppError::forbidden("You are not a member of this guild"));
if role.is_none() || !guild_can(&state, &guild_id, &auth.uuid, "claim").await? {
return Err(AppError::forbidden("Your guild role cannot unclaim land"));
}
let dim = payload.dimension.unwrap_or_else(|| "minecraft:overworld".into());
@@ -724,8 +838,8 @@ pub async fn unclaim_by_id(auth: AuthUser, Path(claim_id): Path<i64>, State(stat
.fetch_optional(&state.db)
.await?;
if role.is_none() {
return Err(AppError::forbidden("You are not a member of this guild"));
if role.is_none() || !guild_can(&state, &guild_id, &auth.uuid, "claim").await? {
return Err(AppError::forbidden("Your guild role cannot unclaim land"));
}
sqlx::query("DELETE FROM guild_claims WHERE id = ?").bind(claim_id).execute(&state.db).await?;
@@ -1033,6 +1147,7 @@ pub async fn server_claim_chunk(
let Some((guild_id, _role)) = member else {
return Err(AppError::bad_request("You must be in a guild to claim land. Create one with /guild create <name> <tag>"));
};
if !guild_can(&state, &guild_id, &payload.uuid, "claim").await? { return Err(AppError::forbidden("Your guild role cannot claim land")); }
let max_claims: i64 =
sqlx::query_scalar("SELECT max_claims FROM guilds WHERE id = ?").bind(&guild_id).fetch_one(&state.db).await.unwrap_or(16);
@@ -1103,7 +1218,7 @@ pub async fn server_unclaim_chunk(
.fetch_optional(&state.db)
.await?;
if member.is_none() {
if member.is_none() || !guild_can(&state, &guild_id, &payload.uuid, "claim").await? {
return Err(AppError::forbidden("You cannot unclaim land belonging to another guild"));
}
panel/server/src/routes/integrations.rs
+18 -1
View File
@@ -130,8 +130,11 @@ async fn apply_luckperms(conn: &mut SqliteConnection, server_id: i64, data: &Val
let settings = load_settings(conn).await?;
let players: Vec<LpPlayer> = serde_json::from_value(data.get("players").cloned().unwrap_or(json!([]))).unwrap_or_default();
let mapped: Vec<(i64, String)> = sqlx::query_as("SELECT id, luckperms_group FROM groups WHERE luckperms_group <> ''").fetch_all(&mut *conn).await?;
let level_groups: Vec<(i64, String)> = sqlx::query_as("SELECT level_req, json_extract(reward_data, '$.luckperms_group') FROM level_rewards WHERE level_type='global' AND reward_type='title' AND json_extract(reward_data, '$.luckperms_group') IS NOT NULL AND json_extract(reward_data, '$.luckperms_group') <> '' ORDER BY level_req DESC")
.fetch_all(&mut *conn).await?;
let now = crate::db::now();
let mut assign = Vec::new();
let mut level_assign = Vec::new();
for p in players.into_iter().take(2000) {
let Some(uuid) = crate::yggdrasil::dashed(&p.uuid) else { continue };
let groups: Vec<String> = p.groups.iter().map(|g| clean(g, 64).to_lowercase()).filter(|g| !g.is_empty()).take(64).collect();
@@ -155,6 +158,20 @@ async fn apply_luckperms(conn: &mut SqliteConnection, server_id: i64, data: &Val
.bind(&now)
.execute(&mut *conn)
.await?;
if !level_groups.is_empty() {
let xp: i64 = sqlx::query_scalar("SELECT global_xp FROM user_levels WHERE uuid=?").bind(&uuid).fetch_optional(&mut *conn).await?.unwrap_or(0);
let level = crate::progression::level_from_xp(xp).0;
let target = level_groups.iter().find(|(required, _)| *required <= level).map(|(_, group)| group.to_lowercase());
let mut add = Vec::new();
let mut remove = Vec::new();
for (_, group) in &level_groups {
let key = group.to_lowercase();
if target.as_deref() == Some(key.as_str()) {
if !groups.contains(&key) { add.push(key); }
} else if groups.contains(&key) { remove.push(key); }
}
if !add.is_empty() || !remove.is_empty() { level_assign.push(json!({"uuid":uuid,"add":add,"remove":remove})); }
}
if settings.luckperms_sync == "off" || mapped.is_empty() {
continue;
}
@@ -173,7 +190,7 @@ async fn apply_luckperms(conn: &mut SqliteConnection, server_id: i64, data: &Val
assign.push(json!({ "uuid": uuid, "add": plan.game_add, "remove": plan.game_remove }));
}
}
Ok(json!({ "mode": settings.luckperms_sync, "assign": assign }))
Ok(json!({ "mode": settings.luckperms_sync, "assign": assign, "level_assign": level_assign }))
}
// ---------------------------------------------------------------------------
panel/server/src/routes/leveling.rs
+38 -1
View File
@@ -1,7 +1,7 @@
//! Leveling system (Global Level & Server-Specific Levels), rewards, and progression.
use crate::auth::{AdminUser, AuthUser};
use crate::error::AppResult;
use crate::error::{AppError, AppResult};
use crate::state::AppState;
use axum::extract::{Path, State};
use axum::Json;
@@ -51,6 +51,9 @@ pub async fn grant_rewards(tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>, uuid: &
_ => {} // Item/cosmetic entitlements are recorded in granted_rewards.
}
}
let active_title: Option<String> = sqlx::query_scalar("SELECT reward_name FROM level_rewards WHERE level_type='global' AND reward_type='title' AND level_req<=? ORDER BY level_req DESC,id DESC LIMIT 1")
.bind(level).fetch_optional(&mut **tx).await?;
sqlx::query("UPDATE user_levels SET title=? WHERE uuid=?").bind(active_title).bind(uuid).execute(&mut **tx).await?;
Ok(())
}
@@ -278,6 +281,33 @@ pub struct RewardPayload {
pub reward_data: Option<Value>,
}
fn validate_rank_mapping(data: &serde_json::Map<String, Value>) -> AppResult<()> {
if data.get("discord_role_id").is_some_and(|v| !v.is_string() && !v.is_null())
|| data.get("luckperms_group").is_some_and(|v| !v.is_string() && !v.is_null()) {
return Err(AppError::bad_request("Rank role mappings must be text"));
}
let discord = data.get("discord_role_id").and_then(Value::as_str).unwrap_or("");
if !discord.is_empty() && (discord.len() > 24 || !discord.bytes().all(|b| b.is_ascii_digit())) {
return Err(AppError::bad_request("Discord role ID must contain digits only"));
}
let group = data.get("luckperms_group").and_then(Value::as_str).unwrap_or("");
if !group.is_empty() && (group.len() > 64 || !group.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'-' || b == b'.')) {
return Err(AppError::bad_request("LuckPerms group must contain letters, digits, _, - or ."));
}
Ok(())
}
async fn refresh_global_titles(state: &AppState) -> AppResult<()> {
let players: Vec<(String, i64)> = sqlx::query_as("SELECT uuid, global_xp FROM user_levels").fetch_all(&state.db).await?;
for (uuid, xp) in players {
let level = level_from_xp(xp).0;
let title: Option<String> = sqlx::query_scalar("SELECT reward_name FROM level_rewards WHERE level_type='global' AND reward_type='title' AND level_req<=? ORDER BY level_req DESC,id DESC LIMIT 1")
.bind(level).fetch_optional(&state.db).await?;
sqlx::query("UPDATE user_levels SET title=? WHERE uuid=?").bind(title).bind(uuid).execute(&state.db).await?;
}
Ok(())
}
/// Admin create reward.
pub async fn admin_create_reward(
_admin: AdminUser,
@@ -300,6 +330,7 @@ pub async fn admin_create_reward(
data_obj.insert("icon".into(), Value::String(ico));
}
data_obj.insert("title".into(), Value::String(reward_name.clone()));
validate_rank_mapping(&data_obj)?;
let data_str = serde_json::to_string(&data_obj).unwrap_or_default();
let id: i64 = sqlx::query_scalar(
@@ -317,6 +348,8 @@ pub async fn admin_create_reward(
.fetch_one(&state.db)
.await?;
refresh_global_titles(&state).await?;
Ok(Json(serde_json::json!({ "id": id, "ok": true })))
}
@@ -341,6 +374,7 @@ pub async fn admin_update_reward(
data_obj.insert("icon".into(), Value::String(ico));
}
data_obj.insert("title".into(), Value::String(reward_name.clone()));
validate_rank_mapping(&data_obj)?;
let data_str = serde_json::to_string(&data_obj).unwrap_or_default();
sqlx::query(
@@ -359,6 +393,8 @@ pub async fn admin_update_reward(
.execute(&state.db)
.await?;
refresh_global_titles(&state).await?;
Ok(Json(serde_json::json!({ "id": id, "ok": true })))
}
@@ -372,5 +408,6 @@ pub async fn admin_delete_reward(
.bind(id)
.execute(&state.db)
.await?;
refresh_global_titles(&state).await?;
Ok(Json(serde_json::json!({ "ok": true })))
}
panel/server/src/routes/livemap.rs
+11 -61
View File
@@ -1,16 +1,14 @@
//! Live map endpoints: ingest from game servers, the authenticated Vantage
//! proxy for launchers/admin, and admin status.
//! Live player positions and legacy world-mirror ingest from game servers.
use super::servers::{get_server, GameServer};
use crate::auth::{AdminUser, AuthUser};
use crate::error::{AppError, AppResult};
use crate::livemap::{parse_chunks, Dim, LivePlayer};
use crate::state::AppState;
use axum::body::{Body, Bytes};
use axum::body::Bytes;
use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade};
use axum::extract::{Path, Query, State};
use axum::http::{header, HeaderMap, HeaderValue, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::response::Response;
use axum::Json;
use base64::Engine;
use serde::Deserialize;
@@ -199,7 +197,6 @@ fn label(d: Dim) -> &'static str {
async fn info(state: &AppState, id: i64, enabled: bool) -> Value {
let summary = state.livemap.world_summary(id);
let (generator, assets) = state.livemap.generator_ready();
let dims: Vec<Value> = summary["dimensions"]
.as_array()
.into_iter()
@@ -209,43 +206,35 @@ async fn info(state: &AppState, id: i64, enabled: bool) -> Value {
Some(json!({ "id": dim.id(), "slug": dim.slug(), "label": label(dim), "available": d["regions"].as_u64().unwrap_or(0) > 0 }))
})
.collect();
let has_world = summary["level_dat"].as_bool().unwrap_or(false) && dims.iter().any(|d| d["available"] == true);
let message = if !enabled {
"Live Map is off for this server."
} else if !generator || !assets {
"The map generator isn't set up on the panel yet."
} else if !has_world {
"Waiting for the game server to upload its world."
"Live player positions are off for this server."
} else {
""
};
json!({
"enabled": enabled,
"ready": enabled && generator && assets && has_world,
"ready": enabled,
"message": message,
"base": format!("/api/livemap/{id}"),
"dimensions": dims,
"players": state.livemap.live_players(id).len(),
})
}
/// What the launcher needs to decide whether to offer the Live Map button.
pub async fn viewer_info(_: AuthUser, State(state): State<AppState>, Path(id): Path<i64>) -> AppResult<Json<Value>> {
/// A signed-in player's own live position for the territory map.
pub async fn viewer_info(AuthUser(auth): AuthUser, State(state): State<AppState>, Path(id): Path<i64>) -> AppResult<Json<Value>> {
let server = get_server(&state, id).await?;
Ok(Json(info(&state, id, server.live_map_enabled).await))
let mut result = info(&state, id, server.live_map_enabled).await;
result["me"] = serde_json::to_value(state.livemap.live_players(id).into_iter()
.find(|player| player.uuid.eq_ignore_ascii_case(&auth.uuid)))?;
Ok(Json(result))
}
pub async fn admin_status(_: AdminUser, State(state): State<AppState>, Path(id): Path<i64>) -> AppResult<Json<Value>> {
let server = get_server(&state, id).await?;
let mut v = info(&state, id, server.live_map_enabled).await;
let (generator, assets) = state.livemap.generator_ready();
let stats = state.livemap.stats(id);
v["generator"] = json!({ "installed": generator, "path": state.livemap.generator_path() });
v["assets"] = json!({ "configured": assets, "path": state.livemap.assets_path() });
v["world"] = state.livemap.world_summary(id);
v["stats"] = serde_json::to_value(stats)?;
v["running"] = json!(state.livemap.sidecars_running(id).await);
v["last_error"] = json!(state.livemap.last_error(id));
v["roster"] = serde_json::to_value(state.livemap.live_players(id))?;
Ok(Json(v))
}
@@ -255,42 +244,3 @@ pub async fn admin_reset(_: AdminUser, State(state): State<AppState>, Path(id):
state.livemap.reset(id).await?;
Ok(Json(json!({ "ok": true })))
}
/// Authenticated reverse proxy to the per-server Vantage sidecar. Clients
/// use `…/api/livemap/{server}/{dimension}/v1/worlds/default/manifest.json`
/// and everything the manifest references.
pub async fn proxy(
_: AuthUser,
State(state): State<AppState>,
Path((id, dim, path)): Path<(i64, String, String)>,
headers: HeaderMap,
) -> AppResult<Response> {
let server = get_server(&state, id).await?;
require_enabled(server.live_map_enabled)?;
let dim = dim_of(&dim)?;
if path.split('/').any(|s| s == ".." || s.is_empty() || s.contains('\\')) || !path.starts_with("v1/worlds/default/") {
return Err(AppError::not_found("not found"));
}
if path == "v1/worlds/default/players.json" {
let mut resp = Json(state.livemap.players_json(id, dim)).into_response();
resp.headers_mut().insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
return Ok(resp);
}
let (port, token) = state.livemap.ensure_sidecar(id, dim).await.map_err(|m| AppError::new(StatusCode::SERVICE_UNAVAILABLE, m))?;
let mut req = state.http.get(format!("http://127.0.0.1:{port}/{path}")).bearer_auth(token).timeout(std::time::Duration::from_secs(120));
if let Some(etag) = headers.get(header::IF_NONE_MATCH) {
req = req.header(header::IF_NONE_MATCH, etag);
}
let upstream = req.send().await.map_err(|e| AppError::new(StatusCode::BAD_GATEWAY, format!("map generator unreachable: {e}")))?;
let mut out = Response::builder().status(upstream.status());
for name in [header::CONTENT_TYPE, header::ETAG, header::CACHE_CONTROL, header::LAST_MODIFIED] {
if let Some(v) = upstream.headers().get(&name) {
out = out.header(name, v);
}
}
// Tiles are immutable per etag; make sure shared caches never keep them.
Ok(out
.header(header::VARY, "Authorization")
.body(Body::from_stream(upstream.bytes_stream()))
.map_err(|e| AppError::new(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?)
}
panel/server/src/routes/map.rs
+8 -2
View File
@@ -146,8 +146,14 @@ pub async fn create_invite(state: &AppState, inviter_uuid: &str, inviter_name: &
}
let mut conn = state.db.acquire().await?;
let role: Option<String> = sqlx::query_scalar("SELECT role FROM guild_members WHERE guild_id = ? AND uuid = ?").bind(guild_id).bind(inviter_uuid).fetch_optional(&mut *conn).await?;
if !role.as_deref().is_some_and(|r| r == "leader" || r == "officer") {
return Err(AppError::forbidden("Only guild leaders and officers can invite players"));
let allowed = match role.as_deref() {
Some("leader" | "officer") => true,
Some(custom) => sqlx::query_scalar::<_, i64>("SELECT can_invite FROM guild_roles WHERE guild_id=? AND name=?")
.bind(guild_id).bind(custom).fetch_optional(&mut *conn).await?.unwrap_or(0) != 0,
None => false,
};
if !allowed {
return Err(AppError::forbidden("Your guild role cannot invite players"));
}
let target: Option<String> = sqlx::query_scalar("SELECT username FROM users WHERE uuid = ? AND status = 'active'").bind(target_uuid).fetch_optional(&mut *conn).await?;
let target_name = target.ok_or_else(|| AppError::not_found("Player not found"))?;
panel/server/src/routes/mod.rs
+5 -1
View File
@@ -84,6 +84,11 @@ pub fn api(state: &AppState) -> Router<AppState> {
.route("/guilds/claims/{id}", delete(guilds::unclaim_by_id))
.route("/guilds/{id}", get(guilds::get_guild_by_id).put(guilds::update_guild))
.route("/guilds/{id}/members", get(guilds::get_guild_members).post(guilds::add_guild_member))
.route("/guilds/{id}/members/{uuid}/role", put(guilds::assign_guild_role))
.route("/guilds/{id}/roles", get(guilds::list_guild_roles).post(guilds::create_guild_role))
.route("/guilds/{id}/roles/{role_id}", delete(guilds::delete_guild_role))
.route("/guilds/{id}/requests", get(guilds::list_join_requests).post(guilds::request_join))
.route("/guilds/{id}/requests/{uuid}/respond", post(guilds::respond_join_request))
.route("/guilds/{id}/members/{uuid}", delete(guilds::remove_guild_member))
.route("/guilds/{id}/posts", get(guilds::get_guild_posts).post(guilds::create_guild_post))
.route("/guilds/{id}/wallet", get(guilds::guild_wallet))
@@ -236,7 +241,6 @@ pub fn api(state: &AppState) -> Router<AppState> {
.layer(DefaultBodyLimit::max(10 * 1024 * 1024));
Router::new()
.route("/api/livemap/{id}/{dim}/{*path}", get(livemap::proxy))
.nest("/api/v1", launcher)
.nest("/api/server/v1", game.merge(livemap_game))
.nest("/api/admin", admin)
panel/server/src/routes/progression.rs
+1 -3
View File
@@ -164,9 +164,7 @@ pub async fn adjust_player(
_ => return Err(AppError::bad_request("scope must be global or server")),
};
// Level rewards (titles, badges) are earned, so they follow upward changes.
if change.new_xp > change.old_xp {
crate::routes::leveling::grant_rewards(&mut tx, &uuid, &now).await?;
}
crate::routes::leveling::grant_rewards(&mut tx, &uuid, &now).await?;
tx.commit().await?;
let reason: String = a.reason.chars().filter(|c| !c.is_control()).take(120).collect();
panel/server/src/routes/servers.rs
+3 -17
View File
@@ -61,6 +61,7 @@ fn clip(s: &str, max: usize) -> String {
#[derive(Debug, Clone, sqlx::FromRow, Serialize)]
pub struct ServerRow {
pub instance_id: String,
#[serde(skip)] // retained only for reading the legacy database column
pub map_url: String,
pub live_map_enabled: bool,
/// Address of this server's BlueMap (https://map.example.com). Shown in the launcher when set.
@@ -867,8 +868,6 @@ pub struct ServerInput {
#[serde(default)]
require_launcher: bool,
#[serde(default)]
map_url: String,
#[serde(default)]
live_map_enabled: bool,
#[serde(default)]
economy_group: String,
@@ -908,18 +907,6 @@ impl ServerInput {
return Err(AppError::bad_request("map address is too long"));
}
}
if !self.map_url.trim().is_empty() {
let url = reqwest::Url::parse(self.map_url.trim()).map_err(|_| AppError::bad_request("map URL must be an absolute URL"))?;
if url.scheme() != "https" && !(url.scheme() == "http" && matches!(url.host_str(), Some("localhost" | "127.0.0.1"))) {
return Err(AppError::bad_request("map URL must use HTTPS (or localhost for development)"));
}
if url.username() != "" || url.password().is_some() || url.fragment().is_some() || url.query().is_some() {
return Err(AppError::bad_request("map URL cannot contain credentials, query parameters, or a fragment"));
}
if !matches!(url.path().rsplit('/').next(), Some("manifest.json" | "world.json")) {
return Err(AppError::bad_request("map URL must end with manifest.json or world.json"));
}
}
Ok(())
}
}
@@ -946,7 +933,7 @@ pub async fn create(_: AdminUser, State(state): State<AppState>, Json(input): Js
.bind(input.require_launcher)
.bind(now())
.bind(&input.instance_id)
.bind(input.map_url.trim())
.bind("")
.bind(input.live_map_enabled)
.bind(input.economy_group.trim())
.bind(input.map_address.trim())
@@ -970,7 +957,7 @@ pub async fn update(
.bind(serde_json::to_string(&input.allowed_groups).unwrap_or_else(|_| "[]".into()))
.bind(input.require_launcher)
.bind(&input.instance_id)
.bind(input.map_url.trim())
.bind("")
.bind(input.live_map_enabled)
.bind(input.economy_group.trim())
.bind(input.map_address.trim())
@@ -1168,7 +1155,6 @@ pub async fn public_servers(State(state): State<AppState>) -> AppResult<Json<Val
"id": s.id,
"name": s.name,
"instance_id": s.instance_id,
"map_url": s.map_url,
"map_address": s.map_address,
"live_map": s.live_map_enabled,
"online": is_online,
panel/server/tests/common/mod.rs
-3
View File
@@ -39,9 +39,6 @@ pub async fn setup_with(tweak: impl FnOnce(&mut Config, &std::path::Path)) -> Te
max_upload_mb: 64,
public_url: Some("https://panel.test".into()),
trusted_proxies: vec!["127.0.0.1".parse().unwrap()],
vantage_bin: None,
vantage_assets: None,
vantage_args: vec![],
};
tweak(&mut cfg, dir.path());
let pool = db::connect_memory().await.unwrap();
panel/server/tests/guild_roles.rs
+37
View File
@@ -0,0 +1,37 @@
mod common;
use common::*;
#[tokio::test]
async fn leader_approves_join_request_and_role_controls_claims() {
let t = setup().await;
let admin = t.login("admin", "supersecret").await;
for name in ["Leader", "Applicant"] {
let (status, body) = t.call("POST", "/api/admin/users", Some(&admin), Some(json!({"username":name,"password":"password123"}))).await;
assert_eq!(status, StatusCode::OK, "{body}");
}
let leader = t.login("Leader", "password123").await;
let applicant = t.login("Applicant", "password123").await;
let applicant_uuid = t.uuid("Applicant").await;
let (_, server) = t.call("POST", "/api/admin/servers", Some(&admin), Some(json!({"name":"SMP","instance_id":"smp"}))).await;
let server_id = server["server"]["id"].as_i64().unwrap();
let (status, guild) = t.call("POST", "/api/v1/guilds", Some(&leader), Some(json!({"instance_id":"smp","name":"Pimps","tag":"PIMP"}))).await;
assert_eq!(status, StatusCode::OK, "{guild}");
let id = guild["id"].as_str().unwrap();
let path = format!("/api/v1/guilds/{id}");
assert_eq!(t.call("POST", &format!("{path}/requests"), Some(&applicant), Some(json!({"message":"Let me in"}))).await.0, StatusCode::OK);
assert_eq!(t.call("GET", &format!("{path}/requests"), Some(&applicant), None).await.0, StatusCode::FORBIDDEN);
let (_, requests) = t.call("GET", &format!("{path}/requests"), Some(&leader), None).await;
assert_eq!(requests[0]["message"], "Let me in");
assert_eq!(t.call("POST", &format!("{path}/requests/{applicant_uuid}/respond"), Some(&leader), Some(json!({"accept":true}))).await.0, StatusCode::OK);
let (status, role) = t.call("POST", &format!("{path}/roles"), Some(&leader), Some(json!({"name":"Builder","can_claim":false,"can_post":true}))).await;
assert_eq!(status, StatusCode::OK, "{role}");
assert_eq!(t.call("PUT", &format!("{path}/members/{applicant_uuid}/role"), Some(&leader), Some(json!({"role":"Builder"}))).await.0, StatusCode::OK);
let claim = json!({"server_id":server_id,"dimension":"minecraft:overworld","chunk_x":1,"chunk_z":1});
assert_eq!(t.call("POST", &format!("{path}/claim"), Some(&applicant), Some(claim)).await.0, StatusCode::FORBIDDEN);
let role_id = role["id"].as_i64().unwrap();
assert_eq!(t.call("DELETE", &format!("{path}/roles/{role_id}"), Some(&leader), None).await.0, StatusCode::OK);
let (_, members) = t.call("GET", &format!("{path}/members"), Some(&leader), None).await;
assert_eq!(members.as_array().unwrap().iter().find(|m| m["uuid"] == applicant_uuid).unwrap()["role"], "member");
}
panel/server/tests/livemap.rs
+3 -87
View File
@@ -1,4 +1,4 @@
//! Central live map: ingest from game servers, status for admins, viewer proxy.
//! Live position and world-mirror ingest from game servers.
mod common;
use common::*;
@@ -20,7 +20,7 @@ async fn post_bytes(t: &TestApp, uri: &str, token: &str, body: Vec<u8>) -> (Stat
}
#[tokio::test]
async fn live_map_ingest_status_and_proxy() {
async fn live_map_ingest_and_player_positions() {
let t = setup().await;
let admin = t.login("admin", "supersecret").await;
let (_, v) = t.call("POST", "/api/admin/servers", Some(&admin), Some(json!({"name": "Survival"}))).await;
@@ -82,29 +82,12 @@ async fn live_map_ingest_status_and_proxy() {
assert_eq!(s, StatusCode::OK);
assert_eq!(info["enabled"], true);
assert_eq!(info["players"], 1);
assert_eq!(info["base"], format!("/api/livemap/{id}"));
assert!(info["dimensions"][0]["available"].as_bool().unwrap());
// No generator is installed in the test environment.
assert_eq!(info["ready"], false);
let (_, pj) = t.call("GET", &format!("/api/livemap/{id}/the_nether/v1/worlds/default/players.json"), Some(&admin), None).await;
assert_eq!(pj["players"][0]["name"], "Notch");
assert_eq!(pj["players"][0]["foreign"], false);
let (_, pj) = t.call("GET", &format!("/api/livemap/{id}/overworld/v1/worlds/default/players.json"), Some(&admin), None).await;
assert_eq!(pj["players"][0]["foreign"], true);
let (s, e) = t.call("GET", &format!("/api/livemap/{id}/overworld/v1/worlds/default/manifest.json"), Some(&admin), None).await;
assert_eq!(s, StatusCode::SERVICE_UNAVAILABLE);
assert!(e["error"].as_str().unwrap().contains("generator"));
let (s, _) = t.call("GET", &format!("/api/livemap/{id}/overworld/v1/openapi.json"), Some(&admin), None).await;
assert_eq!(s, StatusCode::NOT_FOUND);
let (s, _) = t.call("GET", &format!("/api/livemap/{id}/overworld/v1/worlds/default/manifest.json"), None, None).await;
assert_eq!(s, StatusCode::UNAUTHORIZED);
assert_eq!(info["ready"], true);
let (s, st) = t.call("GET", &format!("/api/admin/servers/{id}/livemap"), Some(&admin), None).await;
assert_eq!(s, StatusCode::OK);
assert_eq!(st["stats"]["chunks_received"], 2);
assert_eq!(st["generator"]["installed"], false);
// Public list advertises the map; reset wipes it.
let (_, list) = t.call("GET", "/api/v1/servers/public", None, None).await;
@@ -114,70 +97,3 @@ async fn live_map_ingest_status_and_proxy() {
let (_, m) = t.call("GET", "/api/server/v1/livemap/manifest?dim=overworld", Some(&token), None).await;
assert!(m["regions"].as_array().unwrap().is_empty());
}
/// A stand-in for `vantage server` that answers health checks and serves a
/// manifest, to exercise the supervisor and proxy end to end.
#[cfg(unix)]
#[tokio::test]
async fn proxy_starts_and_reaches_the_generator() {
if std::process::Command::new("python3").arg("--version").output().is_err() {
return;
}
use std::os::unix::fs::PermissionsExt;
let t = setup_with(|cfg, dir| {
let bin = dir.join("fake-vantage");
std::fs::write(
&bin,
r#"#!/usr/bin/env python3
import sys, os, http.server
a = sys.argv
port = int(a[a.index('--port') + 1])
assert a[1] == 'server' and '--assets' in a and '--players-file' in a
token = os.environ['VANTAGE_SERVER_TOKEN']
class H(http.server.BaseHTTPRequestHandler):
def do_GET(self):
if self.path == '/v1/health':
body = b'ok'
elif self.headers.get('Authorization') != 'Bearer ' + token:
self.send_response(401); self.end_headers(); return
else:
body = b'{"fake":true,"path":"' + self.path.encode() + b'"}'
self.send_response(200); self.send_header('ETag', '"v1"'); self.send_header('Content-Type', 'application/json'); self.end_headers(); self.wfile.write(body)
def log_message(self, *a): pass
http.server.ThreadingHTTPServer(('127.0.0.1', port), H).serve_forever()
"#,
)
.unwrap();
std::fs::set_permissions(&bin, std::fs::Permissions::from_mode(0o755)).unwrap();
std::fs::create_dir_all(dir.join("assets")).unwrap();
cfg.vantage_bin = Some(bin);
cfg.vantage_assets = Some(dir.join("assets"));
})
.await;
let admin = t.login("admin", "supersecret").await;
let (_, v) = t.call("POST", "/api/admin/servers", Some(&admin), Some(json!({"name": "S", "live_map_enabled": true}))).await;
let id = v["server"]["id"].as_i64().unwrap();
let token = v["token"].as_str().unwrap().to_string();
let uri = format!("/api/livemap/{id}/overworld/v1/worlds/default/manifest.json");
let (s, _) = t.call("GET", &uri, Some(&admin), None).await;
assert_eq!(s, StatusCode::SERVICE_UNAVAILABLE, "no world uploaded yet");
post_bytes(&t, &format!("/api/server/v1/livemap/chunks?dim=overworld"), &token, record(0, 0, 5, b"abc")).await;
let mut gz = vec![0x1f, 0x8b];
gz.extend([0u8; 30]);
post_bytes(&t, "/api/server/v1/livemap/level", &token, gz).await;
let (_, info) = t.call("GET", &format!("/api/v1/servers/{id}/livemap"), Some(&admin), None).await;
assert_eq!(info["ready"], true, "{info}");
let (s, body) = t.call("GET", &uri, Some(&admin), None).await;
assert_eq!(s, StatusCode::OK, "{body}");
assert_eq!(body["fake"], true);
assert_eq!(body["path"], "/v1/worlds/default/manifest.json");
let (_, st) = t.call("GET", &format!("/api/admin/servers/{id}/livemap"), Some(&admin), None).await;
assert_eq!(st["running"][0], "overworld");
// Reset stops the generator and deletes the mirror.
t.call("DELETE", &format!("/api/admin/servers/{id}/livemap"), Some(&admin), None).await;
let (_, st) = t.call("GET", &format!("/api/admin/servers/{id}/livemap"), Some(&admin), None).await;
assert!(st["running"].as_array().unwrap().is_empty());
}