From f08019bf079a5976f1f456ddc3ca7d7f57663145 Mon Sep 17 00:00:00 2001 From: Codex Date: Mon, 16 Nov 2026 22:58:59 +0000 Subject: [PATCH 1/2] Preserve canonical Bedrock session identities --- .../api/bedrock/BedrockNameResolver.java | 92 +++-- .../api/user/usercache/UserDataManager.java | 1 + .../tests/BedrockCanonicalIdentityTest.java | 315 ++++++++++++++++++ .../tests/BedrockNameResolverTest.java | 9 +- 4 files changed, 396 insertions(+), 21 deletions(-) create mode 100644 AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java index d7547d6a1..6438d6e2a 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java @@ -27,7 +27,10 @@ public final class BedrockNameResolver { private final String bedrockPrefix; private final AdvancedCorePlugin plugin; + private static final String CANONICAL_NAME_KEY = "BedrockCanonicalName"; private final Map cache = new ConcurrentHashMap<>(); + // An observed server name is separate from Bedrock client/transport detection. + private final Map canonicalNames = new ConcurrentHashMap<>(); private final Map ciIndex = new ConcurrentHashMap<>(); /** @@ -127,30 +130,77 @@ public void learn(AdvancedCoreUser user) { String name = user.getPlayerName(); if (name == null || name.isEmpty()) return; - putLearned(name, user.isBedrockUser()); + boolean bedrock = user.isBedrockUser(); + putLearned(name, bedrock); + String canonical = bedrock ? storedCanonicalName(user, name) : null; + if (canonical != null) canonicalNames.put(name.toLowerCase(Locale.ROOT), canonical); } /** * Learns whether a player is a Bedrock player. * + * Observations are immediately available in this resolver. Persistence is queued + * on the ordered user-storage worker and follows ordinary user-cache durability; + * return does not acknowledge a durable write. Call from the platform owner. + * * @param player the player to learn from */ public void learn(Player player) { - if (player == null) - return; + if (player == null) return; + // Capture platform state now; never retain a Player in the storage task. final UUID uuid = player.getUniqueId(); - final boolean isBedrock = bedrockDetect.isBedrock(uuid); - final String originalName = player.getName(); - if (isBedrock) { - plugin.debug("Learned Bedrock player: " + originalName + " (" + uuid + ")"); - cache.put(originalName, true); - ciIndex.put(originalName.toLowerCase(Locale.ROOT), originalName); - AdvancedCoreUser user = userManager.getUser(player); - if (user != null) - user.setBedrockUser(true); + final String name = player.getName(); + if (uuid == null || name == null || name.isEmpty() || !bedrockDetect.isBedrock(uuid)) return; + putLearned(name, true); + canonicalNames.put(name.toLowerCase(Locale.ROOT), name); + var manager = userManager.getDataManager(); + if (manager == null || manager.getTimer() == null) { + reportLearningFailure(); + return; + } + try { + manager.getTimer().execute(() -> { + try { + AdvancedCoreUser user = userManager.getUser(uuid, name); + if (user == null) { reportLearningFailure(); return; } + // This is identity evidence on this UUID record, never a name/UUID remap. + user.getData().setString(CANONICAL_NAME_KEY, name); + user.setBedrockUser(true); + } catch (RuntimeException failure) { + reportLearningFailure(); + } + }); + } catch (RuntimeException rejected) { + reportLearningFailure(); + } + } + + private void reportLearningFailure() { + plugin.getLogger().warning("Unable to persist observed Bedrock identity; observation remains session-local"); + } + + private String storedCanonicalName(AdvancedCoreUser user, String name) { + try { + if (user.getData() == null) return null; + String observed = user.getData().getString(CANONICAL_NAME_KEY, user.getUserDataFetchMode()); + // Never let metadata redirect a query to another name/account. + return observed != null && observed.equalsIgnoreCase(name) ? observed : null; + } catch (RuntimeException unreadable) { + plugin.getLogger().warning("Unable to read observed Bedrock identity; retaining legacy resolution"); + return null; } } + private String exactName(String name, boolean bedrock) { + String observed = canonicalNames.get(name.toLowerCase(Locale.ROOT)); + return observed == null ? addPrefixIfNeeded(name, bedrock) : observed; + } + + private String storedExactName(String name, boolean bedrock, AdvancedCoreUser user) { + String observed = bedrock ? storedCanonicalName(user, name) : null; + return observed == null ? addPrefixIfNeeded(name, bedrock) : observed; + } + /** * Detect whether a name corresponds to a Bedrock player. * @@ -192,7 +242,7 @@ public Result resolve(String incomingName) { Boolean cached = getCachedCaseInsensitive(incomingName); if (cached != null) { boolean bedrock = cached; - String finalName = addPrefixIfNeeded(incomingName, bedrock); + String finalName = exactName(incomingName, bedrock); return new Result(finalName, bedrock, "cache-" + (bedrock ? "bedrock" : "java")); } @@ -200,7 +250,7 @@ public Result resolve(String incomingName) { if (userManager.userExistStored(incomingName)) { AdvancedCoreUser user = userManager.getUser(incomingName); boolean bedrock = user.isBedrockUser(); - String finalName = addPrefixIfNeeded(incomingName, bedrock); + String finalName = storedExactName(incomingName, bedrock, user); return new Result(finalName, bedrock, "db-" + (bedrock ? "bedrock" : "java")); } } catch (Throwable ignored) { @@ -321,7 +371,7 @@ private Result resolvePersisted(String incomingName, Result fallback) { AdvancedCoreUser user = getPersistedUser(incomingName); if (user != null) { boolean bedrock = user.isBedrockUser(); - return new Result(addPrefixIfNeeded(incomingName, bedrock), bedrock, + return new Result(storedExactName(incomingName, bedrock, user), bedrock, "db-" + (bedrock ? "bedrock" : "java")); } @@ -387,18 +437,18 @@ private Result resolveExactWithoutDb(String incomingName) { if (match != null) return resultFromOnlineMatch(incomingName, match); Boolean cached = getCachedCaseInsensitive(incomingName); if (cached == null) return null; - return new Result(addPrefixIfNeeded(incomingName, cached), cached, + return new Result(exactName(incomingName, cached), cached, "cache-" + (cached ? "bedrock" : "java")); } /** - * Get the prefixed name if the player is a Bedrock player. + * Get the canonical name, preserving observed linked Java and unlinked Bedrock identities. * * @param name the player name - * @return the prefixed name if Bedrock, otherwise the original name + * @return the canonical name selected by the resolver */ public String getPrefixedIfBedrock(String name) { - return addPrefixIfNeeded(name, isBedrockName(name)); + return resolve(name).finalName; } /** @@ -407,6 +457,7 @@ public String getPrefixedIfBedrock(String name) { public void clearCache() { cache.clear(); ciIndex.clear(); + canonicalNames.clear(); } private void putLearned(String originalCaseName, boolean isBedrock) { @@ -462,7 +513,8 @@ private String stripPrefixIfPresent(String n) { private Result resultFromOnlineMatch(String incomingName, Player match) { boolean bedrock = bedrockDetect.isBedrock(match.getUniqueId()); - String finalName = bedrock ? addPrefixIfNeeded(match.getName(), true) : incomingName; + // Bukkit already exposes the canonical linked Java or unlinked Bedrock name. + String finalName = bedrock ? match.getName() : incomingName; return new Result(finalName, bedrock, bedrock ? "online-uuid-bedrock" : "online-uuid-java"); } diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/usercache/UserDataManager.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/usercache/UserDataManager.java index 857ef3fa6..4332e8174 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/usercache/UserDataManager.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/usercache/UserDataManager.java @@ -1446,6 +1446,7 @@ private void loadKeys() { addKey(new UserDataKeyString("ChoicePreference")); addKey(new UserDataKeyBoolean("CheckWorld")); addKey(new UserDataKeyBoolean("isBedrock")); + addKey(new UserDataKeyString("BedrockCanonicalName")); } public void removeCache(UUID uuid, String playerName) { diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java new file mode 100644 index 000000000..7fb0e5185 --- /dev/null +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java @@ -0,0 +1,315 @@ +package com.bencodez.advancedcore.tests; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +import java.lang.reflect.Field; +import java.util.*; +import java.util.concurrent.*; +import java.util.logging.Logger; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.function.Supplier; +import com.bencodez.advancedcore.api.player.UuidLookup; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.junit.jupiter.api.*; +import org.mockito.MockedStatic; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.bedrock.BedrockNameResolver; +import com.bencodez.advancedcore.api.user.*; +import com.bencodez.advancedcore.api.user.usercache.UserDataManager; + +/** Exercises the real detector with the optional Floodgate reflection contract, without a server. */ +class BedrockCanonicalIdentityTest { + private final AdvancedCorePlugin plugin = mock(AdvancedCorePlugin.class, RETURNS_DEEP_STUBS); + private final UserManager users = mock(UserManager.class); + private final UserDataManager manager = mock(UserDataManager.class); + private final ScheduledExecutorService worker = mock(ScheduledExecutorService.class); + private final ArrayDeque pending = new ArrayDeque<>(); + private final FloodgateContract api = new FloodgateContract(); + private final Map records = new HashMap<>(); + private MockedStatic bukkit; + private BedrockNameResolver resolver; + + @BeforeEach void setup() throws Exception { + when(plugin.getUserManager()).thenReturn(users); + when(plugin.getOptions().getBedrockPlayerPrefix()).thenReturn("."); + when(plugin.getLogger()).thenReturn(mock(Logger.class)); + when(users.getDataManager()).thenReturn(manager); + when(manager.getTimer()).thenReturn(worker); + doAnswer(call -> { pending.add(call.getArgument(0)); return null; }).when(worker).execute(any(Runnable.class)); + when(users.getUser(any(UUID.class), anyString())).thenAnswer(call -> records.get(call.getArgument(0))); + bukkit = mockStatic(Bukkit.class); + online(); + resolver = newResolver(); + } + @AfterEach void close() { bukkit.close(); } + + @Test void linkedOnlineIdentityIsCanonicalAcrossAllResolverEntrypoints() { + Player linked = player("SyntheticLinked", true); + online(linked); + assertEquals("SyntheticLinked", resolver.resolve("SyntheticLinked").finalName); + assertEquals("SyntheticLinked", resolver.resolveWithoutDb("SyntheticLinked").finalName); + assertEquals("SyntheticLinked", resolver.getPrefixedIfBedrock("SyntheticLinked")); + assertTrue(resolver.resolve("SyntheticLinked").isBedrock, "client type stays Bedrock"); + resolver.resolveAsync("SyntheticLinked", result -> assertEquals("SyntheticLinked", result.finalName), + failure -> fail(failure)); + } + + @Test void observedLinkedNameSurvivesDisconnectStoredLearningAndResolverRestart() throws Exception { + Player linked = player("SyntheticLinked", true); + AdvancedCoreUser record = record(linked); + online(linked); + resolver.learn(linked); + verify(users, never()).getUser(any(UUID.class), anyString()); + online(); + assertEquals("SyntheticLinked", resolver.resolve("SyntheticLinked").finalName); + // Even a disconnected/stale Player must never be accessed by persistence. + when(linked.getName()).thenThrow(new AssertionError("worker accessed Player name")); + drain(); + verify(record).setBedrockUser(true); + resolver.clearCache(); + resolver.learn(record); + assertEquals("SyntheticLinked", resolver.resolve("syntheticlinked").finalName); + resolver = newResolver(); + resolver.learn(record); + assertEquals("SyntheticLinked", resolver.resolve("SyntheticLinked").finalName); + assertTrue(resolver.isBedrockName("SyntheticLinked")); + verify(users, times(1)).getUser(linked.getUniqueId(), "SyntheticLinked"); + verify(users, never()).getUser(any(Player.class)); + } + + @Test void unlinkedBedrockAndDistinctJavaAccountKeepTheirOwnNames() { + Player unlinked = player(".SharedName", false); + AdvancedCoreUser bedrock = record(unlinked); + AdvancedCoreUser java = mock(AdvancedCoreUser.class); + when(java.getPlayerName()).thenReturn("SharedName"); + resolver.learn(java); + online(unlinked); + assertEquals("SharedName", resolver.resolve("SharedName").finalName); + assertEquals(".SharedName", resolver.resolve(".SharedName").finalName); + resolver.learn(unlinked); + drain(); online(); + assertEquals("SharedName", resolver.resolve("SharedName").finalName); + assertEquals(".SharedName", resolver.resolve(".SharedName").finalName); + verify(bedrock).setBedrockUser(true); + } + + @Test void legacyFlagWithoutCanonicalEvidenceDoesNotReassignExistingIdentity() { + AdvancedCoreUser legacy = mock(AdvancedCoreUser.class); + when(legacy.getPlayerName()).thenReturn("LegacyName"); + when(legacy.isBedrockUser()).thenReturn(true); + resolver.learn(legacy); + assertEquals(".LegacyName", resolver.resolve("LegacyName").finalName); + verify(legacy, never()).setBedrockUser(anyBoolean()); + } + + @Test void unlinkAndRelinkDoNotRetargetEarlierJavaIdentityOrWriteAnotherUuid() { + Player first = player("FirstJava", true); + AdvancedCoreUser firstRecord = record(first); + resolver.learn(first); drain(); + api.players.remove(first.getUniqueId()); // unlink: the Bedrock session gets its own identity + Player unlinked = player(".BedrockName", false); + AdvancedCoreUser unlinkedRecord = record(unlinked); + resolver.learn(unlinked); drain(); + Player second = player("SecondJava", true); + AdvancedCoreUser secondRecord = record(second); + api.players.remove(unlinked.getUniqueId()); + resolver.learn(second); drain(); online(); + assertEquals("FirstJava", resolver.resolve("FirstJava").finalName); + assertEquals("SecondJava", resolver.resolve("SecondJava").finalName); + assertEquals(".BedrockName", resolver.resolve(".BedrockName").finalName); + for (Player player : List.of(first, unlinked, second)) verify(users).getUser(player.getUniqueId(), player.getName()); + for (AdvancedCoreUser record : List.of(firstRecord, unlinkedRecord, secondRecord)) { + verify(record).setBedrockUser(true); + } + verify(users, never()).getUser(anyString()); + } + + @Test void rejectedPersistenceRetainsObservedSessionIdentityAndReportsFailure() { + Player linked = player("RejectedJava", true); + doThrow(new RejectedExecutionException("synthetic rejection")).when(worker).execute(any(Runnable.class)); + resolver.learn(linked); online(); + assertEquals("RejectedJava", resolver.resolve("RejectedJava").finalName); + verify(users, never()).getUser(any(UUID.class), anyString()); + verify(plugin.getLogger()).warning(anyString()); + } + + @Test void optionalApiFailureDoesNotErasePreviouslyObservedIdentity() { + Player linked = player("KnownJava", true); + record(linked); + resolver.learn(linked); drain(); + api.failed = true; + online(linked); + assertEquals("KnownJava", resolver.resolve("KnownJava").finalName); + resolver.learn(linked); // failed optional detection must not rewrite the stored observation + online(); + assertEquals("KnownJava", resolver.resolve("KnownJava").finalName); + assertTrue(pending.isEmpty()); + } + + @Test void failedStorageWriteReportsFailureWithoutClaimingRestartRecovery() throws Exception { + Player linked = player("FailedJava", true); + AdvancedCoreUser record = record(linked); + UserData recordData = record.getData(); + doThrow(new IllegalStateException("synthetic private failure")) + .when(recordData).setString(anyString(), anyString()); + resolver.learn(linked); online(); drain(); + assertEquals("FailedJava", resolver.resolve("FailedJava").finalName); + verify(plugin.getLogger()).warning("Unable to persist observed Bedrock identity; observation remains session-local"); + verify(record, never()).setBedrockUser(true); + resolver = newResolver(); + // No persisted observation is invented after the failed task. + resolver.learn(record); + assertFalse(resolver.isBedrockName("FailedJava")); + } + + @Test void missingOptionalApiKeepsExactJavaIdentityAndDoesNotWriteStorage() { + Player java = mock(Player.class); + when(java.getName()).thenReturn("PlainJava"); + when(java.getUniqueId()).thenReturn(UUID.fromString("11111111-2222-4333-8444-555555555555")); + online(java); + assertEquals("PlainJava", resolver.resolve("PlainJava").finalName); + resolver.learn(java); + assertTrue(pending.isEmpty()); + verifyNoInteractions(worker); + } + + @Test void storedMetadataCannotRedirectAnExactNameToAnotherAccount() { + Player linked = player("SafeJava", true); + AdvancedCoreUser record = record(linked); + record.getData().setString("BedrockCanonicalName", "DifferentAccount"); + record.setBedrockUser(true); + resolver.learn(record); + assertEquals(".SafeJava", resolver.resolve("SafeJava").finalName, "ambiguous legacy flag stays legacy"); + } + + @Test void directPersistedLookupUsesOnlyMatchingCanonicalObservation() throws Exception { + Player linked = player("StoredJava", true); + AdvancedCoreUser record = record(linked); + resolver.learn(linked); drain(); + resolver = newResolver(); + when(users.userExistStored("StoredJava")).thenReturn(true); + when(users.getUser("StoredJava")).thenReturn(record); + assertEquals("StoredJava", resolver.resolve("StoredJava").finalName); + } + + @Test void independentObservationsRemainOwnedWhileStorageWorkerIsBlocked() { + Player first = player("QueuedFirst", true); + Player second = player("QueuedSecond", true); + record(first); record(second); + resolver.learn(first); resolver.learn(second); + assertEquals(2, pending.size()); + verify(users, never()).getUser(any(UUID.class), anyString()); + online(); + assertEquals("QueuedFirst", resolver.resolve("QueuedFirst").finalName); + assertEquals("QueuedSecond", resolver.resolve("QueuedSecond").finalName); + drain(); + verify(users).getUser(first.getUniqueId(), "QueuedFirst"); + verify(users).getUser(second.getUniqueId(), "QueuedSecond"); + } + + @Test void asynchronousPersistedLookupReadsCanonicalEvidenceOnItsWorker() throws Exception { + Player linked = player("AsyncJava", true); + UUID id = linked.getUniqueId(); + AdvancedCoreUser record = record(linked); + resolver.learn(linked); drain(); + resolver = newResolver(); + when(manager.mustDeferSharedStorageAccess()).thenReturn(true); + when(users.getUser(id, false)).thenReturn(record); + when(record.userDataFetechMode(UserDataFetchMode.NO_CACHE)).thenReturn(record); + AtomicReference storageTask = new AtomicReference<>(); + doAnswer(call -> { + Supplier work = call.getArgument(0); + @SuppressWarnings("unchecked") Consumer success = call.getArgument(1); + storageTask.set(() -> success.accept(work.get())); + return true; + }).when(manager).deferSharedStorageResult(any(), any(), any()); + UuidLookup lookup = mock(UuidLookup.class); + when(lookup.getUUIDFromStorage("AsyncJava")).thenReturn(id.toString()); + AtomicReference result = new AtomicReference<>(); + try (MockedStatic lookups = mockStatic(UuidLookup.class)) { + lookups.when(UuidLookup::getInstance).thenReturn(lookup); + resolver.resolveAsync("AsyncJava", result::set, failure -> fail(failure)); + assertNull(result.get()); + verifyNoInteractions(lookup); + assertNotNull(storageTask.get()); + bukkit.when(Bukkit::getOnlinePlayers).thenThrow(new AssertionError("storage accessed Bukkit")); + storageTask.get().run(); + assertEquals("AsyncJava", result.get().finalName); + assertTrue(result.get().isBedrock); + verify(lookup, never()).getUUIDFromStorage(".AsyncJava"); + } + } + + @Test void unreadableNewMetadataPreservesLegacyLoadingAndReportsFixedFailure() { + Player linked = player("UnreadableJava", true); + AdvancedCoreUser record = record(linked); + record.setBedrockUser(true); + UserData data = record.getData(); + when(data.getString(anyString(), eq(UserDataFetchMode.DEFAULT))) + .thenThrow(new IllegalStateException("synthetic private cause")); + assertDoesNotThrow(() -> resolver.learn(record)); + assertEquals(".UnreadableJava", resolver.resolve("UnreadableJava").finalName); + verify(plugin.getLogger()).warning("Unable to read observed Bedrock identity; retaining legacy resolution"); + } + + private void online(Player... players) { bukkit.when(Bukkit::getOnlinePlayers).thenReturn(List.of(players)); } + private void drain() { while (!pending.isEmpty()) pending.remove().run(); } + private Player player(String name, boolean linked) { + Player player = mock(Player.class); + UUID uuid = UUID.nameUUIDFromBytes(("synthetic:" + name).getBytes(java.nio.charset.StandardCharsets.UTF_8)); + when(player.getName()).thenReturn(name); + when(player.getUniqueId()).thenReturn(uuid); + api.players.put(uuid, new Session(linked, uuid, name)); + return player; + } + private AdvancedCoreUser record(Player player) { + String observedName = player.getName(); + UUID observedId = player.getUniqueId(); + AdvancedCoreUser user = mock(AdvancedCoreUser.class); + UserData data = mock(UserData.class); + Map stored = new HashMap<>(); + when(user.getData()).thenReturn(data); + when(user.getPlayerName()).thenReturn(observedName); + when(user.getUserDataFetchMode()).thenReturn(UserDataFetchMode.DEFAULT); + when(user.isBedrockUser()).thenAnswer(call -> Boolean.parseBoolean(stored.get("isBedrock"))); + when(data.getString(anyString(), eq(UserDataFetchMode.DEFAULT))).thenAnswer(call -> stored.get(call.getArgument(0))); + doAnswer(call -> { stored.put(call.getArgument(0), call.getArgument(1)); return null; }) + .when(data).setString(anyString(), anyString()); + doAnswer(call -> { stored.put("isBedrock", "true"); return null; }).when(user).setBedrockUser(true); + records.put(observedId, user); + return user; + } + private BedrockNameResolver newResolver() throws Exception { + BedrockNameResolver result = new BedrockNameResolver(plugin); + var detector = new BedrockNameResolver.BedrockDetect(); + field(detector, "floodgateApi", api); + field(detector, "fgIsFloodgatePlayer", FloodgateContract.class.getMethod("isFloodgatePlayer", UUID.class)); + field(detector, "fgGetPlayer", FloodgateContract.class.getMethod("getPlayer", UUID.class)); + field(detector, "floodgateAvailable", true); + field(result, "bedrockDetect", detector); + return result; + } + private static void field(Object target, String name, Object value) throws Exception { + Field field = target.getClass().getDeclaredField(name); field.setAccessible(true); field.set(target, value); + } + // Public reflection fixtures implement the optional API contract, not platform class identities. + public record Session(boolean linked, UUID id, String name) { + public boolean isLinked() { return linked; } + public UUID getCorrectUniqueId() { return id; } + public String getCorrectUsername() { return name; } + } + public static class FloodgateContract { + final Map players = new HashMap<>(); + boolean failed; + public boolean isFloodgatePlayer(UUID uuid) { + if (failed) throw new IllegalStateException("synthetic unavailable API"); + return players.containsKey(uuid); + } + public Session getPlayer(UUID uuid) { return players.get(uuid); } + } +} diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java index d5209f9ff..5b946336b 100644 --- a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java @@ -574,7 +574,14 @@ public void testLearn_playerBedrock_updatesCacheAndSetsUserFlag() throws Excepti when(player.getName()).thenReturn(".BedrockDude"); AdvancedCoreUser user = mock(AdvancedCoreUser.class); - when(userManager.getUser(player)).thenReturn(user); + when(userManager.getUser(uuid, ".BedrockDude")).thenReturn(user); + when(user.getData()).thenReturn(mock(com.bencodez.advancedcore.api.user.UserData.class)); + UserDataManager manager = mock(UserDataManager.class); + java.util.concurrent.ScheduledExecutorService worker = mock(java.util.concurrent.ScheduledExecutorService.class); + when(userManager.getDataManager()).thenReturn(manager); + when(manager.getTimer()).thenReturn(worker); + doAnswer(call -> { call.getArgument(0, Runnable.class).run(); return null; }) + .when(worker).execute(any(Runnable.class)); resolver.learn(player); From 1e6a2aa6994a41e9903d56a7147616c3d2ffcc6b Mon Sep 17 00:00:00 2001 From: Codex Date: Tue, 17 Nov 2026 00:25:50 +0000 Subject: [PATCH 2/2] Preserve observed flags and notification ownership --- .../api/bedrock/BedrockNameResolver.java | 33 ++++- .../advancedcore/api/user/UserManager.java | 40 +++++- .../tests/BedrockCanonicalIdentityTest.java | 124 +++++++++++++++++- .../tests/BedrockNameResolverTest.java | 2 + .../UserDataNotificationDispatcherTest.java | 70 ++++++++++ 5 files changed, 254 insertions(+), 15 deletions(-) create mode 100644 AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/user/UserDataNotificationDispatcherTest.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java index 6438d6e2a..b1e2aaa03 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/bedrock/BedrockNameResolver.java @@ -3,6 +3,7 @@ import java.lang.reflect.Method; import java.util.Locale; import java.util.Map; +import java.util.Set; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Consumer; @@ -31,6 +32,7 @@ public final class BedrockNameResolver { private final Map cache = new ConcurrentHashMap<>(); // An observed server name is separate from Bedrock client/transport detection. private final Map canonicalNames = new ConcurrentHashMap<>(); + private final Set observedBedrockNames = ConcurrentHashMap.newKeySet(); private final Map ciIndex = new ConcurrentHashMap<>(); /** @@ -142,17 +144,20 @@ public void learn(AdvancedCoreUser user) { * Observations are immediately available in this resolver. Persistence is queued * on the ordered user-storage worker and follows ordinary user-cache durability; * return does not acknowledge a durable write. Call from the platform owner. + * Legacy inline notifications return through that player's owner scheduler; + * the shared-SQL notification lane remains worker-owned. * * @param player the player to learn from */ public void learn(Player player) { if (player == null) return; - // Capture platform state now; never retain a Player in the storage task. + // Capture storage identity now. The Player is only a platform callback target. final UUID uuid = player.getUniqueId(); final String name = player.getName(); if (uuid == null || name == null || name.isEmpty() || !bedrockDetect.isBedrock(uuid)) return; - putLearned(name, true); canonicalNames.put(name.toLowerCase(Locale.ROOT), name); + observedBedrockNames.add(name.toLowerCase(Locale.ROOT)); + putLearned(name, true); var manager = userManager.getDataManager(); if (manager == null || manager.getTimer() == null) { reportLearningFailure(); @@ -161,11 +166,21 @@ public void learn(Player player) { try { manager.getTimer().execute(() -> { try { - AdvancedCoreUser user = userManager.getUser(uuid, name); - if (user == null) { reportLearningFailure(); return; } - // This is identity evidence on this UUID record, never a name/UUID remap. - user.getData().setString(CANONICAL_NAME_KEY, name); - user.setBedrockUser(true); + Runnable mutation = () -> { + AdvancedCoreUser user = userManager.getUser(uuid, name); + if (user == null) { reportLearningFailure(); return; } + // Evidence on this UUID record, never a name/UUID remap. + user.getData().setString(CANONICAL_NAME_KEY, name); + user.setBedrockUser(true); + }; + // Shared SQL queues its notifications for later, outside this inline scope. + userManager.withUserDataChangeDispatcher(notification -> { + try { + plugin.getBukkitScheduler().runTask(plugin, notification, player); + } catch (RuntimeException rejected) { + plugin.getLogger().warning("Unable to deliver observed Bedrock identity notification"); + } + }, mutation); } catch (RuntimeException failure) { reportLearningFailure(); } @@ -455,6 +470,7 @@ public String getPrefixedIfBedrock(String name) { * Clear the cache and case-insensitive index. */ public void clearCache() { + observedBedrockNames.clear(); cache.clear(); ciIndex.clear(); canonicalNames.clear(); @@ -468,6 +484,9 @@ private void putLearned(String originalCaseName, boolean isBedrock) { } private Boolean getCachedCaseInsensitive(String name) { + // Player observations outrank a pending stored flag. Persisted canonical + // metadata alone is not a new client observation and cannot force true. + if (observedBedrockNames.contains(name.toLowerCase(Locale.ROOT))) return true; Boolean exact = cache.get(name); if (exact != null) return exact; diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/UserManager.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/UserManager.java index 95ed59fb8..a554ddfe4 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/UserManager.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/UserManager.java @@ -41,7 +41,8 @@ public class UserManager { private final AdvancedCorePlugin plugin; @Getter - private final ArrayList userDataChange = new ArrayList<>(); + private final ArrayList userDataChange = new ArrayList<>(); + private final ThreadLocal> userDataChangeDispatcher = new ThreadLocal<>(); @Getter private UserValidationService validationService; @@ -581,12 +582,37 @@ public void load() { validationService = UserValidationFactory.create(plugin); } - public void onChange(AdvancedCoreUser user, String... keys) { - for (UserDataChanged change : userDataChange) { - change.onChange(user, keys); - } - } - + /** + * Scope inline user-data notifications to an integration-owned dispatcher while + * the mutation itself stays on its caller. Other threads and deferred shared-SQL + * notifications retain their existing lanes. Nested scopes restore their owner. + */ + public void withUserDataChangeDispatcher(Consumer dispatcher, Runnable mutation) { + java.util.Objects.requireNonNull(dispatcher, "dispatcher"); + java.util.Objects.requireNonNull(mutation, "mutation"); + Consumer previous = userDataChangeDispatcher.get(); + userDataChangeDispatcher.set(dispatcher); + try { mutation.run(); } + finally { + if (previous == null) userDataChangeDispatcher.remove(); + else userDataChangeDispatcher.set(previous); + } + } + + public void onChange(AdvancedCoreUser user, String... keys) { + Consumer dispatcher = userDataChangeDispatcher.get(); + if (dispatcher == null) { + notifyUserDataChange(user, keys); + } else { + String[] snapshot = keys == null ? null : keys.clone(); + dispatcher.accept(() -> notifyUserDataChange(user, snapshot)); + } + } + + private void notifyUserDataChange(AdvancedCoreUser user, String... keys) { + for (UserDataChanged change : userDataChange) change.onChange(user, keys); + } + public void purgeOldPlayersNow() { if (plugin.getOptions().isPurgeOldData()) { HashMap> cols = getAllKeys(); diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java index 7fb0e5185..a60b14f55 100644 --- a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockCanonicalIdentityTest.java @@ -21,6 +21,8 @@ import com.bencodez.advancedcore.api.bedrock.BedrockNameResolver; import com.bencodez.advancedcore.api.user.*; import com.bencodez.advancedcore.api.user.usercache.UserDataManager; +import com.bencodez.advancedcore.api.user.usercache.UserDataCache; +import com.bencodez.simpleapi.scheduler.BukkitScheduler; /** Exercises the real detector with the optional Floodgate reflection contract, without a server. */ class BedrockCanonicalIdentityTest { @@ -39,6 +41,8 @@ class BedrockCanonicalIdentityTest { when(plugin.getOptions().getBedrockPlayerPrefix()).thenReturn("."); when(plugin.getLogger()).thenReturn(mock(Logger.class)); when(users.getDataManager()).thenReturn(manager); + doAnswer(call -> { call.getArgument(1, Runnable.class).run(); return null; }) + .when(users).withUserDataChangeDispatcher(any(), any()); when(manager.getTimer()).thenReturn(worker); doAnswer(call -> { pending.add(call.getArgument(0)); return null; }).when(worker).execute(any(Runnable.class)); when(users.getUser(any(UUID.class), anyString())).thenAnswer(call -> records.get(call.getArgument(0))); @@ -257,6 +261,123 @@ class BedrockCanonicalIdentityTest { verify(plugin.getLogger()).warning("Unable to read observed Bedrock identity; retaining legacy resolution"); } + @Test void persistedCanonicalMetadataAloneCannotForceAnUpdatedStoredFlagToTrue() { + Player linked = player("StoredFlagControl", true); + AdvancedCoreUser record = record(linked); + record.getData().setString("BedrockCanonicalName", "StoredFlagControl"); + record.setBedrockUser(true); + resolver.learn(record); // No Player learning in this resolver. + record.setBedrockUser(false); + resolver.learn(record); + assertFalse(resolver.isBedrockName("StoredFlagControl")); + assertEquals("StoredFlagControl", resolver.resolve("StoredFlagControl").finalName); + } + + @Test void sharedStorageRetainsItsExistingNotificationLane() throws Exception { + assertNotificationDelivery(false, true); + } + + @Test void pendingStoredFalseCannotDowngradeObservedClientBeforeOrAfterWorkerCompletion() { + Player linked = player("PendingJava", true); + AdvancedCoreUser record = record(linked); + resolver.learn(linked); + assertFalse(record.isBedrockUser(), "persistence is deliberately blocked"); + resolver.learn(record); + online(); + assertTrue(resolver.isBedrockName("PendingJava")); + assertTrue(resolver.isBedrockName("pendingjava")); + drain(); + assertTrue(record.isBedrockUser()); + assertTrue(resolver.isBedrockName("PendingJava")); + assertEquals("PendingJava", resolver.resolve("PendingJava").finalName); + } + + @Test void legacyInlineNotificationsReturnToPlatformOwnerWhileStorageStaysOnWorker() throws Exception { + assertNotificationDelivery(false, false); + } + + @Test void rejectedOwnerNotificationDoesNotRunOnStorageWorkerOrPreventTheMutation() throws Exception { + assertNotificationDelivery(true, false); + } + + private void assertNotificationDelivery(boolean rejectNotification, boolean shared) throws Exception { + Player linked = player("NotificationJava", true); + UUID id = linked.getUniqueId(); + // The actual callback entry point is used, not a mocked notification implementation. + UserManager callbackUsers = spy(new UserManager(plugin)); + callbackUsers.getDataManager().getTimer().shutdownNow(); + doReturn(manager).when(callbackUsers).getDataManager(); + when(plugin.getUserManager()).thenReturn(callbackUsers); + when(plugin.getStorageType()).thenReturn(UserStorage.SQLITE); + when(manager.effectiveStorageType(UserStorage.SQLITE)).thenReturn(UserStorage.SQLITE); + AdvancedCoreUser record = mock(AdvancedCoreUser.class); + when(record.getPlugin()).thenReturn(plugin); + when(record.getUUID()).thenReturn(id.toString()); + when(record.getPlayerName()).thenReturn("NotificationJava"); + when(record.isCached()).thenReturn(true); + UserDataCache cache = mock(UserDataCache.class); + when(record.getCache()).thenReturn(cache); + UserData data = new UserData(record); + when(record.getData()).thenReturn(data); + doCallRealMethod().when(record).setBedrockUser(true); + if (shared) { + when(manager.hasSharedSqlBackend()).thenReturn(true); + when(manager.usesSharedSqlStorage(UserStorage.SQLITE)).thenReturn(true); + doAnswer(call -> { call.getArgument(2, Runnable.class).run(); return null; }) + .when(manager).withSharedSqlStorage(eq(id), eq(UserStorage.SQLITE), any(Runnable.class)); + when(manager.captureSharedUserDataNotification(any(Runnable.class))) + .thenAnswer(call -> call.getArgument(0)); + doAnswer(call -> { pending.add(call.getArgument(0)); return null; }) + .when(manager).dispatchSharedUserDataNotification(any(Runnable.class)); + } + doReturn(record).when(callbackUsers).getUser(id, "NotificationJava"); + Map callbackThreads = new ConcurrentHashMap<>(); + callbackUsers.getUserDataChange().add(new UserDataChanged() { + @Override public void onChange(AdvancedCoreUser ignored, String... keys) { + for (String key : keys) callbackThreads.put(key, Thread.currentThread()); + } + }); + ArrayDeque platformTasks = new ArrayDeque<>(); + BukkitScheduler scheduler = mock(BukkitScheduler.class); + when(plugin.getBukkitScheduler()).thenReturn(scheduler); + doAnswer(call -> { + if (rejectNotification) throw new RejectedExecutionException("synthetic owner stopped"); + platformTasks.add(call.getArgument(1)); return null; + }).when(scheduler).runTask(eq(plugin), any(Runnable.class), eq(linked)); + resolver = newResolver(); + Thread platformThread = Thread.currentThread(); + AtomicReference storageThread = new AtomicReference<>(); + doAnswer(call -> { + assertNotSame(platformThread, Thread.currentThread(), "storage ran on platform owner"); + storageThread.set(Thread.currentThread()); + return null; + }).when(cache).addChange(any(), eq(true)); + resolver.learn(linked); + assertTrue(callbackThreads.isEmpty()); + Thread storage = new Thread(() -> { + drain(); + callbackUsers.onChange(record, "unrelated"); // dispatch scope must not leak + }, "synthetic-storage-worker"); + storage.start(); storage.join(5000); + assertFalse(storage.isAlive()); + while (!platformTasks.isEmpty()) platformTasks.remove().run(); + assertNotNull(storageThread.get()); + if (rejectNotification) { + assertNull(callbackThreads.get("isBedrock")); + assertNull(callbackThreads.get("BedrockCanonicalName")); + verify(plugin.getLogger(), times(2)) + .warning("Unable to deliver observed Bedrock identity notification"); + } else { + Thread expected = shared ? storageThread.get() : platformThread; + assertSame(expected, callbackThreads.get("isBedrock")); + assertSame(expected, callbackThreads.get("BedrockCanonicalName")); + if (shared) assertTrue(platformTasks.isEmpty()); + } + verify(record).setBedrockUser(true); + verify(cache, times(2)).addChange(any(), eq(true)); + assertSame(storageThread.get(), callbackThreads.get("unrelated")); + } + private void online(Player... players) { bukkit.when(Bukkit::getOnlinePlayers).thenReturn(List.of(players)); } private void drain() { while (!pending.isEmpty()) pending.remove().run(); } private Player player(String name, boolean linked) { @@ -280,7 +401,8 @@ private AdvancedCoreUser record(Player player) { when(data.getString(anyString(), eq(UserDataFetchMode.DEFAULT))).thenAnswer(call -> stored.get(call.getArgument(0))); doAnswer(call -> { stored.put(call.getArgument(0), call.getArgument(1)); return null; }) .when(data).setString(anyString(), anyString()); - doAnswer(call -> { stored.put("isBedrock", "true"); return null; }).when(user).setBedrockUser(true); + doAnswer(call -> { stored.put("isBedrock", String.valueOf(call.getArgument(0, Boolean.class))); return null; }) + .when(user).setBedrockUser(anyBoolean()); records.put(observedId, user); return user; } diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java index 5b946336b..2813c6bb0 100644 --- a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/BedrockNameResolverTest.java @@ -580,6 +580,8 @@ public void testLearn_playerBedrock_updatesCacheAndSetsUserFlag() throws Excepti java.util.concurrent.ScheduledExecutorService worker = mock(java.util.concurrent.ScheduledExecutorService.class); when(userManager.getDataManager()).thenReturn(manager); when(manager.getTimer()).thenReturn(worker); + doAnswer(call -> { call.getArgument(1, Runnable.class).run(); return null; }) + .when(userManager).withUserDataChangeDispatcher(any(), any()); doAnswer(call -> { call.getArgument(0, Runnable.class).run(); return null; }) .when(worker).execute(any(Runnable.class)); diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/user/UserDataNotificationDispatcherTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/user/UserDataNotificationDispatcherTest.java new file mode 100644 index 000000000..d7ef79951 --- /dev/null +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/user/UserDataNotificationDispatcherTest.java @@ -0,0 +1,70 @@ +package com.bencodez.advancedcore.tests.user; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +import org.junit.jupiter.api.*; +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.user.*; + +class UserDataNotificationDispatcherTest { + private UserManager users; + private final AdvancedCoreUser user = mock(AdvancedCoreUser.class); + private final Map deliveries = new ConcurrentHashMap<>(); + + @BeforeEach void setup() { + users = new UserManager(mock(AdvancedCorePlugin.class, RETURNS_DEEP_STUBS)); + users.getDataManager().getTimer().shutdownNow(); + users.getUserDataChange().add(new UserDataChanged() { + @Override public void onChange(AdvancedCoreUser ignored, String... keys) { + for (String key : keys) deliveries.put(key, Thread.currentThread()); + } + }); + } + + @Test void nestedFailureRestoresOuterDispatcherAndDefaultInlineContract() { + List outer = new ArrayList<>(); + List inner = new ArrayList<>(); + users.withUserDataChangeDispatcher(outer::add, () -> { + users.onChange(user, "outer-before"); + assertThrows(IllegalStateException.class, () -> + users.withUserDataChangeDispatcher(inner::add, () -> { + users.onChange(user, "inner"); + throw new IllegalStateException("synthetic failure"); + })); + users.onChange(user, "outer-after"); + }); + assertTrue(deliveries.isEmpty()); + users.onChange(user, "outside"); + assertEquals(Set.of("outside"), deliveries.keySet()); + assertEquals(2, outer.size()); + assertEquals(1, inner.size()); + inner.forEach(Runnable::run); + outer.forEach(Runnable::run); + assertEquals(Set.of("outer-before", "outer-after", "inner", "outside"), deliveries.keySet()); + } + + @Test void dispatchScopeIsThreadLocalAndSnapshotsTheKeyArray() throws Exception { + List ownerQueue = new ArrayList<>(); + Thread caller = Thread.currentThread(); + users.withUserDataChangeDispatcher(ownerQueue::add, () -> { + String[] keys = {"original"}; + users.onChange(user, keys); + keys[0] = "mutated"; + Thread other = new Thread(() -> users.onChange(user, "other"), "synthetic-unrelated-worker"); + other.start(); + try { other.join(5000); } + catch (InterruptedException interrupted) { throw new AssertionError(interrupted); } + assertFalse(other.isAlive()); + assertNotNull(deliveries.get("other")); + assertNotSame(caller, deliveries.get("other")); + }); + assertEquals(1, ownerQueue.size()); + ownerQueue.get(0).run(); + assertSame(caller, deliveries.get("original")); + assertFalse(deliveries.containsKey("mutated")); + } +}