Merge pull request #694 from ludovic111/feat/server-usercache-2
usercache.json, and console names resolved through it as vanilla does (stacked on #589)
This commit is contained in:
@@ -13,7 +13,9 @@ use horizon_client::{
|
||||
server::{
|
||||
eula,
|
||||
java_properties::now_millis,
|
||||
profiles,
|
||||
properties::{GAME_MODES, ServerProperties, SystemEntropy},
|
||||
user_cache::UserCache,
|
||||
user_lists::{
|
||||
BanEntry, BanList, IpBanList, NameAndId, OpEntry, OpList, WhiteEntry, WhiteList,
|
||||
format_date,
|
||||
@@ -57,20 +59,17 @@ struct Setup {
|
||||
started: Instant,
|
||||
}
|
||||
static SETUP: OnceLock<Mutex<Option<Setup>>> = OnceLock::new();
|
||||
/// usercache.json (Services.nameToIdCache): used by the server thread only.
|
||||
static USER_CACHE: Mutex<Option<UserCache>> = Mutex::new(None);
|
||||
|
||||
/// CachedUserNameToIdResolver, kept in memory only (vanilla also saves it to
|
||||
/// usercache.json): players who joined, and accounts found by name, by name
|
||||
/// in lower case.
|
||||
static USER_CACHE: OnceLock<Mutex<std::collections::HashMap<String, NameAndId>>> = OnceLock::new();
|
||||
|
||||
/// PlayerList.placeNewPlayer adds the player to the name cache.
|
||||
pub(super) fn remember(name: &str, uuid: u128) {
|
||||
let user = NameAndId {
|
||||
id: uuid,
|
||||
name: name.to_owned(),
|
||||
};
|
||||
let cache = USER_CACHE.get_or_init(Default::default);
|
||||
cache.lock().unwrap().insert(name.to_lowercase(), user);
|
||||
/// PlayerList.placeNewPlayer: a player who joined is cached (and the file saved).
|
||||
pub(super) fn player_joined(id: u128, name: &str) {
|
||||
if let Some(cache) = USER_CACHE.lock().unwrap().as_mut() {
|
||||
cache.add(NameAndId {
|
||||
id,
|
||||
name: name.to_owned(),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// Log4j's console pattern: `[HH:mm:ss] [thread/LEVEL]: message`.
|
||||
@@ -331,8 +330,6 @@ struct ServerState {
|
||||
/// When the last passes of the loop ended, for the tick rate horizon-server shows.
|
||||
ticks: std::collections::VecDeque<Instant>,
|
||||
paused: bool,
|
||||
/// online-mode: names given to commands are looked up as accounts.
|
||||
online: bool,
|
||||
}
|
||||
|
||||
impl Game<'_> {
|
||||
@@ -365,6 +362,14 @@ impl Game<'_> {
|
||||
line.clear();
|
||||
}
|
||||
})?;
|
||||
// Main: Services.create loads the universe's usercache.json.
|
||||
let (mut cache, warnings) = UserCache::load(universe.join("usercache.json"));
|
||||
for warning in warnings {
|
||||
log_from("main", "WARN", &warning);
|
||||
}
|
||||
// DedicatedServer.initServer: names nobody has resolve offline only without authentication.
|
||||
cache.resolve_offline_users = !props.online_mode;
|
||||
*USER_CACHE.lock().unwrap() = Some(cache);
|
||||
log("INFO", "Starting minecraft server version 26.3");
|
||||
log("INFO", "Loading properties");
|
||||
let game_mode = props.game_mode;
|
||||
@@ -530,7 +535,6 @@ impl Game<'_> {
|
||||
empty_ticks: 0,
|
||||
ticks: Default::default(),
|
||||
paused: false,
|
||||
online: props.online_mode,
|
||||
};
|
||||
let pause_after = props.pause_when_empty_seconds * 20;
|
||||
let idle_timeout = props.player_idle_timeout;
|
||||
@@ -672,33 +676,23 @@ impl Game<'_> {
|
||||
})
|
||||
}
|
||||
|
||||
/// GameProfileArgument: a player on the server, else one seen since the
|
||||
/// start, else the name resolved as the server's mode says (an online
|
||||
/// server asks the services, an offline one makes the offline profile).
|
||||
/// None, told to the console: no such account.
|
||||
fn resolve(&self, name: &str, online: bool) -> Option<NameAndId> {
|
||||
let user = self.online_player(name).or_else(|| {
|
||||
let key = name.to_lowercase();
|
||||
let cache = USER_CACHE.get_or_init(Default::default);
|
||||
if let Some(user) = cache.lock().unwrap().get(&key) {
|
||||
return Some(user.clone());
|
||||
}
|
||||
let user = horizon_server_files::profiles::resolve(name, online);
|
||||
let Some(user) = user else {
|
||||
if online {
|
||||
log("WARN", &format!("Couldn't find profile with name: {key}"));
|
||||
/// GameProfileArgument for a name: the user cache, else the profile
|
||||
/// service, else (offline) the offline player. None, told to the console:
|
||||
/// no such player.
|
||||
fn resolve(&self, name: &str) -> Option<NameAndId> {
|
||||
let found = USER_CACHE.lock().unwrap().as_mut().and_then(|cache| {
|
||||
cache.get_by_name(name, |lower| {
|
||||
let found = profiles::find_by_name(&profiles::discovery_url(), lower);
|
||||
if found.is_none() {
|
||||
log("WARN", &format!("Couldn't find profile with name: {lower}"));
|
||||
}
|
||||
return None;
|
||||
};
|
||||
if online {
|
||||
cache.lock().unwrap().insert(key, user.clone());
|
||||
}
|
||||
Some(user)
|
||||
found
|
||||
})
|
||||
});
|
||||
if user.is_none() {
|
||||
if found.is_none() {
|
||||
self.console_reply(Text::translate("argument.player.unknown", &[]));
|
||||
}
|
||||
user
|
||||
found
|
||||
}
|
||||
|
||||
/// MinecraftServer.sendSystemMessage: what the console is told.
|
||||
@@ -781,7 +775,7 @@ impl Game<'_> {
|
||||
));
|
||||
}
|
||||
"op" | "deop" if !rest.is_empty() => {
|
||||
let Some(user) = self.resolve(rest[0], state.online) else {
|
||||
let Some(user) = self.resolve(rest[0]) else {
|
||||
return;
|
||||
};
|
||||
let level = 4;
|
||||
@@ -813,7 +807,7 @@ impl Game<'_> {
|
||||
}
|
||||
"whitelist" => self.console_whitelist(state, &rest),
|
||||
"ban" if !rest.is_empty() => {
|
||||
let Some(user) = self.resolve(rest[0], state.online) else {
|
||||
let Some(user) = self.resolve(rest[0]) else {
|
||||
return;
|
||||
};
|
||||
let reason = (rest.len() > 1).then(|| rest[1..].join(" "));
|
||||
@@ -905,7 +899,7 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
"pardon" if !rest.is_empty() => {
|
||||
let Some(user) = self.resolve(rest[0], state.online) else {
|
||||
let Some(user) = self.resolve(rest[0]) else {
|
||||
return;
|
||||
};
|
||||
let removed = state.lists.lock().unwrap().bans.remove(&user);
|
||||
@@ -1056,7 +1050,7 @@ impl Game<'_> {
|
||||
self.console_reply(Text::translate("commands.whitelist.reloaded", &[]));
|
||||
}
|
||||
["add", name] | ["remove", name] => {
|
||||
let Some(user) = self.resolve(name, state.online) else {
|
||||
let Some(user) = self.resolve(name) else {
|
||||
return;
|
||||
};
|
||||
let mut l = state.lists.lock().unwrap();
|
||||
|
||||
@@ -799,7 +799,7 @@ impl Game<'_> {
|
||||
&& let Some(g) = host.hub.guest(conn)
|
||||
{
|
||||
// PlayerList.placeNewPlayer, then the broadcast join message.
|
||||
super::dedicated::remember(&g.name, g.uuid);
|
||||
super::dedicated::player_joined(g.uuid, &g.name);
|
||||
let [x, y, z] = g.position;
|
||||
super::dedicated::log(
|
||||
"INFO",
|
||||
|
||||
@@ -78,6 +78,43 @@ impl Json {
|
||||
}
|
||||
}
|
||||
|
||||
/// `new GsonBuilder().create().toJson(element)`: compact, HTML-safe
|
||||
/// strings, null members skipped.
|
||||
pub fn gson(&self) -> String {
|
||||
let mut out = String::new();
|
||||
self.write_gson(&mut out);
|
||||
out
|
||||
}
|
||||
fn write_gson(&self, out: &mut String) {
|
||||
match self {
|
||||
Json::String(s) => quote(out, s, true),
|
||||
Json::Array(items) => {
|
||||
out.push('[');
|
||||
for (i, v) in items.iter().enumerate() {
|
||||
if i > 0 {
|
||||
out.push(',');
|
||||
}
|
||||
v.write_gson(out);
|
||||
}
|
||||
out.push(']');
|
||||
}
|
||||
Json::Object(m) => {
|
||||
out.push('{');
|
||||
let members = m.iter().filter(|(_, v)| *v != Json::Null);
|
||||
for (i, (k, v)) in members.enumerate() {
|
||||
if i > 0 {
|
||||
out.push(',');
|
||||
}
|
||||
quote(out, k, true);
|
||||
out.push(':');
|
||||
v.write_gson(out);
|
||||
}
|
||||
out.push('}');
|
||||
}
|
||||
other => other.write_compact(out),
|
||||
}
|
||||
}
|
||||
|
||||
/// `new GsonBuilder().setPrettyPrinting().create().toJson(element, writer)`:
|
||||
/// two-space indents, HTML-safe strings, null members skipped.
|
||||
pub fn pretty(&self) -> String {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
//! The dedicated server's files and settings, ported from
|
||||
//! net.minecraft.server.dedicated and net.minecraft.server.players:
|
||||
//! server.properties, eula.txt, the four user lists and looking players up
|
||||
//! by name in online mode. The game's dedicated server
|
||||
//! server.properties, eula.txt, the four user lists, usercache.json and
|
||||
//! looking players up by name. The game's dedicated server
|
||||
//! (`horizon-client --dedicated`) reads them, and `horizon-server` manages
|
||||
//! them; this crate needs neither a window nor the game.
|
||||
pub mod eula;
|
||||
@@ -9,4 +9,5 @@ pub mod java_properties;
|
||||
pub mod json;
|
||||
pub mod profiles;
|
||||
pub mod properties;
|
||||
pub mod user_cache;
|
||||
pub mod user_lists;
|
||||
|
||||
@@ -0,0 +1,318 @@
|
||||
//! usercache.json (CachedUserNameToIdResolver): the players the server has
|
||||
//! seen join or has looked up by name, so commands find a player by name
|
||||
//! without asking the profile service again. Each entry expires a month after
|
||||
//! it was added; the file keeps the 1000 most recently used.
|
||||
use crate::{
|
||||
java_properties::{civil_from_days, days_from_civil, now_millis},
|
||||
json::{self, Json},
|
||||
profiles::valid_player_name,
|
||||
user_lists::{NameAndId, format_date, parse_date},
|
||||
};
|
||||
use std::{collections::HashMap, path::PathBuf};
|
||||
|
||||
const MRU_LIMIT: usize = 1000;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Info {
|
||||
user: NameAndId,
|
||||
expires: i64,
|
||||
last_access: u64,
|
||||
}
|
||||
|
||||
/// `Calendar.add(MONTH, 1)` on a UTC time: the same day and time a month
|
||||
/// later, the day clamped to the end of a shorter month.
|
||||
pub fn one_month_later(millis: i64) -> i64 {
|
||||
let days = millis.div_euclid(86_400_000);
|
||||
let time = millis.rem_euclid(86_400_000);
|
||||
let (y, m, d) = civil_from_days(days);
|
||||
let (y, m) = if m == 12 { (y + 1, 1) } else { (y, m + 1) };
|
||||
let last = days_from_civil(
|
||||
if m == 12 { y + 1 } else { y },
|
||||
if m == 12 { 1 } else { m + 1 },
|
||||
1,
|
||||
) - days_from_civil(y, m, 1);
|
||||
let d = d.min(last as u32);
|
||||
days_from_civil(y, m, d) * 86_400_000 + time
|
||||
}
|
||||
|
||||
pub struct UserCache {
|
||||
file: PathBuf,
|
||||
/// Every entry ever added; the maps point into it, as vanilla's two maps
|
||||
/// share their GameProfileInfo objects.
|
||||
infos: Vec<Info>,
|
||||
by_name: HashMap<String, usize>,
|
||||
by_uuid: HashMap<u128, usize>,
|
||||
operations: u64,
|
||||
/// Off on an online-mode server: a name the profile service doesn't know
|
||||
/// is then no player at all, rather than an offline one.
|
||||
pub resolve_offline_users: bool,
|
||||
}
|
||||
|
||||
impl UserCache {
|
||||
/// The cache in `file`, loaded; also returns the warnings vanilla logs.
|
||||
pub fn load(file: impl Into<PathBuf>) -> (Self, Vec<String>) {
|
||||
let mut cache = Self {
|
||||
file: file.into(),
|
||||
infos: Vec::new(),
|
||||
by_name: HashMap::new(),
|
||||
by_uuid: HashMap::new(),
|
||||
operations: 0,
|
||||
resolve_offline_users: true,
|
||||
};
|
||||
let mut warnings = Vec::new();
|
||||
let entries = match std::fs::read_to_string(&cache.file) {
|
||||
Ok(text) => cache.parse(&text, &mut warnings),
|
||||
Err(_) => Vec::new(),
|
||||
};
|
||||
for info in entries.into_iter().rev() {
|
||||
cache.safe_add(info);
|
||||
}
|
||||
(cache, warnings)
|
||||
}
|
||||
|
||||
fn parse(&self, text: &str, warnings: &mut Vec<String>) -> Vec<Info> {
|
||||
let items = match json::parse(text, false) {
|
||||
Ok(Json::Array(items)) => items,
|
||||
// An empty file is Gson's null.
|
||||
Ok(Json::Null) => return Vec::new(),
|
||||
_ if text.trim().is_empty() => return Vec::new(),
|
||||
_ => {
|
||||
warnings.push(format!(
|
||||
"Failed to load profile cache {}",
|
||||
self.file.display()
|
||||
));
|
||||
return Vec::new();
|
||||
}
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
for item in &items {
|
||||
if !matches!(item, Json::Object(_)) {
|
||||
continue;
|
||||
}
|
||||
let Some(user) = NameAndId::from_json(item) else {
|
||||
continue;
|
||||
};
|
||||
let Some(date) = item.get("expiresOn").and_then(Json::as_string) else {
|
||||
continue;
|
||||
};
|
||||
match parse_date(&date) {
|
||||
Some(expires) => out.push(Info {
|
||||
user,
|
||||
expires,
|
||||
last_access: 0,
|
||||
}),
|
||||
None => warnings.push(format!("Failed to parse date {date}")),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn safe_add(&mut self, mut info: Info) -> usize {
|
||||
self.operations += 1;
|
||||
info.last_access = self.operations;
|
||||
let index = self.infos.len();
|
||||
self.by_name.insert(info.user.name.to_lowercase(), index);
|
||||
self.by_uuid.insert(info.user.id, index);
|
||||
self.infos.push(info);
|
||||
index
|
||||
}
|
||||
|
||||
/// `add`: a player who joined, remembered for a month; saves the file.
|
||||
pub fn add(&mut self, user: NameAndId) {
|
||||
self.add_internal(user, now_millis());
|
||||
}
|
||||
|
||||
fn add_internal(&mut self, user: NameAndId, now: i64) -> NameAndId {
|
||||
let index = self.safe_add(Info {
|
||||
user,
|
||||
expires: one_month_later(now),
|
||||
last_access: 0,
|
||||
});
|
||||
self.save();
|
||||
self.infos[index].user.clone()
|
||||
}
|
||||
|
||||
/// `get(String)`: the player with this name (any case). An expired entry is
|
||||
/// dropped; a name not cached is asked of `lookup` (the profile service,
|
||||
/// given the lower-case name) and, failing that, made an offline player
|
||||
/// when offline users resolve. What is found is cached.
|
||||
pub fn get_by_name(
|
||||
&mut self,
|
||||
name: &str,
|
||||
lookup: impl FnOnce(&str) -> Option<NameAndId>,
|
||||
) -> Option<NameAndId> {
|
||||
self.get_by_name_at(name, now_millis(), lookup)
|
||||
}
|
||||
|
||||
fn get_by_name_at(
|
||||
&mut self,
|
||||
name: &str,
|
||||
now: i64,
|
||||
lookup: impl FnOnce(&str) -> Option<NameAndId>,
|
||||
) -> Option<NameAndId> {
|
||||
let name = name.to_lowercase();
|
||||
let mut found = self.by_name.get(&name).copied();
|
||||
let mut needs_save = false;
|
||||
if let Some(index) = found
|
||||
&& now >= self.infos[index].expires
|
||||
{
|
||||
let user = self.infos[index].user.clone();
|
||||
self.by_uuid.remove(&user.id);
|
||||
self.by_name.remove(&user.name.to_lowercase());
|
||||
needs_save = true;
|
||||
found = None;
|
||||
}
|
||||
let result = if let Some(index) = found {
|
||||
self.operations += 1;
|
||||
self.infos[index].last_access = self.operations;
|
||||
Some(self.infos[index].user.clone())
|
||||
} else {
|
||||
let profile = if valid_player_name(&name) {
|
||||
lookup(&name)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let profile = profile.or_else(|| {
|
||||
self.resolve_offline_users
|
||||
.then(|| NameAndId::offline(&name))
|
||||
});
|
||||
match profile {
|
||||
Some(profile) => {
|
||||
needs_save = false;
|
||||
Some(self.add_internal(profile, now))
|
||||
}
|
||||
None => None,
|
||||
}
|
||||
};
|
||||
if needs_save {
|
||||
self.save();
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// `get(UUID)`: a cached player by id (expired or not).
|
||||
pub fn get_by_id(&mut self, id: u128) -> Option<NameAndId> {
|
||||
let index = *self.by_uuid.get(&id)?;
|
||||
self.operations += 1;
|
||||
self.infos[index].last_access = self.operations;
|
||||
Some(self.infos[index].user.clone())
|
||||
}
|
||||
|
||||
/// The file's text: the 1000 most recently used entries, most recent
|
||||
/// first, as Gson writes them (compact, HTML-safe).
|
||||
pub fn to_json(&self) -> String {
|
||||
let mut entries: Vec<&Info> = self.by_uuid.values().map(|&i| &self.infos[i]).collect();
|
||||
entries.sort_by_key(|info| std::cmp::Reverse(info.last_access));
|
||||
let items = entries
|
||||
.into_iter()
|
||||
.take(MRU_LIMIT)
|
||||
.map(|info| {
|
||||
let mut o = Json::Object(Vec::new());
|
||||
info.user.append_to(&mut o);
|
||||
o.add("expiresOn", Json::String(format_date(info.expires)));
|
||||
o
|
||||
})
|
||||
.collect();
|
||||
Json::Array(items).gson()
|
||||
}
|
||||
|
||||
/// `save`: errors are ignored, as vanilla does.
|
||||
pub fn save(&self) {
|
||||
let _ = std::fs::write(&self.file, self.to_json());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
const DAY: i64 = 86_400_000;
|
||||
|
||||
fn cache(text: &str) -> (UserCache, Vec<String>) {
|
||||
let dir = std::env::temp_dir().join(format!(
|
||||
"horizon-usercache-{}-{}",
|
||||
std::process::id(),
|
||||
text.len()
|
||||
));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let file = dir.join("usercache.json");
|
||||
std::fs::write(&file, text).unwrap();
|
||||
UserCache::load(file)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn months() {
|
||||
let jan31 = days_from_civil(2026, 1, 31) * DAY + 3_723_000;
|
||||
assert_eq!(
|
||||
format_date(one_month_later(jan31)),
|
||||
"2026-02-28 01:02:03 +0000"
|
||||
);
|
||||
let dec15 = days_from_civil(2026, 12, 15) * DAY;
|
||||
assert_eq!(
|
||||
format_date(one_month_later(dec15)),
|
||||
"2027-01-15 00:00:00 +0000"
|
||||
);
|
||||
let jan31_leap = days_from_civil(2028, 1, 31) * DAY;
|
||||
assert_eq!(
|
||||
format_date(one_month_later(jan31_leap)),
|
||||
"2028-02-29 00:00:00 +0000"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_order_and_skips_bad_entries() {
|
||||
let (c, warnings) = cache(
|
||||
r#"[{"uuid":"069a79f4-44e9-4726-a5be-fca90e38aaf5","name":"Notch","expiresOn":"2099-01-01 00:00:00 +0000"},
|
||||
1, {"name":"NoId"}, {"uuid":"853c80ef-3c37-49fd-aa49-938b674adae6","name":"NoDate"},
|
||||
{"uuid":"853c80ef-3c37-49fd-aa49-938b674adae6","name":"BadDate","expiresOn":"soon"},
|
||||
{"uuid":"61699b2e-d327-4a01-9f1e-0ea8c3f06bc6","name":"Alex","expiresOn":"2099-01-01 00:00:00 +0000"}]"#,
|
||||
);
|
||||
assert_eq!(warnings, vec!["Failed to parse date soon".to_owned()]);
|
||||
assert_eq!(
|
||||
c.to_json(),
|
||||
r#"[{"uuid":"069a79f4-44e9-4726-a5be-fca90e38aaf5","name":"Notch","expiresOn":"2099-01-01 00:00:00 +0000"},{"uuid":"61699b2e-d327-4a01-9f1e-0ea8c3f06bc6","name":"Alex","expiresOn":"2099-01-01 00:00:00 +0000"}]"#
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_resolve_through_the_cache() {
|
||||
let (mut c, _) = cache(
|
||||
r#"[{"uuid":"069a79f4-44e9-4726-a5be-fca90e38aaf5","name":"Notch","expiresOn":"2099-01-01 00:00:00 +0000"},
|
||||
{"uuid":"61699b2e-d327-4a01-9f1e-0ea8c3f06bc6","name":"Old","expiresOn":"2000-01-01 00:00:00 +0000"}]"#,
|
||||
);
|
||||
let now = days_from_civil(2026, 10, 17) * DAY;
|
||||
let never = |_: &str| -> Option<NameAndId> { panic!("looked up") };
|
||||
// A hit in any case, and it becomes the most recent.
|
||||
let notch = c.get_by_name_at("NOTCH", now, never).unwrap();
|
||||
assert_eq!(notch.name, "Notch");
|
||||
// Expired: dropped and looked up again, by its lower-case name.
|
||||
let mut asked = Vec::new();
|
||||
let old = c
|
||||
.get_by_name_at("Old", now, |n| {
|
||||
asked.push(n.to_owned());
|
||||
None
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(asked, ["old"]);
|
||||
assert_eq!(old, NameAndId::offline("old"));
|
||||
// Not a valid name: never looked up.
|
||||
let odd = c.get_by_name_at("a b", now, never).unwrap();
|
||||
assert_eq!(odd, NameAndId::offline("a b"));
|
||||
c.resolve_offline_users = false;
|
||||
assert_eq!(c.get_by_name_at("Nobody", now, |_| None), None);
|
||||
let found = NameAndId {
|
||||
id: 7,
|
||||
name: "Steve".into(),
|
||||
};
|
||||
let steve = c.get_by_name_at("steve", now, |_| Some(found.clone()));
|
||||
assert_eq!(steve, Some(found));
|
||||
let json = c.to_json();
|
||||
let names: Vec<&str> = json
|
||||
.split("\"name\":\"")
|
||||
.skip(1)
|
||||
.map(|s| s.split('"').next().unwrap())
|
||||
.collect();
|
||||
assert_eq!(names, ["Steve", "a b", "old", "Notch"]);
|
||||
assert!(json.contains(r#""name":"Steve","expiresOn":"2026-11-17 00:00:00 +0000"}"#));
|
||||
}
|
||||
}
|
||||
@@ -39,7 +39,7 @@ impl NameAndId {
|
||||
name: name.to_owned(),
|
||||
}
|
||||
}
|
||||
fn from_json(o: &Json) -> Option<Self> {
|
||||
pub(crate) fn from_json(o: &Json) -> Option<Self> {
|
||||
let uuid = o.get("uuid")?.as_string()?;
|
||||
let name = o.get("name")?.as_string()?;
|
||||
Some(Self {
|
||||
@@ -47,7 +47,7 @@ impl NameAndId {
|
||||
name,
|
||||
})
|
||||
}
|
||||
fn append_to(&self, o: &mut Json) {
|
||||
pub(crate) fn append_to(&self, o: &mut Json) {
|
||||
o.add("uuid", Json::String(uuid_string(self.id)));
|
||||
o.add("name", Json::String(self.name.clone()));
|
||||
}
|
||||
|
||||
@@ -33,6 +33,12 @@ The dedicated server is the game itself, run headless:
|
||||
`whitelist on|off|list|reload|add|remove`, `ban`, `ban-ip`, `pardon`, `pardon-ip`, `banlist`, `kick` and
|
||||
`say` behave as in `DedicatedServer`. Every other command goes to the game's own dispatcher as the server
|
||||
(permission level 4). The log follows vanilla's Log4j pattern, in `logs/latest.log` and on stdout.
|
||||
- **Player names.** `usercache.json` in the universe folder works as vanilla's `CachedUserNameToIdResolver`.
|
||||
Players are added when they join and kept for a month, and the file keeps the 1000 most recently used,
|
||||
newest first. The console finds a player by name in it, in any case. A name it doesn't hold is asked of the
|
||||
profile service (`getByName`). If the service doesn't know the name, an offline server uses the offline
|
||||
player of the lower-case name; an online server answers "That player does not exist".
|
||||
`tools/test_user_cache_parity.py` checks this against vanilla, with a mock profile service.
|
||||
|
||||
### Measured (2026-10-16, Mac mini M4 Pro, main at bd8dff20, release build)
|
||||
|
||||
|
||||
@@ -35,7 +35,8 @@ exactly:
|
||||
shift-click changes and its lit and cooking totals;
|
||||
- the console lines about the player, the chat, `list`, `say` and `stop`;
|
||||
- the files the servers leave: server.properties (but the date line),
|
||||
eula.txt, ops.json, whitelist.json, banned-players.json, banned-ips.json.
|
||||
eula.txt, ops.json, whitelist.json, banned-players.json, banned-ips.json,
|
||||
usercache.json (but the date the player's entry expires).
|
||||
|
||||
Online mode needs Mojang's session servers and is not tested.
|
||||
"""
|
||||
@@ -238,7 +239,8 @@ def console_lines(lines):
|
||||
|
||||
def server_files(directory):
|
||||
out = []
|
||||
for name in ['server.properties', 'eula.txt', 'ops.json', 'whitelist.json', 'banned-players.json', 'banned-ips.json']:
|
||||
for name in ['server.properties', 'eula.txt', 'ops.json', 'whitelist.json', 'banned-players.json', 'banned-ips.json',
|
||||
'usercache.json']:
|
||||
path = directory / name
|
||||
if not path.exists():
|
||||
out.append(f'{name}: missing')
|
||||
@@ -249,6 +251,9 @@ def server_files(directory):
|
||||
text = re.sub(r'^(#[^\n]*\n)#[^\n]*\n', r'\1#<date>\n', text)
|
||||
# Random per server, and each side has its own port.
|
||||
text = re.sub(r'\n(management-server-secret|server-port)=[^\n]*', r'\n\1=<varies>', text)
|
||||
if name == 'usercache.json':
|
||||
# A month from when the player joined.
|
||||
text = re.sub(r'"expiresOn":"[^"]*"', '"expiresOn":"<a month on>"', text)
|
||||
out.append(f'{name}: {text!r}')
|
||||
return out
|
||||
|
||||
|
||||
@@ -0,0 +1,246 @@
|
||||
#!/usr/bin/env python3
|
||||
"""usercache.json and the console's player names, against vanilla's dedicated server.
|
||||
|
||||
The console finds a player by name through the user cache (CachedUserNameToIdResolver): a name it holds
|
||||
in any case, else the profile service's `getByName` (asked with the lower-case name), else, in offline
|
||||
mode, the offline player of that lower-case name; what it finds is cached for a month and the file
|
||||
rewritten, most recently used first. A small mock of the Minecraft services (dev only: the discovery
|
||||
document and `getByName`, which knows one account) stands in for Mojang's; vanilla finds it through
|
||||
`-Dminecraft.api.discovery.host`, Horizon through `HORIZON_API_DISCOVERY`.
|
||||
|
||||
Each server starts in offline mode in a folder holding a usercache.json with a live entry, an expired
|
||||
one, entries without a date, with a bad date, without an id, and not an object. The console then
|
||||
whitelists, ops, deops and bans players: the cached one in another case, the expired one, the account the
|
||||
service knows, names it doesn't know, a name too long to ask about. The server restarts in online mode,
|
||||
where a name nobody knows is no player at all, and stops. Compared exactly: the console's replies, the
|
||||
names asked of the service in order, and usercache.json, whitelist.json, ops.json and
|
||||
banned-players.json after each run (the dates the servers wrote are placeholders).
|
||||
|
||||
Players who join are added by the dedicated-server harness, which compares usercache.json too.
|
||||
"""
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import platform
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import urllib.parse
|
||||
|
||||
try:
|
||||
from . import lab, test_rust_parity as base
|
||||
from .test_dedicated_server_parity import Server, free_port
|
||||
except ImportError:
|
||||
import lab
|
||||
import test_rust_parity as base
|
||||
from test_dedicated_server_parity import Server, free_port
|
||||
|
||||
NAME = 'user-cache-parity'
|
||||
PROPERTIES = {
|
||||
'online-mode': 'false',
|
||||
'level-seed': '12345',
|
||||
'generate-structures': 'false',
|
||||
'view-distance': '2',
|
||||
'simulation-distance': '2',
|
||||
'spawn-protection': '0',
|
||||
'pause-when-empty-seconds': '-1',
|
||||
}
|
||||
NOTCH = '069a79f444e94726a5befca90e38aaf5'
|
||||
SEEDED = [
|
||||
{'uuid': '853c80ef-3c37-49fd-aa49-938b674adae6', 'name': 'Seeded', 'expiresOn': '2099-01-01 00:00:00 +0000'},
|
||||
{'uuid': '61699b2e-d327-4a01-9f1e-0ea8c3f06bc6', 'name': 'Expired', 'expiresOn': '2001-02-03 04:05:06 +0000'},
|
||||
{'uuid': '00000000-0000-0000-0000-000000000001', 'name': 'NoDate'},
|
||||
{'uuid': '00000000-0000-0000-0000-000000000002', 'name': 'BadDate', 'expiresOn': 'tomorrow'},
|
||||
{'name': 'NoId', 'expiresOn': '2099-01-01 00:00:00 +0000'},
|
||||
'not an object',
|
||||
{'uuid': '00000000-0000-0000-0000-000000000003', 'name': 'Later', 'expiresOn': '2098-05-06 07:08:09 +0100'},
|
||||
]
|
||||
# (console command, the reply it waits for)
|
||||
OFFLINE = [
|
||||
('whitelist add SEEDED', r'System chat: (Added|Player is already)'),
|
||||
('whitelist add Notch', r'System chat: (Added|Player is already)'),
|
||||
('op expired', r'System chat: (Made|Nothing changed)'),
|
||||
('ban Nobody_Here', r'System chat: (Banned|Nothing changed)'),
|
||||
('whitelist add NameMuchTooLongForMinecraft', r'System chat: (Added|Player is already)'),
|
||||
('deop NOTCH', r'System chat: (Made|Nothing changed)'),
|
||||
('whitelist add later', r'System chat: (Added|Player is already)'),
|
||||
('whitelist remove notch', r'System chat: (Removed|Player is not)'),
|
||||
]
|
||||
ONLINE = [
|
||||
('whitelist add Somebody_Else', r'System chat: (Added|That player does not exist)'),
|
||||
('whitelist add nobody_here', r'System chat: (Added|Player is already)'),
|
||||
]
|
||||
FILES = ['usercache.json', 'whitelist.json', 'ops.json', 'banned-players.json']
|
||||
|
||||
|
||||
class Services:
|
||||
"""The mock discovery document and profile lookup by name."""
|
||||
|
||||
def __init__(self):
|
||||
self.asked = []
|
||||
self.lock = threading.Lock()
|
||||
services = self
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
def log_message(self, *args):
|
||||
pass
|
||||
|
||||
def reply(self, status, body):
|
||||
data = json.dumps(body).encode()
|
||||
self.send_response(status)
|
||||
self.send_header('Content-Type', 'application/json')
|
||||
self.send_header('Content-Length', str(len(data)))
|
||||
self.end_headers()
|
||||
self.wfile.write(data)
|
||||
|
||||
def do_GET(self):
|
||||
url = urllib.parse.urlparse(self.path)
|
||||
if url.path == '/minecraft/client':
|
||||
return self.reply(200, services.discovery())
|
||||
if url.path.startswith('/profiles/name/'):
|
||||
name = urllib.parse.unquote(url.path.removeprefix('/profiles/name/'))
|
||||
with services.lock:
|
||||
services.asked.append(name)
|
||||
if name.lower() == 'notch':
|
||||
return self.reply(200, {'id': NOTCH, 'name': 'Notch'})
|
||||
return self.reply(404, {'path': url.path, 'errorMessage': f"Couldn't find any profile with name {name}"})
|
||||
self.reply(404, {'error': 'NotFound', 'path': url.path})
|
||||
|
||||
self.server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
|
||||
self.url = f'http://127.0.0.1:{self.server.server_address[1]}'
|
||||
threading.Thread(target=self.server.serve_forever, daemon=True).start()
|
||||
|
||||
def discovery(self):
|
||||
def endpoints(**names):
|
||||
return {'endpoints': {k: {'uri': self.url + v} for k, v in names.items()}}
|
||||
return {'environment': 'mock', 'product': 'minecraft', 'discovery': {
|
||||
'authentication': endpoints(getPublicKeys='/publickeys'),
|
||||
'session': endpoints(join='/session/minecraft/join', verify='/session/minecraft/hasJoined',
|
||||
getProfileById='/session/minecraft/profile/{profileId}'),
|
||||
'player': endpoints(),
|
||||
'profiles': endpoints(getByName='/profiles/name/{name}'),
|
||||
'telemetry': endpoints(),
|
||||
}}
|
||||
|
||||
def take(self):
|
||||
with self.lock:
|
||||
asked, self.asked = self.asked, []
|
||||
return asked
|
||||
|
||||
def stop(self):
|
||||
self.server.shutdown()
|
||||
|
||||
|
||||
def write_properties(directory, online):
|
||||
props = dict(PROPERTIES, **{'server-port': str(free_port()), 'online-mode': str(online).lower()})
|
||||
(directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()),
|
||||
encoding='iso-8859-1')
|
||||
|
||||
|
||||
def files(directory):
|
||||
out = []
|
||||
for name in FILES:
|
||||
path = directory / name
|
||||
if not path.exists():
|
||||
out.append(f'{name}: missing')
|
||||
continue
|
||||
text = path.read_text(encoding='utf-8')
|
||||
# The dates written now: a month on for the cache, the ban's creation.
|
||||
text = re.sub(r'"(expiresOn|created)": ?"20[2-3]\d-[^"]*"', r'"\1":"<now>"', text)
|
||||
out.append(f'{name}: {text}')
|
||||
return out
|
||||
|
||||
|
||||
def wait_after(server, seen, pattern, timeout=60):
|
||||
"""Waits for a line matching `pattern` after the first `seen` lines."""
|
||||
deadline = time.time() + timeout
|
||||
regex = re.compile(pattern)
|
||||
while not any(regex.search(l) for l in server.lines[seen:]):
|
||||
if time.time() > deadline or server.process.poll() is not None:
|
||||
raise AssertionError(f'{server.log_path.name}: no reply matching {pattern!r}:\n'
|
||||
+ '\n'.join(server.lines[-20:]))
|
||||
time.sleep(0.1)
|
||||
|
||||
|
||||
def run(label, command, build, services, steps, online, transcript):
|
||||
directory = build / label
|
||||
write_properties(directory, online)
|
||||
server = Server(command, directory, f'{label}-{"online" if online else "offline"}')
|
||||
try:
|
||||
server.wait_for(r'Done \(')
|
||||
services.take()
|
||||
for line, reply in steps:
|
||||
seen = len(server.lines)
|
||||
server.console(line)
|
||||
wait_after(server, seen, reply)
|
||||
replies = [l for l in server.lines[seen:] if 'System chat:' in l]
|
||||
transcript.append(f'> {line}')
|
||||
transcript += [re.sub(r'^\[[^]]*\] ', '', l) for l in replies]
|
||||
transcript.append(f'asked: {services.take()}')
|
||||
finally:
|
||||
server.stop()
|
||||
transcript += files(directory)
|
||||
|
||||
|
||||
def run_side(label, command, build, services):
|
||||
directory = build / label
|
||||
if directory.exists():
|
||||
shutil.rmtree(directory)
|
||||
directory.mkdir(parents=True)
|
||||
(directory / 'eula.txt').write_text('eula=true\n')
|
||||
(directory / 'usercache.json').write_text(json.dumps(SEEDED), encoding='utf-8')
|
||||
transcript = []
|
||||
run(label, command, build, services, OFFLINE, False, transcript)
|
||||
run(label, command, build, services, ONLINE, True, transcript)
|
||||
return transcript
|
||||
|
||||
|
||||
def main():
|
||||
lock, jars, libraries = base.verify_artifacts()
|
||||
build = lab.LOCAL / NAME
|
||||
build.mkdir(parents=True, exist_ok=True)
|
||||
report = build / 'report.json'
|
||||
report.unlink(missing_ok=True)
|
||||
subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
|
||||
check=True, capture_output=True)
|
||||
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
|
||||
cwd=lab.ROOT, text=True))
|
||||
binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
|
||||
services = Services()
|
||||
discovery = services.url + '/minecraft/client'
|
||||
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
|
||||
vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', f'-Dminecraft.api.discovery.host={discovery}',
|
||||
'-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
|
||||
horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
|
||||
os.environ['HORIZON_API_DISCOVERY'] = discovery
|
||||
try:
|
||||
vanilla = run_side('vanilla', vanilla_server, build, services)
|
||||
horizon = run_side('horizon', horizon_server, build, services)
|
||||
finally:
|
||||
services.stop()
|
||||
(build / 'vanilla.txt').write_text('\n'.join(vanilla) + '\n', encoding='utf-8')
|
||||
(build / 'horizon.txt').write_text('\n'.join(horizon) + '\n', encoding='utf-8')
|
||||
if vanilla != horizon:
|
||||
import difflib
|
||||
diff = '\n'.join(difflib.unified_diff(vanilla, horizon, 'vanilla', 'horizon', n=1, lineterm=''))
|
||||
raise AssertionError(f'transcripts differ (see {build}/vanilla.txt and horizon.txt):\n' + diff[:6000])
|
||||
if not any('Notch' in l for l in vanilla if l.startswith('usercache.json')):
|
||||
raise AssertionError(f'the cache never held the looked-up account (see {build})')
|
||||
lab.write_json(report, dict(
|
||||
schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(),
|
||||
java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0],
|
||||
lines=len(vanilla), output_sha256=lab.digest(build / 'horizon.txt', 'sha256'),
|
||||
scope='usercache.json (load, expiry, most recently used order, Gson output) and the console finding '
|
||||
'players by name through it and the profile service, offline and online.'))
|
||||
print(f'user cache: {len(vanilla)} lines identical')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
main()
|
||||
except AssertionError as error:
|
||||
sys.exit(f'{NAME}: {error}')
|
||||
Reference in New Issue
Block a user