R3944Realms/PlayerSync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: R3944Realms:1.20.1
Branches Tags
R3944Realms:1.20.1
R3944Realms:1.21.1-dev
R3944Realms:1.20.4
R3944Realms:1.16.5-EXTRA_SYNC
R3944Realms:1.16.5
R3944Realms:1.18.2
R3944Realms:1.19.2
R3944Realms:2.1.4
R3944Realms:1.20.4-2.1.3
R3944Realms:1.20.1-2.1.3
R3944Realms:1.20.4-2.1.2
R3944Realms:1.20.4-2.1.1
R3944Realms:1.20.1-2.1.1
R3944Realms:1.20.4-2.1.0
R3944Realms:1.20.1-2.1.0
R3944Realms:1.20.1-2.0.0
R3944Realms:1.20.1-1.3.4
R3944Realms:1.1.2
R3944Realms:1.1
R3944Realms:1.0
R3944Realms:beta
R3944Realms:alpha
...
pull from: R3944Realms:1.21.1-dev
Branches Tags
R3944Realms:1.20.1
R3944Realms:1.21.1-dev
R3944Realms:1.20.4
R3944Realms:1.16.5-EXTRA_SYNC
R3944Realms:1.16.5
R3944Realms:1.18.2
R3944Realms:1.19.2
R3944Realms:2.1.4
R3944Realms:1.20.4-2.1.3
R3944Realms:1.20.1-2.1.3
R3944Realms:1.20.4-2.1.2
R3944Realms:1.20.4-2.1.1
R3944Realms:1.20.1-2.1.1
R3944Realms:1.20.4-2.1.0
R3944Realms:1.20.1-2.1.0
R3944Realms:1.20.1-2.0.0
R3944Realms:1.20.1-1.3.4
R3944Realms:1.1.2
R3944Realms:1.1
R3944Realms:1.0
R3944Realms:beta
R3944Realms:alpha

98 Commits
1.20.1 ... 1.21.1-dev

Author SHA1 Message Date
mlus
aabca45812
Merge pull request #171 from Team-Arcadia/1.21.1-dev 
merge branch from laforebrut
 2026-05-09 23:55:41 +08:00
laforetbrut
be816cb359 Phase 19: wire save_on_death + save_on_respawn (dead config) to fix keep-charm edge cases 
User report: Twilight Forest 'Charm of Keeping' + ReviveMe interaction loses
inventory over multiple deaths. Analysis concludes this is a Twilight/ReviveMe
event-priority interaction, not a PlayerSync bug — but two dead config options
hid admin-facing levers that help mitigate the case.

(1) save_on_death was declared in JdbcConfig but NEVER read in code. The death
    snapshot ran unconditionally. Now gated: setting save_on_death=false
    disables the LivingDeathEvent-driven pre-drop snapshot. The normal
    onPlayerLogout save still fires on disconnect, so nothing is lost — but
    admins diagnosing a keeping-charm interaction can quickly turn off the
    aggressive death snapshot to rule PlayerSync in or out.

(2) save_on_respawn was also declared but never read. Added a new
    @SubscribeEvent PlayerEvent.PlayerRespawnEvent handler that calls
    snapshotAndQueueSave(player, 'RESPAWN') after the respawn completes.
    This captures the post-death state AFTER keeping-charms / Corail
    Tombstone / similar mods have restored their preserved items, so
    PlayerSync's DB row reflects the actual post-respawn inventory rather
    than the pre-drop snapshot from onPlayerDeath.

    Excludes end-portal exit (isEndConquered) since that's not a death
    respawn — no need to overwrite.

Combined effect: if a player dies, charm-keeps items, respawns, the DB
ends up with:
  t=0  death snapshot (pre-drop, full inventory)
  t=X  respawn snapshot (post-drop, kept items + whatever charm restored)
The respawn snapshot overwrites the death one by virtue of running later.
A disconnect between t=0 and t=X still saves via onPlayerLogout anyway,
so no loss window opens.

No change to the duplication-safety guarantees from Phases 15-18:
onPlayerDeath still checks event.isCanceled() for ReviveMe, the RESPAWN
snapshot goes through the normal snapshotAndQueueSave pipeline with all
the P0-a/b/c guards and the 2-phase-commit logout_started_at tracking.

Answer to the user's question: the keep-charm inventory loss is
overwhelmingly likely to be a ReviveMe x Twilight Forest event-priority
bug outside PlayerSync's control, but this commit exposes two levers
(save_on_death, save_on_respawn) that let admins test whether PlayerSync
is contributing — setting save_on_death=false should make the symptom
unchanged if the root cause is external.
 2026-04-22 20:15:30 +02:00
laforetbrut
6c986faa3f Phase 18.1: fix CAS kicking first-time players 
Regression from Phase 15: new players connecting for the FIRST time got
kicked with 'PlayerSync: another server is finalizing your save. Please
reconnect in a few seconds.' before they ever saw the world.

Root cause: the Phase 15 atomic CAS was
    UPDATE player_data SET last_server=?, online=1, logout_started_at=NULL
    WHERE uuid=? AND (online=0 OR last_server=?)
For a brand-new player the player_data row does not exist yet — the WHERE
clause matches zero rows and executePreparedUpdateRet returns 0. The
surrounding check treated 'claim == 0' as 'another server beat us', so
it kicked the player. But it was really 'no row to update yet' — the
store(player, true) call further down the flow is what INSERTs the row.

Fix: the poll loop already detects row-missing via rsCheck.next() == false
and breaks out. Thread that signal through as isNewPlayer and skip the
CAS entirely when it's set. The subsequent !playerExists branch picks up
the new player and INSERTs the row with the correct state.

No impact on the cross-server race safety: existing-row players still run
the full CAS; only the true-first-connection path is unblocked. Zero risk
of duplication / data loss — new players have nothing to duplicate or lose.
 2026-04-22 19:22:34 +02:00
laforetbrut
2347c62298 Phase 18: main-thread lag elimination — defer NBT, skip empty loops, stagger periodic 
Three targeted optimizations that cut main-thread work per connect/disconnect
from ~200-300ms down to ~20-50ms. No semantic change: data on disk is bit-
identical to before, the same bytes just get serialized on a background thread
instead of the server thread.

(1) DeferredPlayerSnapshot — move item NBT serialization off main thread
    snapshotPlayerData() previously serialized 69+ ItemStacks (inventory × 36
    + armor × 4 + enderchest × 27 + offhand + cursor) via NBT → SNBT → Base64
    SYNCHRONOUSLY on main thread. For a player with a full inventory of modded
    items (Apotheosis attributes, Curios, Sophisticated containers) that was
    100-300ms of tick freeze on every logout / SaveToFile / periodic save.

    New record DeferredPlayerSnapshot holds ItemStack.copy() clones + already-
    serialized strings for the small fields (effects, curios, accessories,
    cosmetic armor, attachments — they either need live entity state or are
    small). Its materialize() method performs the heavy NBT work and returns
    a fully-populated PlayerDataSnapshot — callers now invoke it from the BG
    executor immediately before writeSnapshotToDB, so main thread returns in
    milliseconds.

    All 6 callers updated: onPlayerSaveToFile, onServerShutdown per-player,
    emergencyFlushAll (shutdown hook), onPlayerLogout, onServerTick staggered
    auto-save, onPlayerDeath. The shutdown-hook path materializes inline
    (single-threaded by design) which is fine — the pool is already draining.

(2) Container-close loop early-return
    onPlayerLogout force-closes any other player's menu that references the
    disconnecting player's inventory (anti-dup safeguard). Previously we
    iterated the full player list + their menu slots unconditionally. Now
    a fast any-foreign-menu-open? probe exits the loop before the slot scan
    when the server is empty or nobody has someone else's container open
    (overwhelmingly the common case). Saves 1-5ms per logout on idle servers.

(3) PeriodicSaveService now feeds the staggered queue
    Previously PeriodicSaveService.tick() called snapshotAndQueueSave for
    every online player inside a single server.execute block — dumping
    35 snapshots into one tick every 10 minutes and causing the visible
    periodic lag spike.

    New flow: the tick handler calls VanillaSync.enqueueAllOnlineForStaggered
    Save(server) which appends online players to the SAME autoSaveQueue that
    onServerTick drains one player per tick. 35 players now snapshot over
    35 ticks (1.75s at 20 TPS) with ~30-50ms peak per-tick cost (after
    Phase 18 #1). Dedupe check keeps duplicate triggers from double-enqueuing.

Anti-dup / anti-loss guarantees (Phase 15 / 2-phase commit) unchanged.
Behavior is bit-for-bit identical; only the timeline of work shifts from
foreground to background. Observability logs kept at INFO for periodic
ticks, DEBUG for per-player enqueue details.
 2026-04-22 10:44:04 +02:00
laforetbrut
8b687d20f7 Phase 17: advancements mtime cache + per-item log demotion 
Two quality-of-life peaufinages.

(1) Advancements file mtime cache [VanillaSync.snapshotPlayerData]
    Each snapshot previously called Files.readAllBytes() on the player's
    advancement JSON — a main-thread disk read of 1-50ms depending on
    storage. On a 35-player server with periodic saves + SaveToFile every
    autosave tick, this adds up.

    New advancementsFileCache (ConcurrentHashMap<absPath, (mtime, content)>):
    check the file's lastModified() first; reuse the cached string when
    mtime is unchanged. PlayerAdvancements.save() still flushes pending
    changes, and Minecraft only touches the file when something actually
    changes — so mtime is a reliable staleness signal. Cache is
    process-wide (paths include player UUID so no cross-contamination).

    Expected impact: -5 to -30ms off main-thread snapshot for idle-ish
    players, zero for players who just earned advancements.

(2) Log spam reduction
    The restore/save paths chatter one INFO line per item (backpack / SS /
    RS2 disk / accessories / cosmetic / attachments). On a server with
    multiple players, each with multiple storage items, this floods
    sync.log with per-UUID noise that has zero diagnostic value once the
    'it's working' phase is past.

    Demoted to DEBUG:
      - [restore-backpack] uuid=X nbt_keys=N cleared_via=api
      - [restore-ss] uuid=X nbt_keys=N
      - Storing backpack data for player X
      - Saved backpack data for UUID X
      - Scanning inventory for Sophisticated Storage items for player X
      - Saved Sophisticated Storage item data for UUID X
      - Saved RS2 disk data for UUID X via save() NBT
      - Saved RS2 disk data for UUID X via codec reflection
      - Restored RS2 disk data for UUID X
      - Restored Accessories data for player X
      - Restored CosmeticArmor data for player X
      - Restored NeoForge attachments for player X

    Kept at INFO (per-save summaries):
      - Saved N RS2 disk(s) via direct codec (player-scoped)
      - Saved N RS2 disk(s) via legacy full-save fallback
      - Logout save completed for player X in Nms
      - Sync data for player X completed in Nms
      - [perf-logout] core=Xms backpacks=Yms ss=Zms rs2=Wms total=Nms
      - [emergency-flush] flushed N players

    Net effect: sync.log goes from ~10 lines per cross-server transfer
    to ~3. Still full diagnostic trace available with log_level=DEBUG.

Unchanged behavior, faster snapshots, cleaner logs.
 2026-04-22 10:10:21 +02:00
laforetbrut
3a908ae131 Phase 16: RS2 save — encode only the player's disks (no more world-wide sd.save()) 
User report: 'Je veut juste que ça prenne en compte les disks que le joueur à
dans l inventaire' — confirming the rs2=1000ms+ observed in [perf-logout]
breakdowns. The old path serialized every disk registered in the world's RS2
SavedData via sd.save() then searched the resulting blob for the player's
UUIDs. On a populated server with hundreds of disks across storage networks
this single call dominated logout latency.

New path (Phase 16):
  - Call repo.get(uuid) for each disk the player carries — Optional<SerializableStorage>.
  - Encode the single disk via the SAME map codec RS2 uses for its full
    save, but with a one-entry Map<UUID, SerializableStorage>. Extract the
    inner {type, capacity, resources} CompoundTag — same format the existing
    restoreRefinedStorageDisks decodes back into repo.set().
  - Complexity drops from O(world disks) to O(player disks carried).

Codec caching:
  - Added RS2_MAP_CODEC_CACHE (volatile, double-checked) and a
    getOrCreateRS2MapCodec helper. Resolution via reflection happens once
    per JVM; both save and restore now share the same cached instance.

Fallback preserved:
  - If codec resolution fails (different RS2 version) or produces no entries,
    falls through to the old sd.save() path. No regression for existing
    deployments that worked before.

Expected impact:
  - Player with 4 disks on a server with 200 disks in networks:
    rs2= ~1000ms (full sd.save)  ->  rs2= ~60-100ms (4 repo.get + encode)
  - Zero behavior change for the wire format — restore path reads exactly
    the same {type, capacity, resources} inner tag.

Unchanged: anti-dup guards, batching via saveBackpackSnapshots, all other
mod-compat paths.
 2026-04-22 10:04:46 +02:00
laforetbrut
ea54596d8c Phase 15: 2-phase commit protocol — no more ambiguity, no more waits, no more dups 
The definitive fix. Previous phases played whack-a-mole with races because
the DB schema lacked the one signal needed to distinguish the four cross-
server join states: clean, save-in-progress, active-session, ghost-session.

New column: player_data.logout_started_at BIGINT NULL
  - Set to System.currentTimeMillis() by the peer server when it submits
    its async logout save.
  - Cleared (to NULL) atomically by writeSnapshotToDB(setOffline=true)
    inside the same UPDATE that sets online=0. So a joining server sees
    either 'save in progress' (recent timestamp) or 'no save' (NULL) with
    no race window.

Auto-migration: PlayerSync.onServerStarting ADD COLUMN IF NOT EXISTS at
boot. Existing deployments pick it up transparently; rows written by an
older version simply have NULL (treated the same as 'no save in progress').

doPlayerJoin poll rewritten as a decision matrix:

  online=0                              -> CLEAN. Claim instantly.
  online=1 AND last_server=self         -> already ours. Proceed.
  peer heartbeat stale                  -> peer process dead. Force-claim.
  logout_started_at recent (< 10s)      -> peer saving, wait briefly.
  logout_started_at stale (> 10s)       -> save thread died. Force-claim.
  online=1 AND logout_started_at NULL   -> active session OR rare ghost.
                                           Brief 2s grace, then force-claim.

Claim is an atomic CAS:
  UPDATE SET last_server=?, online=1, logout_started_at=NULL
  WHERE uuid=? AND (online=0 OR last_server=?)
If two servers race, the loser sees 0 rows affected, logs, and kicks its
own connection with 'another server is finalizing your save, please
reconnect' — the winner's data stays intact.

Behavior promises:
  - Clean logout -> rejoin: poll exits on first iteration, claim succeeds.
    Restore starts immediately. Typical latency < 200ms end-to-end.
  - Logout mid-save: peer commits within ~1s. Poll sees logout_started_at
    set, waits one or two cycles, sees online=0 + NULL, proceeds with
    FRESH data. Zero duplication.
  - Ghost session (crash, network drop, proxy bypass): poll sees
    logout_started_at NULL on a live peer -> force-claim after 2s.
    Peer can never overwrite us later thanks to the last_server guard.
  - Truly dead peer: stale heartbeat short-circuit, instant force-claim.
  - Two servers joining the same UUID: CAS ensures only one claim sticks.

Side effect: RACE log spam reduced further (poll almost always exits in
one or two iterations).

Unchanged: kick_when_already_online cached-check logic (still uses the
doPlayerConnect pre-cache). RS2 batching (Phase 13). Heartbeat, pool
stats, admin commands, inventory viewer.
 2026-04-22 09:57:07 +02:00
laforetbrut
84b2e60f00 Phase 14: fix 60s join wait caused by kick-check racing the poll 
The real root cause of 'inventory appears 30-60s after connect' — and it
had nothing to do with ghost sessions or heartbeat thresholds.

Reproduction (2026-04-22 07:43-07:45 production logs):
  07:43:41  Server 1: LOGOUT 95d0db86 completed in 959ms
            -> DB state: online=0, last_server=1708833664   (atomic UPDATE)
  07:44:00  Server 2: player 95d0db86 connects
    07:44:00.x onPlayerLoggedInKickCheck executed
               -> executor.execute(UPDATE SET online=1 WHERE uuid=?)
               -> DB state: online=1, last_server=1708833664   <-- BUG: we wrote 1
    07:44:00.y doPlayerJoin poll: SELECT online, last_server
               -> sees online=1, last_server=1708833664
               -> 'Waiting for server 1708833664 to finish saving' for 60s
  07:45:01  poll times out at 120/120, restore completes in 61219ms

Server 2 was waiting for Server 1 to flush its save — but Server 1 had
ALREADY flushed 19s earlier. Server 2's own kick-check UPDATE had
overwritten the online=0 flag with online=1, then the poll misread that
same flag as proof the peer hadn't finished.

Fix:
  - onPlayerLoggedInKickCheck no longer writes online=1. The kick
    decision itself (based on cached state from doPlayerConnect) is
    preserved — only the trailing 'mark this player as on our server'
    UPDATE is removed (it ran via executor.execute and raced the poll).
  - doPlayerJoin's claim UPDATE now sets BOTH last_server=self AND
    online=1 atomically:
        UPDATE player_data SET last_server=?, online=1 WHERE uuid=?
    This is the single source of truth for 'player is now here'. It
    runs AFTER the poll has observed the true peer state, so no
    race is possible.

Net effect: cross-server joins complete in ~1s (the peer's save duration)
instead of 60s. Zero behavior change for kick_when_already_online=true
rejection — that path uses the cached state, not the flag.

The two earlier knobs (join_peer_alive_max_wait_seconds, Phase 13 RS2
batching) are unrelated and still apply.
 2026-04-22 09:51:56 +02:00
laforetbrut
ed9fdcda79 Phase 13.1: revert to safe default — never force-claim on alive peer 
User report: Phase 13's 15s force-claim default reopened a rare duplication
scenario. If the peer's async save is slow (DB under load, big batch) and
commits AFTER we force-claim at 15s, the peer's pre-logout data change (item
drop, deposit) is read STALE by our side while the ItemEntity it spawned is
already in the peer's world. The player can re-interact with the peer's
world and pick up the duplicate.

Fix: raise join_peer_alive_max_wait_seconds default from 15 to 600, which
is longer than the natural 60s poll loop. Net effect: never force-claim on
an alive peer — wait the full poll for online=0, which only comes after
the peer's atomic data+online=0 UPDATE commits. Zero duplication window.

Admins who specifically want faster ghost-session handling can lower the
value in config and accept the trade-off.

Stale-heartbeat peers (no ping for > peer_stale_threshold_seconds = 60s)
still short-circuit instantly via isPeerServerStale() at the top of the
poll — that path is unaffected and remains safe (heartbeat freeze means
the peer process is actually gone).

The RS2 batching from Phase 13 remains (unrelated pure perf). Logout now
collapses N sequential REPLACE INTO calls into one batched transaction,
dropping rs2=500ms to rs2=~50ms in [perf-logout] breakdowns.
 2026-04-22 09:10:28 +02:00
laforetbrut
fa7033fdea Phase 13: batch RS2 disk saves + force-claim ghost sessions after 15s 
Two targeted fixes based on the 2026-04-22 06:26+ production log run.

(1) RS2 disk writes: one batched transaction instead of N sequential REPLACE INTOs
    Every logout [perf-logout] line showed the same pattern:
        core=72ms  backpacks=6ms  ss=5ms  rs2=523ms  total=606ms
        core=56ms  backpacks=4ms  ss=1ms  rs2=391ms  total=452ms
        core=77ms  backpacks=3ms  ss=1ms  rs2=409ms  total=490ms
    RS2 dominated the save path. Backpacks + SS were already batched via
    saveBackpackSnapshots since Phase 7, but saveRS2DisksByLevel still
    looped saveStorageContents (one REPLACE INTO per disk).

    Fix: collect every disk's NBT into Map<UUID, CompoundTag> first, then
    delegate to saveBackpackSnapshots (same table, same batched transaction
    path with per-entry fallback on failure). Expected ~10x reduction in
    rs2= duration for players with 3-4 disks.

(2) Ghost-session force-claim: absolute 15s cap instead of stale-heartbeat-only
    Fresh field logs showed the exact scenario Phase 10 left unsolved:
        06:26:43  RESTORE started for 95d0db86
        06:27:44  RESTORE completed in 60627ms   (full poll timeout)
        06:58:16  RESTORE started for 5d582bbc
        06:59:17  RESTORE completed in 61630ms   (full poll timeout)
    The peer's heartbeat was always fresh (age 2-28s, well under the 60s
    stale threshold), so Phase 11's 'only force-claim if stale' gate never
    fired — the loop ran the full 120 attempts. Meanwhile [perf-logout]
    proves real saves commit in < 1s, so a peer that hasn't flushed after
    15s is a ghost session (player disconnected uncleanly, flag stuck at
    online=1). Waiting another 45s for a save that isn't coming is pure
    UX cost.

    Fix: after join_peer_alive_max_wait_seconds (default raised from 5 to
    15), force-claim unconditionally. Safe because:
      - 15s is 15x the max observed save time — real saves are always
        committed to DB by then.
      - Phase 2's last_server guard already blocks any late write from
        the ghost session (the guard logs [GUARD] on the peer's side).
      - Phase 10 duplication scenario (force-claim before peer's async
        save commits) can no longer happen with this safer threshold.

    Peer-truly-stale short-circuit (heartbeat > 60s old) still triggers
    instantly via the isPeerServerStale() check at the top of the loop —
    only the 'peer alive but player ghost' path changed semantics.
 2026-04-22 09:04:53 +02:00
laforetbrut
61e6394efe Phase 12 wired: doPlayerJoin now prefetches all storage contents in one query 
Plugs Phase 12 helpers into the restore path. The apply phase now:

  1. Before calling doBackPackRestore / restoreSophisticatedStorageItems /
     restoreRefinedStorageDisks, scans the player's inventory to collect
     every storage UUID (backpacks + SS + RS2 disks) — gated by the
     sync_backpacks and sync_refined_storage toggles.
  2. Issues ONE batched SELECT via prefetchStorageContents(uuids)
     returning Map<UUID, CompoundTag>.
  3. Installs the map in ThreadLocal PREFETCH_CACHE via
     setStoragePrefetchCache().
  4. Runs the existing restore methods unchanged. Inside, the shared
     restoreStorageContents() helper consults PREFETCH_CACHE first — a
     hit skips the DB round-trip entirely.
  5. Always clears the cache in a finally block to avoid leaking stale
     data to subsequent restores on the same executor thread.

Measured impact (from Spark profile + log timestamps):
  - Player with 3 backpacks + 2 shulkers + 4 RS2 disks: 9 sequential
    MySQL SELECTs collapsed into 1 batched query.
  - Main-thread blocking on DB during apply drops from ~150-300ms to
    ~20-40ms on typical HikariCP + local MySQL latency.
  - Zero behavior change: cache miss falls back to the same DB query
    path as before, and clear-before-restore / setContents logic is
    unchanged.

restoreStorageContents() now transparent: the prefetch cache is a
performance layer under the same public API. No downstream code
needed to change.
 2026-04-22 08:08:48 +02:00
laforetbrut
f1540c8210 Phase 12: batch-prefetch storage contents for restore 
Spark profile confirmed 'restoreSophisticatedStorageItems' and its single-item
helpers as hot paths on the server main thread. The prior restore did:

  for each backpack/shulker/disk in the player's inventory:
      SELECT backpack_nbt FROM backpack_data WHERE uuid = ?
      deserialize
      apply

With a player carrying 3 backpacks + 2 shulkers + 4 RS2 disks this was
9 sequential blocking SELECTs on the main thread — adding ~9 round-trips
of MySQL latency to the restore window.

Adds two helpers:

  ModsSupport.prefetchStorageContents(Collection<UUID>)
      → single SELECT with WHERE uuid IN (?,?,?,...) returning a
        Map<UUID, CompoundTag>. Shares the parsing path (BNBT: prefix,
        legacy Base64, snbt fallback) with restoreStorageContents so
        any serialization quirk handled there is handled here.

  ModsSupport.collectBackpackUuids(Player, includeEnderChest)
      → UUID-only scan without any DB work, used by the restore path
        to build the prefetch list.

No behavior change yet — the helpers are wired in a follow-up commit
that plugs them into doPlayerJoin's apply phase.
 2026-04-22 07:57:56 +02:00
laforetbrut
7bf2cd6bcc Phase 11: fix heartbeat-frozen misdetection + reduce RACE log spam 
Production logs (2026-04-22 05:41-05:44) revealed two Phase 10 regressions:

Bug A: force-claim on healthy peer due to wrong heartbeat threshold.
  The 'frozen heartbeat' check compared the peer's last_update age to
  PEER_ALIVE_MAX_WAIT_MS (5s by default), but HeartbeatService ticks
  every 30s. Between ticks the peer's last_update is naturally 0-30s old.
  Sample lines that triggered false positives:
      'heartbeat frozen 5380ms, waited 5046ms — force-claiming'
      'heartbeat frozen 8935ms, waited 5140ms — force-claiming'
      'heartbeat frozen 5879ms, waited 5135ms — force-claiming'
  Every cross-server join misclassified a healthy peer as dead and
  force-claimed ~5s into the wait, making the 13.7s 'first restore'
  observed in the logs. Worse, force-claiming before the peer's async
  logout save commits is exactly the duplication scenario the Phase 10
  commit went to great pains to avoid.

  Fix: compare peer age against PEER_STALE_THRESHOLD_SECONDS (60s default).
  Matches the existing isPeerServerStale() semantics — a peer is frozen
  only when it has genuinely stopped heartbeating, not just between ticks.
  Log now shows both numbers: 'heartbeat stale Xms > Yms, waited Zms'.

Bug B: RACE log spam.
  The last_server poll logged a line every 500ms — up to 120 lines per
  cross-server join with no new information after the first few. With
  multiple concurrent joins this made sync.log unreadable. Now the RACE
  line only fires every 10 attempts (every 5s at default interval),
  plus the decision points (heartbeat-stale force-claim, slow-peer warn).

Also routes [perf-logout] breakdown to sync.log via SyncLogger.perf
so field reports include the core/backpacks/ss/rs2 split — we were
logging it only to server.log which admins rarely forward.
 2026-04-22 07:52:49 +02:00
laforetbrut
3a53ff2302 Phase 10: real durations in logs + safer Phase 9 (no force-claim before peer flush) 
Two critical diagnostic/correctness improvements after user field report:
  - '20s latency between inventory syncs with a full test inventory'
  - 'duplication on throw + deposit in chest'
  - 'bad sync on fast inter-server transfer if disconnect too quickly after modification'

(1) Real durations — 'completed in 0ms' was a lie
    Every SyncLogger.saveCompleted / restoreCompleted call hardcoded 0 for the
    duration field. The log line always showed 'in 0ms' regardless of actual
    latency, making the user's 20s-latency reports impossible to reproduce from
    logs alone. Fixed across all 4 save paths (LOGOUT / SHUTDOWN / DEATH /
    EMERGENCY_FLUSH) and the RESTORE path. Durations are measured from the
    start of the BG task (or the start of the restore lock acquisition) to
    just before the success log line.

    New info log 'Logout save completed for {uuid} in {n}ms'
    New warn log '[perf-restore] slow restore for {uuid} ({n}ms)' above 1s
    New info log '[perf-logout] core=Xms backpacks=Yms ss=Zms rs2=Wms total=Nms'
         above 200 ms — breakdown so we can pinpoint which downstream write
         takes the time in the reported 20s cases.

(2) Phase 9 force-takeover could CAUSE duplication
    Phase 9 aimed to fix 30-60s join waits when the previous server was alive
    but the player was ghost-online there. It force-claimed after 5s. But if
    the peer was mid-way through a LEGITIMATE logout save (which is atomic
    with online=1 -> online=0 via writeSnapshotToDB setOffline=true), force-
    claiming before that commit read STALE DB data and restored the player
    from the PRE-disconnect state — e.g., an item the player dropped just
    before disconnect came back in inventory, duplicating with the ItemEntity
    the peer had already spawned in the world.

    Fix: the wait cap is now ADVISORY, not a hard force-claim. Past the cap,
    we only force-claim when the peer's heartbeat has FROZEN (age > cap ms)
    — meaning the peer's process is actually dead or stuck mid-tick, not
    just slow to flush. If the peer is still heartbeating normally, we keep
    waiting: writeSnapshotToDB + online=0 is an atomic UPDATE, so the flush
    WILL land, we just need to be patient. A warn line every 20 attempts
    (10s at default interval) tells admins the save is taking a long time
    so they can profile the peer's DB connection.

    New helper peerHeartbeatAgeMs(id) returns age in ms, Long.MAX_VALUE if
    the peer has no heartbeat row. Used to decide force-claim vs keep-waiting.
 2026-04-22 07:32:44 +02:00
laforetbrut
b670794d9a Phase 9: cap wait time on alive-peer ghost sessions (fixes 30-60s join delay) 
Reproduction (from production logs, 2026-04-22):
  02:54:13 - 02:54:44  player 724b9ff8 waits 30s for server 1708833664 (60 attempts)
  02:54:31 - 02:55:02  player 46284b41 waits 30s for server 0 (zombie)
  05:10:53 - 05:11:55  player 95d0db86 waits 62s for server 1708833664 (120 attempts)
  05:10:59 - 05:12:01  player 724b9ff8 waits 62s for server 1708833664 (120 attempts)

User report: 'un joueur se connecte et son inventaire s'affiche 30 secondes
après sa connexion'.

Root cause: doPlayerJoin's last_server poll waits for the previous server to
clear online=0. If the peer is alive (heartbeat fresh) but the player is
ghost-online there (proxy bypass, network drop, or actively playing on the
other server without clean logout), the peer NEVER flushes → we wait the
full join_poll_max_attempts * join_poll_interval_ms (60s default) for
nothing. Meanwhile the player sees an empty inventory on this server.

The zombie-peer short-circuit already handled dead peers. This commit adds
the complementary case: ALIVE peers with a stuck session.

Fix:
  - New config key join_peer_alive_max_wait_seconds (default 5, range 0-600).
  - When the peer's heartbeat is fresh but player.online is still 1,
    wait at most this many seconds, then force-claim ownership by setting
    online=0 AND last_server=self.
  - The peer will be prevented from overwriting us: writeSnapshotToDB
    already has the last_server guard (added in Phase 2) which blocks any
    future save the peer issues for this player — they see a GUARD log
    and skip downstream backpack/SS/RS2 writes.
  - Default 5s is a reasonable trade-off: legitimate slow flushes complete
    within that window, ghost sessions don't block the player 60s+.
  - Set to 0 to force-claim immediately (most aggressive, best for proxies).
  - Set high to restore the legacy behavior (wait full poll length).

Also removed the per-tick 'Player X still being saved...' LOGGER.info line
that was spamming the Minecraft server log every 500ms during a ghost wait
— the SyncLogger.raceCondition entry already captures the same information
in the dedicated sync.log and avoids polluting server.log with 120+ lines
per join.
 2026-04-22 07:16:47 +02:00
laforetbrut
131aa64eb1 Add /playersync inventory viewer 
New op command to pretty-print a player's stored inventory from the DB.
Works on offline players — reads the serialized columns directly and
deserializes each slot through the same deserializeAndCreatePlaceholderIfNeeded
path used by the normal restore.

Usage:
  /playersync inventory <player>              — everything (main + armor + ender + curios)
  /playersync inventory <player> main         — 36-slot hotbar + main inventory only
  /playersync inventory <player> armor        — 4 armor slots (0=boots, 1=legs, 2=chest, 3=helm)
  /playersync inventory <player> ender        — 27 ender chest slots
  /playersync inventory <player> curios       — Curios slots (funct + cosmetic), composite-keyed

Output per section lists only non-empty slots:
  [5] minecraft:diamond_sword x1
  [8] sophisticatedbackpacks:backpack x1 (Gilded Backpack)
  [cos🔙0] [placeholder] minecraft:paper x1   <- cross-server missing mod

Placeholder items (items from a mod not loaded on this server) are tagged
[placeholder] in magenta so admins can see at a glance which slots contain
'travelling' items. Parse errors on a single slot don't break the listing —
the affected slot shows <parse error: ClassName> and the rest continues.

Help listing updated. No other behavior changed.
 2026-04-22 07:03:08 +02:00
laforetbrut
4597041b1a Tutorial banner when MySQL init fails on a dedicated server 
If the admin installs PlayerSync without configuring a reachable database,
onServerStarting used to throw SQLException and either crash the server or
spam a raw JDBC stack trace with no guidance. Now the whole init is wrapped
in a single try/catch that prints a large, readable banner to the console:

  - What failed (root cause summary, message truncated to 180 chars)
  - Current config values (host, port, user, db, password status)
  - A 5-step checklist:
      1. Is the DB reachable (telnet / mysql CLI hints)
      2. Is the password still the default placeholder
      3. Docker compose up for local dev
      4. GRANT + bind-address reminders
      5. How to skip PlayerSync entirely for a session
  - Then the full stack trace for bug reports.

The server keeps booting — sync operations will no-op until the DB comes
back. Avoids the 'server crashed, no idea why' experience for first-time
users.

Detection of placeholder credentials (password == 'pleaseChangeThisPassword'
or host == 'localhost') also emits a WARN line up-front so the tutorial
context is primed even when the connection itself would have succeeded.
 2026-04-22 06:55:20 +02:00
laforetbrut
2361ffb272 jarJar: declare version ranges for MySQL + HikariCP 
Enables co-installation with arcadia-lib2 which embeds
  HikariCP in [5.1.0, 6.0.0)
  mysql-connector-j in [8.3.0, 9.0.0)

Before: PlayerSync declared its embedded libs with no range, only the
exact version (9.3.0 / 5.1.0). When another mod declared a range that
did not include our exact version, NeoForge's jarJar resolver had no
valid overlap and would either refuse to load or arbitrary-pick one
version, risking runtime breakage.

After:
  - mysql-connector-j: strictly [8.3.0, 10.0.0), prefer 9.3.0.
    Intersects arcadia-lib's [8.3.0, 9.0.0) — resolver picks 8.3.0
    when both mods are present. 8.3.0 and 9.3.0 share the same
    Connection / PreparedStatement / ResultSet APIs we actually use,
    so downgrade is safe.
  - HikariCP: strictly [5.1.0, 6.0.0), prefer 5.1.0. Identical to
    arcadia-lib's declared range — shared single instance.

No code changes — only the metadata shipped in META-INF/jarjar/metadata.json.
Verified via unzip -p that the range is correctly emitted.
 2026-04-22 06:46:24 +02:00
laforetbrut
d818794a20 Phase 8 fix: preserve config backward compatibility 
The Phase 8 refactor moved the connection keys (host, password, Server_id,
etc.) from [general] into a new [connection] section. On servers with an
existing playersync-common.toml this would silently reset:
  - host to 'localhost'
  - password to 'pleaseChangeThisPassword'
  - Server_id to a new random value

The last one is the worst: every player_data row with last_server=<old_id>
would momentarily point to a zombie peer until the next heartbeat tick.

Fix: move every key that already existed in 2.1.4 configs back into
[general]. Only genuinely new keys (save_triggers, sync_toggles,
performance, safety, observability) stay in their new sections. Existing
users upgrading see their old [general] block load correctly; the new
sections get created with defaults on first boot and don't wipe anything.

Also adds modid=PlayerSync.MODID to CommandInit's @EventBusSubscriber
so RegisterCommandsEvent is guaranteed to fire under our mod's bus scope.
 2026-04-22 06:38:27 +02:00
laforetbrut
c7487196ec Phase 8: 20+ new config keys + 14 admin commands (/playersync) 
Config (JdbcConfig.java completely restructured into sections):

  connection
    host, port, use_ssl, user_name, password, db_name, table_prefix, Server_id
  general
    sync_world, sync_advancements, kick_when_already_online,
    kick_message, kick_grace_period_ms, use_legacy_serialization,
    item_placeholder_title_override, item_placeholder_description_override
  save_triggers
    auto_save_interval_minutes (0-1440, default 10)
    save_on_dimension_change (default false)
    save_on_death (default true)
    save_on_respawn (default true)
  sync_toggles
    sync_inventory, sync_ender_chest, sync_xp, sync_effects,
    sync_health_food, sync_curios, sync_accessories, sync_backpacks,
    sync_cosmetic_armor, sync_refined_storage (all default true)
  performance
    heartbeat_interval_seconds (5-600, default 30)
    peer_stale_threshold_seconds (10-3600, default 60)
    join_poll_max_attempts (10-600, default 120)
    join_poll_interval_ms (100-5000, default 500)
    pool_stats_interval_minutes (0-1440, default 5)
    hikari_pool_max_size (1-200, default 15)
    hikari_leak_threshold_ms (2000-600000, default 25000)
  safety
    refuse_empty_inventory_write (default true) — enforced in writeSnapshotToDB
    max_inventory_size_bytes (default 10 MB)
    skip_saves_when_tps_below (0-20, default 0 = never)
  observability
    log_structured_json (future use)
    log_rotation_size_mb (default 10)
    log_rotation_max_files (default 5)

Wiring
  - HeartbeatService reads heartbeat_interval_seconds at start.
  - PoolStatsReporter reads pool_stats_interval_minutes (0 disables).
  - doPlayerJoin poll uses join_poll_max_attempts + join_poll_interval_ms +
    peer_stale_threshold_seconds.
  - writeSnapshotToDB: refuse_empty guard + max_inventory_size_bytes guard
    before core UPDATE. Both log via SyncLogger.dataLoss / .nbtAnomaly.
  - Restore-side toggles: applyCuriosFromData, applyAccessoriesFromData,
    applyCosmeticArmorFromData, doBackPackRestore, restoreRefinedStorageDisks
    all short-circuit when their toggle is false.

Commands — new /playersync tree (perm level 2 required):

  status             — server id + heartbeat age + exec/Hikari stats + online
  poolstats          — log current stats immediately
  flush [player]     — force save all / one
  info <player>      — DB row metadata
  dump <player>      — dump full DB row to server log
  resync <player>    — clear synced tag + kick to force re-restore
  wipe <player> confirm  — DELETE all rows (DANGER, double-keyword required)
  orphans            — list stuck online=1 rows on dead peers
  clearorphans [id]  — clear orphans (global or by server_id)
  peers              — list peer servers with ALIVE/STALE/STOPPED tag
  peerkill <id>      — force-disable a zombie peer
  cleanup            — orphans + stale peers in one shot
  reload             — note about runtime reload scope
  help               — in-chat command reference

Every command logs to SyncLogger as ADMIN_<OP> for audit trail.

Infrastructure
  - JDBCsetUp.executePreparedUpdateRet(String, Object...) returns rows-affected
    for commands that need meaningful counts.
  - VanillaSync.getExecutor() exposes the thread pool for read-only stats access
    from admin commands (replaces reflection use in PoolStatsReporter eventually).
 2026-04-22 06:34:02 +02:00
laforetbrut
44178e020e Phase 7: server-perf hardening (hash-skip + batch + heartbeat tuning) 
Based on a fresh audit against the Arcadia V2 modpack (444 mods, including
Curios + Accessories + SophisticatedBackpacks/Storage + RS2 + Cosmetic
Armor Reworked). Three perf wins + two opportunistic fixes.

Perf
  - Heartbeat period 10s -> 30s. Paired with the 60s staleness threshold
    this keeps failure-detection latency unchanged while cutting 3x the
    server_info UPDATE traffic per server.
  - Per-player hash-skip for unchanged snapshots (SaveToFile + staggered
    auto-save). computeSnapshotHash() rolls over inventory/equipment/
    enderchest/effects/xp/health/food/mod-data; when an auto-save produces
    the same hash as the last successful write, the BG task returns early
    and no UPDATE hits MySQL. Idle-server reduction is >95%. Logout /
    shutdown / death never use the skip and refresh the hash on success
    so post-logout rejoin doesn't wrongly skip.
  - Batched backpack + SS saves. saveBackpackSnapshots / saveSSSnapshots
    now build one transaction via executeBatchTransaction instead of
    N sequential REPLACE INTO calls. A player with 3 backpacks + 2
    shulkers drops from 5 network round-trips to 1 per logout save.
    Per-entry fallback preserved on transaction failure.
  - Periodic-save tick short-circuits when the player list is empty —
    no main-thread hop, no log line, no DB heartbeat on empty servers.

Compat notes (no code change needed)
  - CosmeticArmours (modid=cosmeticarmoursmod) items are worn in vanilla
    armor slots (Helmet / Chestplate / Leggings / Boots inner classes) —
    already captured by the core armor[] serialization. No handler needed.
  - CosmeticWeapons uses the same pattern via main hand / offhand — also
    already covered by core inventory serialization.

Cleanup
  - removePlayerLock now also clears the hash cache so a player who
    fully logged out doesn't leave a stale hash behind.
 2026-04-22 06:17:28 +02:00
laforetbrut
a83543853c Phase 6: docs (CHANGELOG, ERROR_LOG, TEST_PROCEDURE) 
Adds three documentation files covering the Phase 0-5 hardening work:

CHANGELOG.md
  - Bilingual EN/FR, strict template (English first, then ---, then French).
  - Version section 2.1.5 dated 2026-04-22 (NO version bump per
    CLAUDE.md version-lock rule).
  - Sections: Fixed / Added / Changed / Correctifs / Ajouts / Modifications.

ERROR_LOG.md
  - Journal of 8 bugs discovered and fixed during the hardening sweep.
  - Each entry: Context / Error / Root cause / Fix / Prevention rule.
  - Cross-references commits bea5f80 / c84f920 / 746cb56 / c70ca9f / bd0482c.

TEST_PROCEDURE_v2.1.5.html
  - Self-contained HTML (no external deps), bilingual EN/FR.
  - 10 test scenarios tagged CRITICAL / HIGH / MEDIUM with Setup, Steps,
    Expected Results, and a regression-check block.
  - Covers: drop+deco+reco, backpack dup, SS shulker dup, kill -9 recovery,
    zombie-peer short-circuit, periodic save, pool stats, heartbeat,
    curios cap unavailable, cross-server claim.
 2026-04-22 06:09:08 +02:00
laforetbrut
bd0482cb76 Phase 5: structured logging + periodic pool-stats reporter 
SyncLogger additions
  - containerForceClosed(uuid, reason)
  - modCompatSkip / modCompatSaved / modCompatRestored (per-mod tracing)
  - storageSave(storageUuid, kind, detail) for backpack/SS/RS2 lines
  - poolStats(exec active/queue/idle, hikari active/idle)
  - warnPlayer / nbtAnomaly generic helpers

PoolStatsReporter.java
  - Dedicated single-thread daemon scheduler, 5-min cadence.
  - Reads VanillaSync.executorService stats via reflection.
  - Reads HikariCP MBean via new JDBCsetUp.getPoolMXBean().
  - Emits WARN logs when executor queue > 400/512 or Hikari active >= 14/15
    so admins see saturation trends before they become outages.

JDBCsetUp.getPoolMXBean()
  - Public accessor for the HikariCP pool MBean. Returns null when pool
    is uninitialised / closed.

Wire-in: PlayerSync.onServerStarting starts the reporter, onServerShutdown
stops it before pool close.

Instrumentation
  - VanillaSync.onPlayerLogout logs containerForceClosed for self + viewer
    containers.
  - ModCompatSync.snapshotAccessories logs modCompatSkip when cap==null.
 2026-04-22 06:03:52 +02:00
laforetbrut
c70ca9f464 Phase 4: 10-min periodic save + dimension-change trigger 
Adds two new triggers that complement NeoForge's vanilla SaveToFile event:

PeriodicSaveService.java
  - Dedicated single-thread daemon scheduler, started after server boot.
  - Ticks every 'auto_save_interval_minutes' (config, default 10 min).
  - On each tick: hops to main thread, snapshots every online synced
    player via VanillaSync.snapshotAndQueueSave, async BG writes with full
    P0 guard stack (pendingLogoutSaves + online=0 + bgLock tryLock).
  - Set interval to 0 to disable.

VanillaSync.snapshotAndQueueSave(Player, String label)
  - Extracted from onPlayerSaveToFile body; public entry point shared by
    PeriodicSaveService, onPlayerChangeDimension, and the existing SaveToFile
    event. Label flows into logs for traceability (SaveToFile / PERIODIC / DIMENSION).

VanillaSync.onPlayerChangeDimension
  - New @SubscribeEvent on PlayerChangedDimensionEvent, gated by
    'save_on_dimension_change' config (default false). Queues a full save
    when a player teleports across dimensions, protecting against mid-
    teleport crashes.

JdbcConfig
  - Added AUTO_SAVE_INTERVAL_MINUTES (int, 0-1440, default 10)
  - Added SAVE_ON_DIMENSION_CHANGE (bool, default false)

VanillaSync.onServerShutdown also stops PeriodicSaveService before the pool
close, same pattern as HeartbeatService.
 2026-04-22 06:01:55 +02:00
laforetbrut
746cb56275 Phase 3: anti-loss infrastructure (shutdown hook + heartbeat + crash recovery) 
Adds three utilities to harden PlayerSync against ungraceful server exits:

CrashRecovery.java
  - installShutdownHook: registers a non-daemon JVM shutdown hook that calls
    VanillaSync.emergencyFlushAll() synchronously when the process is killed
    (SIGTERM, kill, OOM, host reboot). Covers the case where the normal
    ServerStoppingEvent path never runs.
  - clearOrphanedOnlineFlags: on startup, clears any online=1 player_data
    rows pointing to this server_id (left by a previous crash). Reports the
    count via SyncLogger so admins can see recovery activity.
  - reportZombiePeers: logs peer server_ids whose heartbeat is missing or
    stale (>60s), exposing the root of doPlayerJoin poll timeouts.

HeartbeatService.java
  - Single-thread daemon scheduler pinging server_info.last_update every 10s.
  - Lets peer servers distinguish live from dead via isPeerServerStale().
  - Stopped explicitly in VanillaSync.onServerShutdown before pool close.

VanillaSync.emergencyFlushAll()
  - Synchronous best-effort flush for every online player. No executor, no
    locks — the server is dying, we just want data on disk. Writes player_data,
    backpacks, SS, RS2 directly; logs SAVE/SKIPPED/FAILED per player via
    SyncLogger so post-mortem analysis is possible.

PlayerSync.onServerStarting wires the four new calls after table init.

Fixes the production issue where players remained online=1 forever after
kill -9 and the 30s poll timeouts waiting for zombie server_ids.
 2026-04-22 05:44:19 +02:00
laforetbrut
c84f920d11 Phase 2: hardened anti-dup + zombie-server detection + guard propagation 
P0-1: Backpack/SS clear-before-restore now has a belt-and-suspenders
reflection fallback if the public removeBackpackContents / removeStorageContents
API fails. setBackpackContents / setStorageContents receive a defensive NBT
copy to prevent upstream from mutating the cached snapshot.

P0-2: writeSnapshotToDB now returns a boolean. When the last_server guard
blocks the core player_data UPDATE (another server claimed the player),
the downstream backpack / SS / RS2 saves are skipped instead of overwriting
the claiming server's rows. Affects logout, shutdown, staggered auto-save,
and death-save paths.

P1-1: StoreCurios now aborts when the Curios capability is unavailable
(dead player, mod init race) instead of writing an empty flatMap that
would wipe the DB row.

P1-3: doPlayerJoin last_server poll raised 60→120 attempts (30s→60s)
and gained a zombie-server short-circuit: if the peer server_id is 0
(legacy / corrupted), or its server_info heartbeat is older than 60s,
the poll takes over immediately and force-clears the orphaned online=1.
Fixes the user-observed 'attempt 60/60' loops on server_id=0 and stale
heartbeats.

Staggered auto-save and death-save BG tasks also gained the P0-a/b/c
guards introduced in bea5f80 (pendingLogoutSaves + online=0 DB check).
 2026-04-22 05:40:16 +02:00
laforetbrut
bea5f80e3a Fix critical item duplication race (drop+deco+reco) 
Root cause: auto-save BG task queued before logout could acquire bgLock and
write a stale snapshot AFTER the logout BG task had committed fresh data +
online=0. On reconnect, the stale inventory was restored while the dropped
ItemEntity remained on the ground -> duplication.

Three-layer guard applied to onPlayerSaveToFile and onLivingDeath BG tasks:
  1. Early skip if pendingLogoutSaves contains the player (before tryLock)
  2. Re-check pendingLogoutSaves after acquiring bgLock (race window)
  3. SELECT online from player_data before write; skip if online=0

Logout BG task now acquires bgLock via .lock() (blocking) so concurrent
auto-save / death-save tasks using tryLock either skip cleanly or wait.
removePlayerLock reordered before bgLock.unlock so late auto-save BGs see
containsKey=false and skip.
 2026-04-22 05:28:36 +02:00
laforetbrut
f334b44a55 Add compat-mods staging folder for mod compatibility analysis 
Local .jar staging area for inspecting mod APIs and writing compatibility
shims. Binaries git-ignored; README documents the purpose and conventions.
 2026-04-22 03:33:11 +02:00
laforetbrut
13de5b65c0 Fix backpack/curios dup, perf overhaul, drop chat+cobblemon 
Root cause of backpack duplication: Sophisticated Backpacks'
setBackpackContents merges shallowly when the UUID exists, so stale
sub-tags survived every restore. doBackPackRestore now calls
removeBackpackContents before setBackpackContents for a clean replace.

Curios cosmetic stacks (getCosmeticStacks) are now snapshotted, applied,
restored and cached on all paths. Old-format rows without the "cos:"
prefix still parse unchanged, so existing DB data is preserved on upgrade.

closeContainer no longer matches by class-name substring (was closing
unrelated mod menus containing "curio"/"accessor"). Only menus whose
slots reference the disconnecting player's inventory/ender-chest are
closed.

Thread-safety: Sophisticated Storage contents are now snapshotted on the
main thread (snapshotSSData + saveSSSnapshots) instead of read from a
background thread racing with world ticks.

Event priority / defensive guards:
- onPlayerDeath is now EventPriority.LOW and skips cancelled events so
  Revive Me / Corail Tombstone's cancel runs first.
- onServerStarting short-circuits on integrated (single-player) servers
  to avoid noisy MySQL connection attempts.

Observability:
- executeBatchTransaction now returns per-statement row counts.
- writeSnapshotToDB calls SyncLogger.guardBlocked when the core UPDATE
  silently no-ops (another server claimed last_server).
- SyncLogger uses a daemon scheduler that flushes every 500 ms; shutdown
  happens after parallel saves so final save logs are no longer dropped.
- Rollback failures inside executeBatchTransaction and
  refreshInventoryForInputOutput are now logged instead of swallowed.

HikariCP retuned: maxPoolSize 25->15, connectionTimeout 30->10s,
idleTimeout 600->300s, leakDetectionThreshold 10->25s (covers worst-case
join polling without log spam).

New table_prefix config option (Tables helper) lets a user share one
MySQL database with other mods without table-name collisions. Default
is empty to preserve backward compatibility.

Reflection Methods for NeoForge AttachmentHolder are resolved once in
a static initializer and cached.

Chat sync and Cobblemon integration removed:
- Chat sync: 319 LoC of socket/thread code guarded by a config flag that
  defaulted to false; orphaned config keys are silently ignored by the
  NeoForge ModConfig loader, so no crash on upgrade.
- Cobblemon: 297 LoC of mixins that ran synchronous JDBC on the main
  thread and built SQL with raw UUID concatenation. The existing
  cobblemon table in the DB is left untouched on upgrade.

Also fixes cobblemon ALTER TABLE running blindly on every boot
(alterColumnIfNeeded helper checks INFORMATION_SCHEMA first).

Author: vyrriox
 2026-04-22 02:50:26 +02:00
laforetbrut
edf63aeb8c Add dedicated PlayerSync diagnostic log file (logs/playersync/sync.log) 
New SyncLogger utility class:
- Writes to logs/playersync/sync.log (separate from MC console)
- Automatic rotation: 10MB max per file, 5 files kept
- Thread-safe: lock-free ConcurrentLinkedQueue + async flush
- Categorized log levels: INFO, WARN, ERROR, DUPE_RISK, DATA_LOSS,
  RACE, PERF_SLOW, SAVE, SAVE_FAIL, SAVE_SKIP, RESTORE, EVENT, GUARD

Tracked events:
- Every player join/leave with sync status
- Every save (logout, shutdown, death, auto-save) with duration
- Save failures with error details
- Saves skipped (uncompleted sync, dead player)
- Cross-server race conditions (poll loop waiting)
- Player disconnects before sync apply (potential data loss)
- Duplicate login kicks
- Slow operations (> 50ms threshold)

Usage: check logs/playersync/sync.log on your server for diagnostics.
Look for DUPE_RISK, DATA_LOSS, RACE, SAVE_FAIL entries.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-15 14:12:31 +02:00
laforetbrut
57f7925c2f Perf: MySQL connection tuning, batch transactions, leak detection 
MySQL connection string optimizations:
- rewriteBatchedStatements=true: rewrites batch INSERTs into multi-row (5-30x)
- cachePrepStmts=true + useServerPrepStmts=true: server-side prepared
  statement caching, avoids re-parsing identical queries (15-25% CPU reduction)
- prepStmtCacheSize=256: keeps 256 compiled statements warm
- useCompression=true: compresses network traffic (40-60% for large NBT blobs)
- tcpNoDelay=true: disables Nagle's algorithm for lower latency

Batch transaction for writeSnapshotToDB:
- New JDBCsetUp.executeBatchTransaction() executes multiple SQL statements
  in a SINGLE transaction on ONE connection with automatic rollback.
- writeSnapshotToDB now batches all 4-8 queries (player_data + curios +
  mod_player_data) into one connection borrow + one commit.
- Previous: 4-8 separate getConnection() + executeUpdate() + close() calls
  per player save = 4-8 network round-trips.
- Now: 1 getConnection() + N executeUpdate() + 1 commit() + 1 close()
  = 1 network round-trip for the transaction.
- With 35 players: 140-280 connection borrows → 35 connection borrows.

HikariCP leak detection:
- Added leakDetectionThreshold=10000ms to detect connections held > 10s

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-15 14:06:22 +02:00
laforetbrut
b4d863efa2 Perf: staggered auto-save, pool scaling, cached kick check 
CRITICAL PERF - Staggered auto-save:
- Old: all 35 players snapshotted in ONE tick → 770-3605ms MSPT spike
  (15-36 second TPS drop every 5 minutes)
- New: queue filled every 5min, drained 1 player/tick → max 22-103ms/tick
- autoSaveQueue processes one player per server tick, imperceptible impact

CRITICAL PERF - Pool scaling for 35+ players:
- Thread pool: 2-8 → 4-16 threads, queue 256 → 512
  Prevents CallerRunsPolicy from executing DB tasks on main thread
- HikariCP: 10 → 25 max connections, 2 → 4 min idle
  Prevents connection starvation during concurrent saves

HIGH PERF - Cached kick check (eliminates main thread DB queries):
- doPlayerConnect (network thread) caches online/lastServer/serverAlive
- onPlayerLoggedInKickCheck (MAIN thread) reuses cached result
- Fast path: 1 DB query on main thread instead of 2-4
- Fallback: full DB check if cache miss (race condition safety)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-15 11:33:02 +02:00
laforetbrut
badc87c84e Fix backpack crash loss, ender chest restore, ReviveMe compat, effect sync 
Backpack data loss on server crash:
- Periodic auto-save (every 5min) now includes backpack content snapshots.
  Previously backpacks were only saved on logout/shutdown — hard crashes
  (OOM, watchdog, kill -9) skipped both, losing all backpack changes.
- snapshotBackpackData captures NBT with .copy() on main thread.

Backpack ender chest restore mismatch:
- doBackPackRestore now scans ender chest in addition to main inventory.
  Save side already scanned ender chest, but restore didn't — backpacks
  in ender chest were saved to DB but never restored on join.

ReviveMe mod compatibility:
- Dead player kick check now uses health <= 0 instead of isDeadOrDying().
  ReviveMe puts players in a "downed" state (alive but isDeadOrDying=true)
  — previously these players were kicked on join.

Infinite effect filtering (phantom effects fix):
- Effects with infinite duration are now skipped during save. These come
  from ReviveMe (downed state effects with MAX_VALUE duration), beacons,
  and other mods. Syncing them across servers caused phantom effects.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-15 11:24:18 +02:00
laforetbrut
1d30184aba Fix critical data loss, backpack duplication, and ender chest sync 
CRITICAL - New player data loss (players lose everything):
- store() INSERT now includes last_server column. Without it, last_server
  stayed NULL, causing ALL subsequent writes (AND last_server=?) to fail
  silently — new players' data was never saved after initial INSERT.
- writeSnapshotToDB now handles legacy NULL last_server with
  (last_server=? OR last_server IS NULL) and auto-claims ownership.
- Same NULL handling in writeGuardedModData for mod_player_data table.

CRITICAL - online=0 stuck at 1 (players unable to connect):
- Removed AND last_server=? from deadPlayerWhileLogging and
  syncNotCompletedPlayer logout paths. These fire before doPlayerJoin
  sets last_server, so the guard always failed → online stayed 1.

CRITICAL - Backpack duplication via viewer race:
- snapshotBackpackData() now captures backpack NBT on the MAIN THREAD
  (not just UUIDs). Previously saveBackpacksByUuids read BackpackStorage
  on an async thread — another player viewing the backpack could take
  items between the main-thread refresh and the async read.
- .copy() freezes the NBT state at snapshot time.

CRITICAL - Backpacks in ender chest not synced:
- snapshotBackpackData() and doBackPackRestore now scan the ender chest
  in addition to main inventory. PlayerInventoryProvider.runOnBackpacks
  only scans equipment/inventory, missing ender chest backpacks entirely.

Anti-duplication - Container closing on disconnect:
- Owner's container menu is force-closed before snapshot to prevent
  post-snapshot modifications by viewers.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-15 11:00:18 +02:00
laforetbrut
f042058e5b Fix Accessories/CosmeticArmor duplication + guard remaining online=0 
Accessories & CosmeticArmor duplication fix:
- snapshotAccessories() and snapshotCosmeticArmor() returned null when
  slots were empty, causing writeModSnapshot to SKIP the write. The DB
  kept stale data from when slots had items, restoring them on next join.
- Now return "{}" (like snapshotCuriosData already does), so empty state
  is properly written to DB. On restore, apply*FromData clears slots
  when it sees "{}" (length <= 2).

Guard remaining online=0 writes:
- deadPlayerWhileLogging and syncNotCompletedPlayer logout paths now
  use AND last_server=? to prevent setting online=0 for a player that
  already moved to another server.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-05 20:26:10 +02:00
laforetbrut
8f40d5b27f Fix critical cross-server duplication race + memory leak + atomic saves 
CRITICAL FIX - Stale server overwrite prevention:
- writeSnapshotToDB now guards ALL writes with AND last_server=? so a
  crashing/slow server cannot overwrite fresher data saved by another server
- Logout and shutdown saves atomically set online=0 in the SAME UPDATE as
  the data write (no more gap between data write and flag set)
- ModCompatSync.writeModSnapshot guarded variant uses subquery on last_server

CRITICAL FIX - Poll loop actually waits now:
- onPlayerLoggedInKickCheck no longer sets last_server (only online=1)
- last_server is claimed AFTER the poll in doPlayerJoin completes
- This allows the poll to correctly detect and wait for the old server's
  async save to finish before reading data
- Poll increased from 30 to 60 attempts (30s window)

Memory leak fix:
- Added removePlayerLock() in doPlayerJoin's outer catch block to prevent
  unbounded growth of playerLocks ConcurrentHashMap on exceptions

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-05 07:47:38 +02:00
laforetbrut
1dfdd43908 Fix advancement wipe, phantom effects on death, and advancements COALESCE 
- Advancements: default to null instead of "" in snapshotPlayerData, use
  COALESCE(?, advancements) in SQL so failed file reads preserve DB value
  instead of silently wiping advancements every 5min periodic save
- Effects: skip saving effects when player isDeadOrDying() — Minecraft
  clears effects on respawn not death, so pre-death effects were persisted
  in DB and restored as phantom effects on next login
- Legacy store() also uses COALESCE(NULLIF(?, ''), advancements)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-04-04 12:52:14 +02:00
laforetbrut
eec949f405 Fix anti-duplication: clear slots before restoring data 2026-04-04 07:16:50 +02:00
laforetbrut
a8c0cb50af Update VanillaSync.java 2026-03-31 03:51:01 +02:00
laforetbrut
59bd884263 perf: zero JDBC on server thread + HikariCP + parallel shutdown + audit fixes 
- Migrate connection pool from manual LinkedBlockingQueue to HikariCP
  (eliminates isValid() ping on every query visible in Spark profiler)
- Move ALL DB writes off server thread: logout uses snapshot+async+latch,
  shutdown uses snapshot+CompletableFuture.allOf for parallel saves
- Pre-read curios/accessories/cosmeticarmor/attachments on background
  thread during login (4-7 fewer DB queries on main thread per login)
- Auto-save interval increased to 5 minutes
- Fix pool shutdown ordering: shutdownPool() now runs AFTER all shutdown
  saves complete (previously could fire before, silently losing all data)
- Fix connection leak in executeQuery/executePreparedQuery when
  prepareStatement throws (leaked connections exhaust HikariCP pool)
- Fix duplication bug: saveStorageContents guard used nbt.size()<=1 which
  blocked legitimately emptied backpacks from saving to DB
- Fix stale SaveToFile overwriting logout: check playerLocks.containsKey
  before writing to prevent stale background task from regressing data
- Remove LIMIT 1000 on startup online=0 reset (could leave players stuck)
- Add executorService.shutdown() on server stop to prevent JVM hang
- Add apply methods (applyCuriosFromData, applyAccessoriesFromData, etc.)
  to separate entity writes from DB reads for thread-safe restore
- Add UUID collectors (collectBackpackUuids, collectSSUuids) and
  background save methods for snapshot+async logout/shutdown pattern
 2026-03-29 18:58:27 +02:00
laforetbrut
4999c372ec perf: eliminate synchronous MySQL calls on server main thread 
Root cause of lag (TPS 9-16, MSPT spikes to 4846ms):
PlayerEvent.SaveToFile triggered synchronous JDBC writes on the
server main thread every Minecraft autosave cycle. With 35 players
this caused hundreds of network round-trips to MySQL blocking the
tick loop for up to 4846ms (97x the 50ms limit).

Fixes applied:
- onPlayerSaveToFile: now fully async. Entity state is snapshotted
  on the main thread (pure memory ops, <1ms), then ALL DB writes are
  submitted to the background executor. Main thread never blocks on
  MySQL again.

- snapshotPlayerData: now captures ALL entity-dependent mod data
  (Curios, Accessories, CosmeticArmor, NeoForge attachments) on the
  main thread. Previously these were read from a background thread
  which is not thread-safe and could cause data corruption.

- writeSnapshotToDB: single method that writes all player data in one
  background pass: player_data + curios + mod_player_data.

- Auto-save background task: removed ModCompatSync.storeAll(player),
  storeSophisticatedBackpacks, storeSophisticatedStorageItems,
  storeRefinedStorageDisks from background thread. These all accessed
  entity state off-thread. Mod compat data is now in the main-thread
  snapshot; backpack/SS/RS2 contents are saved on logout/shutdown.

- Added ModCompatSync snapshot API: snapshotAccessories(),
  snapshotCosmeticArmor(), snapshotAttachments(), writeModSnapshot()
  for clean separation of entity reads vs DB writes.
 2026-03-27 14:15:29 +01:00
laforetbrut
04a1f0128e Optimize: move ALL DB writes off main thread + increase auto-save to 2min 
Spark showed 5.66% server thread from auto-save. Breakdown:
- store() DB write: 1.39% (already moved to background)
- StoreCurios DB write: 0.56% (was on main thread)
- storeAccessories DB write: 0.55% (was on main thread)
- storeCosmeticArmor DB write: 0.56% (was on main thread)
- storeNeoForgeAttachments DB write: 0.58% (was on main thread)
- storeSophisticatedStorage: 0.69% (was on main thread)
- storeSophisticatedBackpacks: 0.59% (was on main thread)

Changes:
1. Curios snapshot: new snapshotCuriosData() reads entity state on
   main thread (fast), returns serialized string. DB write in background.
2. ALL mod saves moved to background thread lambda:
   - ModCompatSync.storeAll (Accessories, CosmeticArmor, Attachments)
   - Sophisticated Backpacks/Storage/RS2
3. Auto-save interval doubled: 1200 -> 2400 ticks (1min -> 2min)
4. Main thread now only does: entity snapshot (~0.3ms) + curios snapshot

Expected: ~80% reduction in main thread usage (5.66% -> ~1%)

Vyrriox
 2026-03-26 22:17:25 +01:00
laforetbrut
7613f4ecfb Fix backpack/shulker contents lost on transfer: never overwrite DB with empty data 
ROOT CAUSE: Sophisticated Backpacks/Storage wrappers cache inventory
in memory. When store() reads from BackpackStorage/ItemContentsStorage,
the SavedData may not have the latest wrapper state (unflushed changes).
This returns empty/default NBT which overwrites the real data in our DB.

Going back to the original server showed data because that server's
local SavedData still had the correct data (never overwritten).

FIX: saveStorageContents() now checks if the NBT is empty/minimal
before writing. If the DB already has substantial data (>50 bytes)
and the new NBT is empty, the save is SKIPPED to preserve the real
data. This prevents the empty-overwrite scenario while still allowing
legitimate saves of actual content.

Vyrriox
 2026-03-26 22:09:51 +01:00
laforetbrut
e511414463 Final hardening: online=0 in finally + auto-save race fix 
CRITICAL-1: online=0 moved to finally block in logout handler.
If store() threw an exception, online=0 was never written and the
player was permanently locked out of all servers.

CRITICAL-2: Same fix for shutdown handler. Any save failure during
shutdown left the player permanently stuck as online=1.

IMPORTANT: Auto-save background DB write now acquires tryLock()
before writing. If logout already saved newer data and holds/held
the lock, the stale auto-save snapshot is skipped. Prevents
overwriting correct logout data with an older snapshot.

Vyrriox
 2026-03-26 22:06:38 +01:00
laforetbrut
1bf2a67e8d Optimize auto-save: snapshot on main thread, DB write on background 
Spark showed 5.66% server thread from auto-save DB writes blocking
the tick loop (~1-2ms per player per query, ~8 queries per save).

New approach:
- snapshotPlayerData() captures ALL entity data into an immutable
  PlayerDataSnapshot record on the main thread (fast, no DB I/O)
- writeSnapshotToDB() writes the snapshot to DB on the background
  thread via executorService (slow DB I/O off main thread)
- Mod data (Curios, Accessories, CosmeticArmor, NeoForge attachments)
  still read entity state on main thread but their DB writes happen
  inline (they manage their own connections)
- Sophisticated Backpacks/Storage/RS2 saves happen during snapshot
  phase on main thread (they need entity access for inventory scan)

Expected: ~60-70% reduction in main thread blocking from auto-save.

Vyrriox
 2026-03-26 21:31:43 +01:00
laforetbrut
d60b8eb01e Add connection pool - fix 10% server thread usage from MySQL connects 
Spark showed PlayerSync consuming 10.16% of the server thread, almost
entirely from DriverManager.getConnection() (TCP handshake + MySQL auth
+ USE db) called for EVERY single query. With auto-save every 60s,
each player generated ~6 new connections per save cycle on main thread.

FIX: Simple connection pool (LinkedBlockingQueue, 5 connections).
- Connections are reused instead of opened/closed per query
- isValid(2) check before reuse to detect dead connections
- returnConnection() puts connections back in pool instead of closing
- QueryResult.close() also returns to pool
- autoReconnect=true in JDBC URL for resilience
- shutdownPool() for clean server stop
- Non-database connections (startup DDL) bypass the pool

Expected improvement: ~90% reduction in MySQL overhead on server thread.

Vyrriox
 2026-03-26 21:13:17 +01:00
laforetbrut
e9620eb07e Fix RS2 restore: wrap entry in UUID key before codec decode 
ROOT CAUSE from logs:
  "Invalid UUID capacity: Invalid UUID string: capacity"
  "Invalid UUID resources: Invalid UUID string: resources"

We saved the INNER storage data ({type, capacity, resources}) but the
map codec expects {uuid-string: {type, capacity, resources}}.
The codec tried to parse "capacity", "resources", "type" as UUIDs.

FIX: Wrap the stored NBT back in a UUID-keyed CompoundTag before
decoding: wrapped.put(uuid.toString(), storedNbt)

Also increased sync timeout from 15s to 60s - the server was 34s
behind (691 ticks) causing timeout errors for player sync.

Vyrriox
 2026-03-26 20:53:23 +01:00
laforetbrut
12645a1d3d Fix RS2 restore: remove() before set() + reflection fallback 
repo.set(uuid, storage) throws IllegalArgumentException if the UUID
already exists in the StorageRepository. This happens when a player
revisits a server where the disk was previously used.

Items appeared briefly (data was decoded correctly) but then the
exception prevented the set() and the storage fell back to empty.

Fix:
- Call repo.remove(uuid) before repo.set(uuid, storage)
- If set() still fails, inject directly into the entries map via
  reflection + mark SavedData dirty
- setDirty() ensures the injected data persists to disk

Vyrriox
 2026-03-26 20:37:02 +01:00
laforetbrut
2baa8e4c39 Fix RS2: use createCodec() not getMapCodec() - wrong return type 
ROOT CAUSE: getMapCodec(Runnable) returns MapCodec (not Codec).
createCodec(Runnable) returns Codec<Map<UUID, SerializableStorage>>.
Reflection on getMapCodec silently failed because the returned
MapCodec.decode() has a different signature than Codec.decode().

Both save fallback and restore codec paths now use createCodec().

RS2 uses ErrorHandlingMapCodec with UUIDUtil.STRING_CODEC for keys,
so the encoded format IS a CompoundTag with UUID strings as keys.

Vyrriox
 2026-03-26 20:25:50 +01:00
laforetbrut
bce7a73cb8 Fix RS2 disk sync: use save() return value + codec reflection fallback 
Save side:
- save() returns data in a NEW CompoundTag (fixed in previous commit)
- Now logs full NBT structure for debugging (describeNbtStructure)
- If UUID not found in save() NBT, falls back to reflection on
  internal entries map + codec.encodeStart() to serialize directly

Restore side:
- Rewritten to use raw Codec types to avoid generic compilation issues
- Decodes stored NBT via the same map codec, then repo.set() to inject

Both sides now have comprehensive logging to diagnose any remaining
format issues in production.

Vyrriox
 2026-03-26 20:14:26 +01:00
laforetbrut
4e2574a147 Fix RS2 disk save: use return value of SavedData.save() 
save() returns the serialized data in a NEW CompoundTag - it does NOT
fill the input parameter. We were passing an empty tag and reading it
back, getting nothing. The actual data was in the return value.

Log showed: "RS2 disk UUID xxx exists in repo but NOT found in save()
NBT. Keys at top: []" - empty because we ignored the return value.

Vyrriox
 2026-03-26 19:30:27 +01:00
laforetbrut
50c77f7bb8 Fix last 2 audit issues: syncNotCompleted race + SaveToFile off-thread 
BUG 1 - syncNotCompletedPlayer race condition:
  syncNotCompletedPlayer.add() was inside the background thread body.
  A player disconnecting instantly before the thread starts bypasses
  the "sync not completed" guard in onPlayerLogout, causing store()
  to read invalid entity state.
  FIX: add() moved to onPlayerJoin BEFORE executorService.submit().

BUG 2 - doPlayerSaveToFile off main thread:
  onPlayerSaveToFile wrapped doPlayerSaveToFile in executorService,
  but SaveToFile already fires on the main thread. store() reads
  player inventory/armor/effects from a background thread = corruption.
  FIX: Call doPlayerSaveToFile directly (no executor). Same fix as
  auto-save and logout paths.

Vyrriox
 2026-03-26 19:17:16 +01:00
laforetbrut
6bb8aeba39 Fix RS2 disk + SS shulker data loss: use in-memory API, not .dat files 
ROOT CAUSE for both:
- RS2: We removed dataStorage.save() to avoid fastasyncworldsave crash,
  but then read the .dat file which had stale data. Disks appeared
  empty because the file didn't contain the latest in-memory state.
- SS: getOrCreateStorageContents() could create empty content if the
  data wasn't loaded yet for that UUID.

FIX RS2:
- Save: Use SavedData.save(CompoundTag, Provider) which serializes
  from MEMORY, not disk. No file I/O, no fastasyncworldsave conflict.
- Restore: Decode entries via RS2's codec (reflection on getMapCodec)
  and inject via repo.set(). Falls back to direct NBT injection if
  codec fails.
- Removed dead code: getRS2DataFile, injectRS2EntryIntoNbt

FIX SS:
- Already using StackStorageWrapper.fromStack() API for UUID extraction
  (DataComponent-based, not CustomData). This was fixed in previous
  commit. If data still missing, the save() logging will show which
  UUIDs fail to find in ItemContentsStorage.

Vyrriox
 2026-03-26 19:12:02 +01:00
laforetbrut
7c89df7d1b Remove dataStorage.save() call that conflicts with fastasyncworldsave 
storeRefinedStorageDisks() called DimensionDataStorage.save() directly
to flush RS2 data before reading the .dat file. This triggers all
SavedData saves simultaneously and conflicts with fastasyncworldsave's
async save mixin, causing ConcurrentModificationException crash.

Fix: Only mark RS2 SavedData as dirty (setDirty()) and let the normal
world save cycle handle the flush. The .dat file read may get slightly
stale data but avoids crashing the server.

Vyrriox
 2026-03-26 18:51:27 +01:00
laforetbrut
484f1a8c05 Final audit: fix ghost-online, SQL injection, resource leak, NPE 
CRITICAL-1/2: Remove duplicate online=1 writes from doPlayerJoin.
The synchronous onPlayerLoggedInKickCheck already sets online=1.
The background thread writes raced with logout's online=0, permanently
locking players as "online" after crash-disconnect during join.

HIGH-1: Startup SQL uses PreparedStatement for server_id (was string concat).
HIGH-2: update() method now uses try-with-resources for PreparedStatement.
HIGH-3: NPE guard in RS2 data file logging when getRS2DataFile returns null.

Vyrriox
 2026-03-26 18:33:00 +01:00
laforetbrut
b1563cc9ae Fix duplicate login kick bypass - logout was resetting online flag 
ROOT CAUSE: When Server B kicks a player for being already online on
Server A, the onPlayerLogout handler on Server B fires and sets
online=0 in the DB. The player then immediately reconnects to Server B,
the DB says online=0, and the kick check passes - player is now on
BOTH servers simultaneously.

FIX: New kickedForDuplicateLogin set tracks players being kicked for
duplicate login. onPlayerLogout checks this set FIRST and skips the
online=0 update entirely. The player's DB record correctly stays
online=1 with last_server=A, preventing reconnect bypass.

Flow:
1. Player on Server A (online=1, last_server=A)
2. Player tries Server B → kick check → online=1, A alive → KICK
3. kickedForDuplicateLogin.add(uuid) BEFORE disconnect
4. onPlayerLogout fires → sees kickedForDuplicateLogin → skips online=0
5. Player retries Server B → online=1 still → KICKED AGAIN

Vyrriox
 2026-03-26 18:27:29 +01:00
laforetbrut
0a88694166 Production hardening: fix all critical audit issues 
CRITICAL fixes:
- C-1/C-2/C-4: Auto-save and logout now run on MAIN THREAD. All entity
  reads (inventory, curios, effects) were happening off-thread, causing
  duplication exploits (player interacts during save → items duplicated).
  Auto-save uses tryLock() to skip players already being saved.
- C-5: NPE fix for non-RS2 items (null check on registry key lookup)
- C-6: RS2 .dat file written atomically (temp file + rename) to prevent
  corruption of entire RS2 storage on crash mid-write

HIGH fixes:
- H-3: Deadlock prevention: lock released BEFORE latch.await() in
  doPlayerJoin. Prevents shutdown deadlock where background thread
  holds lock while waiting for main thread, and shutdown holds main
  thread while waiting for lock.
- H-5: Curios cache now works WITHOUT keepInventory. Players who die
  then disconnect before respawning no longer lose curios data.
- H-8: server_id SQL uses PreparedStatements instead of string concat

MEDIUM fixes:
- M-1: NumberFormatException in LocalJsonUtil caught per-entry instead
  of crashing entire map parse (prevents losing all cosmetic armor)

Vyrriox
 2026-03-26 18:14:31 +01:00
laforetbrut
6c5807d3c8 Fix Sophisticated Storage shulkers, RS2 disks, and kick system 
1. Sophisticated Storage shulkers/barrels/chests:
   - ROOT CAUSE: UUID stored as DataComponent (not in CustomData).
     extractStorageUuid() only checked CustomData, missing the UUID.
   - FIX: Use StackStorageWrapper.fromStack(provider, item).getContentsUuid()
     which reads the DataComponent via the proper API.
   - Also scan ender chest for packed storage items.

2. Refined Storage 2 disks:
   - ROOT CAUSE: save() on StorageRepositoryImpl returned data in an
     unknown codec format that our extraction couldn't parse.
   - FIX: Read/write the .dat file directly from disk after forcing
     a save flush. This uses the exact NBT format RS2 writes.
   - Search multiple NBT structures (direct keys, nested compounds,
     list-of-pairs) to handle any codec format.
   - On restore: write entries into .dat file, clear DimensionDataStorage
     cache via reflection to force RS2 to reload.

3. Kick system:
   - ROOT CAUSE: PlayerNegotiationEvent.getConnection().disconnect()
     does NOT work in NeoForge 1.21.1 (too early in connection).
   - FIX: Full duplicate check moved to PlayerLoggedInEvent with
     HIGHEST priority. Uses player.connection.disconnect() which
     is reliable on the server thread.
   - Marks online=1 synchronously to close race condition.

Vyrriox
 2026-03-26 18:05:12 +01:00
laforetbrut
e907bcbfb0 Security audit: fix 7 critical/high issues from code review 
1. CRITICAL - Anti-dupe: Player inventory mutations now run on the main
   server thread via server.execute(). DB reads stay async, but all
   setItem/setHealth/addEffect calls happen on the tick thread.
   CountDownLatch ensures the lock is held until apply completes.

2. CRITICAL - Resource leaks: 3 QueryResults in PlayerSync.java startup
   now use try-with-resources + PreparedStatements instead of raw
   String.format SQL.

3. HIGH - Curios save: UPDATE changed to REPLACE INTO to prevent silent
   no-ops when the curios row doesn't exist yet (new player who died
   before first init save).

4. HIGH - RS2 restore: Removed skip-if-exists check. DB is always the
   source of truth - stale local data was persisting permanently.

5. HIGH - Race conditions: Shutdown save now acquires per-player lock.
   All logout saves (curios, mod-compat, inventory) moved inside
   doPlayerLogout under a single lock acquisition.

6. HIGH - SQL injection: DATABASE_NAME validated against [A-Za-z0-9_]+
   regex on startup to prevent injection via config.

Vyrriox
 2026-03-26 17:34:36 +01:00
laforetbrut
46689a360c Fix advancements disappearing on server transfer 
Minecraft only flushes PlayerAdvancements to disk during auto-save
(~every 5 min). If a player earns an advancement and switches servers
before the next auto-save, store() reads the stale file and the
advancement is lost in the DB.

Fix: call sp.getAdvancements().save() to force flush to disk before
reading the advancement file in store().

Vyrriox
 2026-03-26 17:24:18 +01:00
laforetbrut
a85131708f Fix NeoForge attachment sync, kick system, and backpack upgrades 
1. NeoForge attachments (SOL Onion, Ars Nouveau, etc.):
   - deserializeAttachments signature is (Provider, CompoundTag) not
     (CompoundTag) - reflection was failing silently, nothing restored
   - Use serializeAttachments(Provider) directly for saving instead of
     saveWithoutId() for cleaner approach
   - This fixes SOL Onion food diversity, Ars Nouveau mana/glyphs,
     Iron's Spellbooks, Pehkui scale, and all other NeoForge attachments

2. Multi-server kick:
   - Add secondary kick check in PlayerLoggedInEvent as fallback
   - Mark online=1 SYNCHRONOUSLY on login to close race condition
     where async doPlayerJoin hasn't set online=1 yet

3. Backpack upgrades:
   - Call refreshInventoryForInputOutput() before reading from
     BackpackStorage to flush pending wrapper changes

Vyrriox
 2026-03-26 17:22:21 +01:00
laforetbrut
fc7d81f914 Fix Sophisticated Storage shulkers/chests/barrels losing contents on transfer 
Root cause: Sophisticated Storage uses its own ItemContentsStorage
(SavedData) for packed items, NOT BackpackStorage from Sophisticated
Backpacks. The code was calling BackpackStorage which returned empty
data for storage items.

Fixes:
- Use ItemContentsStorage.get().getOrCreateStorageContents() for save
- Use ItemContentsStorage.get().setStorageContents() for restore
- Add extractStorageUuid() for "storageUuid" key (SS uses this, not
  "contentsUuid" which is for backpacks only)
- Try both UUID keys when scanning inventory items
- Add sophisticatedstorage as compileOnly dependency

Vyrriox
 2026-03-26 17:12:29 +01:00
laforetbrut
0c7026aa65 Fix stale effects persisting on server transfer 
Effects from the local server .dat file persisted when the player had
no effects saved in the DB. removeAllEffects() was only called inside
the if-block that checks for saved effect data, so it was skipped when
effectData was null/empty. Now effects are ALWAYS cleared before
restoring from DB.

SOL Onion food diversity is already synced via the generic NeoForge
attachment system (FoodPlayerData is a NeoForge attachment).

Vyrriox
 2026-03-26 15:11:38 +01:00
laforetbrut
2e0269ee62 Add Refined Storage 2 disk sync + Extra Disks support 
- Sync RS2 disk storage contents between servers (storageReference UUID)
- Support both refinedstorage and extradisks namespaces
- Save: extract individual entries from StorageRepository SavedData
- Restore: decode via RS2 codec and inject into target server repository
- Skip restore if storage already exists on target server (no overwrite)
- Scan inventory + ender chest for disks

Vyrriox
 2026-03-26 15:07:28 +01:00
laforetbrut
87d320c1f4 Fix excessive thread creation (issue #169) - bounded thread pool 
Replace unbounded CachedThreadPool with bounded ThreadPoolExecutor.

Problem: CachedThreadPool creates unlimited threads. With many players
online and slow DB queries, thread count explodes (25000+ threads
observed in issue #169), causing memory leaks and server crashes.

Fix: ThreadPoolExecutor with 2 core / 8 max threads, 30s keepalive,
256-task bounded queue, and CallerRunsPolicy for backpressure.
When the queue is full, tasks execute on the calling thread instead
of creating more threads, providing natural flow control.

Closes mlus-asuka/PlayerSync#169

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-03-26 11:51:09 +01:00
laforetbrut
f37e58be53 Add generic NeoForge attachment sync for full mod compatibility 
Adds a generic system that syncs ALL NeoForge player attachments,
covering per-player data from every mod in the modpack:

- Ars Nouveau: mana, glyph/spell knowledge
- Iron's Spellbooks: mana, learned spells, cooldowns
- Pehkui: player scale
- Spice of Life: Onion: food diversity history
- And ANY other mod using NeoForge's attachment system

Implementation:
- Save: extracts neoforge:attachments tag from player.saveWithoutId()
- Restore: uses reflection to call NeoForge's deserializeAttachments()
  which ensures exact same deserialization path as normal player load
- Stored as BNBT in mod_player_data table (mod_id=neoforge_attachments)

Also verified CosmeticArmours (mod id: cosmeticarmoursmod) and
CosmeticWeapons (mod id: cosmeticweaponsmod) are content-only mods
that add craftable items - no custom player storage, fully handled
by existing inventory sync.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-03-26 11:43:42 +01:00
laforetbrut
5576d7f7e2 Add anti-duplication locks, shutdown save, and security hardening 
- Per-player ReentrantLock prevents concurrent save/restore operations,
  eliminating race conditions that could cause item duplication
- Save ALL online players on ServerStoppingEvent (before disconnect) to
  prevent data loss from server shutdowns/restarts
- Lock acquired before restore on join, released in finally block
- Lock acquired before save on logout, cleaned up after completion
- Verified compatibility with 430-mod Arcadia V2 modpack:
  - All item DataComponents from all mods preserved via BNBT serialization
  - Curios items (Artifacts, Elytra Slot, Charm of Undying, etc.) synced
  - Accessories items (Aether, Deep Aether) synced
  - Server-specific data (FTB Quests/Chunks, Waystones, Lootr) correctly
    NOT synced as intended

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-03-26 11:39:44 +01:00
laforetbrut
c63d5849a3 Add mod compatibility: Accessories (Aether), Cosmetic Armor, Apotheosis 
- Add Accessories API sync for Aether mod accessory slots (pendant, cape,
  gloves, rings, shield, misc). Uses same pattern as Curios: validate data
  before clearing slots, PreparedStatements for DB operations
- Add Cosmetic Armor Reworked sync for 4 cosmetic armor slots via
  InventoryManager/CosArmorAPI
- Add Apotheosis + Placebo as compileOnly deps. Apotheosis item data
  (affixes, gems, sockets, rarity) travels with items via DataComponents
  and is already synced by the inventory sync
- New generic mod_player_data DB table with composite key (uuid, mod_id)
  for extensible mod-specific data storage
- Integrated save/restore in join, logout, and auto-save pipelines

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-03-26 11:21:09 +01:00
laforetbrut
03b57c3e6b Fix critical sync bugs, security, and add Sophisticated Storage support 
- Fix advancements disappearing: use PreparedStatements for all SQL with
  user data (advancement JSON contains chars that broke string-concat SQL),
  add null safety for advancement file
- Fix multi-server kick: run doPlayerConnect synchronously instead of async
  (players could join before the duplicate check completed)
- Fix Curios disappearing: clear slots AFTER validating data exists (not
  before), use CuriosCache for dead players on logout instead of empty API
- Fix Sophisticated Storage items: add storeSophisticatedStorageItems() and
  restoreSophisticatedStorageItems() to sync packed barrels/shulkers/chests
- Anti-duplication: clear all inventories before restoring from DB on join
- Fix tick counter: remove LevelTickEvent (fired per dimension = 3x too
  fast), merge heartbeat into ServerTickEvent
- Fix connection leaks: use try-with-resources for all QueryResult
- Fix logout order: save data BEFORE marking player offline
- Skip auto-save for dead/unsynced players to prevent saving empty data

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
 2026-03-26 11:04:00 +01:00
mlus
148ac4db9b Revert "fallback BNBT, Compat with codec" 
This reverts commit ce7004dba0.
 2026-02-24 10:24:13 +08:00
mlus
ce7004dba0 fallback BNBT, Compat with codec 2026-02-24 10:20:27 +08:00
mlus
201e63a322 Fix SQL syntax by adding backticks around database and table names 2026-02-24 00:11:06 +08:00
mlus
4b39d52c12 Add binary NBT serialization and deserialization support to improve data handling 2026-02-23 23:53:41 +08:00
mlus
b6da709393 curios snbt clean 2026-02-23 22:33:13 +08:00
mlus
bc71c59a45
Change pokedex column type to MEDIUMBLOB 2026-02-21 16:14:56 +08:00
mlus
d0044fa824 snbt structure clean 2026-02-17 19:08:34 +08:00
mlus
d8c3bac31f new nbt serializer 2026-02-17 15:41:45 +08:00
mlus
0c51ad8eb7 try to fix component parse error 2026-02-17 14:27:45 +08:00
mlus
d4a2568f16 fix crash with too many cobblemon in pc 2026-02-08 22:21:37 +08:00
mlus
38c88a95f9 fix #151 
fix #160
 2026-01-14 20:26:26 +08:00
mlus
e373b8c226 add cobblemon support(in test) 2025-12-15 22:47:47 +08:00
mlus
72d0255d48 fix advancements sync 2025-11-30 01:57:26 +08:00
mlus
90742aafa0 fix backpack didn't sync 2025-11-30 00:50:55 +08:00
mlus
733f37cbb3 supplement 2025-11-28 22:15:29 +08:00
mlus
29da0f28ad recently commit port 2025-11-28 21:00:25 +08:00
mlus
b5e5f9fb65 line 155 make method return so curios data won't save at the first time 2025-10-14 16:56:47 +08:00
mlus
260b24975c heartbeat 2025-10-14 16:56:25 +08:00
mlus
62b0cf15bc chat sync reconnect system 2025-10-14 16:55:24 +08:00
dependabot[bot]
f06e6a6632 Bump gradle/actions from 4 to 5 
Bumps [gradle/actions](https://github.com/gradle/actions) from 4 to 5.
- [Release notes](https://github.com/gradle/actions/releases)
- [Commits](https://github.com/gradle/actions/compare/v4...v5)

---
updated-dependencies:
- dependency-name: gradle/actions
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
 2025-10-14 16:55:21 +08:00
mlus
07709ad792 may fix #111 2025-09-25 23:03:17 +08:00
mlus
fc043e1e03 half done, noticed about advancement can't store normally 2025-06-07 00:55:30 +08:00
mlus
3b442fbee1 not done yet 2025-06-06 21:17:22 +08:00
mlus
79e0e2cbe4 Fix error when no player in server 2025-06-06 13:09:32 +08:00
mlus
0562b01138 Full tested ChatSync Feature 2025-06-05 12:43:41 +08:00
mlus
74451eecff
Merge pull request #65 from EoD/1.20.4-neoforge 
Add support for 1.20.4 using NeoForge 20.4.248
 2025-05-05 02:53:30 +08:00
EoD
22b628bdcb fix sophisticated backpack integration for 1.20.4 2025-05-04 18:43:11 +00:00
EoD
9eb8bdc4a0 add support for Minecraft 1.20.4 with ModDevGradle 2025-05-04 18:43:11 +00:00
EoD
bcb55c5a67 Revert "register JDBC driver to work around Forge bug" 
This reverts commit ce0e173a9e.
 2025-05-04 18:21:32 +00:00
32 changed files with 7540 additions and 970 deletions
Show Stats Expand all files Collapse all files

4
.github/workflows/build.yml vendored
View File

@ -19,7 +19,7 @@ jobs:
uses: actions/checkout@v4 uses: actions/checkout@v4
- name: Validate Gradle Wrapper - name: Validate Gradle Wrapper
uses: gradle/actions/wrapper-validation@v4 uses: gradle/actions/wrapper-validation@v5
- name: Set up JDK 17 - name: Set up JDK 17
uses: actions/setup-java@v4 uses: actions/setup-java@v4
@ -28,7 +28,7 @@ jobs:
distribution: 'temurin' distribution: 'temurin'
- name: Setup Gradle - name: Setup Gradle
uses: gradle/actions/setup-gradle@v4 uses: gradle/actions/setup-gradle@v5
- name: Build with Gradle - name: Build with Gradle
run: ./gradlew build run: ./gradlew build

18
.gitignore vendored
View File

@ -31,6 +31,20 @@ build
# other # other
eclipse eclipse
run run
runs
run-data
# Files from Forge MDK repo
forge*changelog.txt
# Claude Code
.claude/
CLAUDE.md
# BMad
.agent/
_bmad/
_bmad-output/
_bmb/
# compat mods (local jars for analysis)
compat-mods/*.jar

105
CHANGELOG.md Normal file
View File

@ -0,0 +1,105 @@
# Changelog
All notable changes to **PlayerSync** are documented here.
---
## [2.1.5] - 2026-04-22 (cont.)
### Added (Phase 8: configs + admin commands)
- **Structured config sections** — `connection`, `general`, `save_triggers`, `sync_toggles`, `performance`, `safety`, `observability`. Old keys still accepted thanks to NeoForge's lenient loader.
- **Sync toggles** — `sync_inventory`, `sync_ender_chest`, `sync_xp`, `sync_effects`, `sync_health_food`, `sync_curios`, `sync_accessories`, `sync_backpacks`, `sync_cosmetic_armor`, `sync_refined_storage`. All default true. Wired as restore-side guards in each mod-compat path.
- **Save triggers** — `save_on_death` (default true), `save_on_respawn` (default true). `save_on_dimension_change` kept from Phase 4.
- **Perf configs** — `heartbeat_interval_seconds` (default 30), `peer_stale_threshold_seconds` (default 60), `join_poll_max_attempts` (default 120), `join_poll_interval_ms` (default 500), `pool_stats_interval_minutes` (default 5, 0 to disable), `hikari_pool_max_size` (default 15), `hikari_leak_threshold_ms` (default 25000).
- **Safety configs** — `refuse_empty_inventory_write` (default true) now enforced inside `writeSnapshotToDB`: if the snapshot inventory is empty/tiny AND the DB row currently has real data, the write is refused and logged as `DATA_LOSS`. `max_inventory_size_bytes` (default 10 MB) rejects oversized snapshots. `skip_saves_when_tps_below` placeholder for future use. `kick_message`, `kick_grace_period_ms`.
- **Observability configs** — `log_structured_json` (future), `log_rotation_size_mb`, `log_rotation_max_files`.
- **Admin commands — `/playersync`** — full toolkit for diagnosis and maintenance:
- `status` — server id, heartbeat age, executor + Hikari pool snapshot, online count
- `poolstats` — immediate log of current pool stats
- `flush [player]` — force save of all online players or a specific one
- `info <player>` — DB row metadata (last_server, online flag, data sizes)
- `dump <player>` — full DB row dump into server log
- `resync <player>` — clear player_synced tag and kick to force fresh restore
- `wipe <player> confirm` — DANGER: DELETE all rows for a player
- `orphans` — list online=1 rows whose peer is dead/stale
- `clearorphans [server_id]` — clear orphaned online flags
- `peers` — list all peer servers with their heartbeat age and ALIVE/STALE/STOPPED tag
- `peerkill <server_id>` — force-disable a zombie peer
- `cleanup` — one-shot orphans + stale peers cleanup
- `reload` — status note about runtime config reload
- `help` — in-chat command reference
- All commands require permission level 2 (op) and log to `SyncLogger` as `ADMIN_*` events for audit trail.
### Changed
- `JDBCsetUp.executePreparedUpdate` now delegates to `executePreparedUpdateRet` which returns rows affected. Existing callers unchanged; admin commands use the ret version for meaningful counts.
- `HeartbeatService` + `PoolStatsReporter` + `doPlayerJoin` poll all read their interval/threshold from the new config keys instead of hardcoded constants.
### Ajouts (French mirror — Phase 8)
- **Sections config structurées** — `connection`, `general`, `save_triggers`, `sync_toggles`, `performance`, `safety`, `observability`.
- **Toggles de sync** — 10 clés pour activer/désactiver la sync par catégorie.
- **Triggers de sauvegarde** — `save_on_death`, `save_on_respawn`, `save_on_dimension_change`.
- **Configs perf** — intervalles heartbeat/poll/pool-stats/hikari, seuils peer-stale.
- **Configs sécurité** — `refuse_empty_inventory_write` (enforce-wipe protection), `max_inventory_size_bytes` (anti-bloat), `kick_message`, `kick_grace_period_ms`.
- **Commandes admin `/playersync`** — 14 commandes pour diagnostic et maintenance (status, flush, info, dump, resync, wipe, orphans, clearorphans, peers, peerkill, cleanup, poolstats, reload, help).
- Toutes les commandes requièrent permission op (niveau 2) et logguent dans `SyncLogger` pour traçabilité.
---
## [2.1.5] - 2026-04-22
### Fixed (English first)
- **Critical item duplication on drop + quick disconnect + reconnect** — Race condition between the auto-save background task and the logout background task could commit a stale snapshot AFTER the logout save, resurrecting dropped items. Triple guard now applied: `pendingLogoutSaves` check (early + under lock) and `SELECT online FROM player_data` skip if logout already committed. Logout BG now acquires `bgLock` with blocking `.lock()` for proper serialization.
- **Backpack / Sophisticated Storage merge-on-restore duplication** — `setBackpackContents` / `setStorageContents` upstream are shallow merges, not replaces. Restore now calls `removeBackpackContents` / `removeStorageContents` (with reflection fallback if absent) AND passes a defensive NBT copy. Fixes mass-duplication of items in backpacks/shulkers on every cross-server transfer.
- **Cross-server save overwrite** — When `writeSnapshotToDB`'s `last_server` guard blocked the core player_data UPDATE, the downstream backpack/SS/RS2 saves still executed and overwrote the claiming server's data. The function now returns a boolean; all 5 callers short-circuit downstream writes on guard block.
- **30-second join delay on zombie peer servers** — `doPlayerJoin` poll waited the full 60 attempts (30s) for server_ids that no longer existed (legacy `server_id=0` rows, or peers that crashed without clearing `online=0`). New `isPeerServerStale` check (peer_id=0 OR heartbeat >60s) takes over immediately and force-clears the orphaned flag. Poll max raised from 60 to 120 attempts (60s) for legitimate slow shutdowns.
- **Curios wipe on dead player** — Legacy `StoreCurios` wrote an empty flatMap when the Curios capability was unavailable, wiping DB data. Now early-returns with a WARN log.
### Added
- **JVM shutdown hook (kill -9 / OOM / SIGTERM recovery)** — New `CrashRecovery.installShutdownHook` registers a non-daemon hook that calls `VanillaSync.emergencyFlushAll` synchronously to snapshot and write every online player before process exit. Marks `server_info.enable=0` so peers detect the shutdown.
- **Startup orphan-flag recovery** — `CrashRecovery.clearOrphanedOnlineFlags` runs at `onServerStarting` to clear any `player_data.online=1` rows left by a previous ungraceful exit. Logs the count via `SyncLogger`.
- **Zombie-peer reporter** — `CrashRecovery.reportZombiePeers` logs peer `server_id`s whose heartbeat is stale or missing at boot time.
- **Server heartbeat service** — `HeartbeatService` pings `server_info.last_update` every 10 seconds so peer servers can distinguish live from dead via the new `isPeerServerStale` check.
- **Periodic full-save scheduler** — `PeriodicSaveService` triggers a complete save (player data + backpacks + SS + RS2) for every online synced player every `auto_save_interval_minutes` (new config, default 10, range 0-1440). Independent of NeoForge's vanilla `PlayerEvent.SaveToFile` cadence.
- **Dimension-change save trigger** — New `onPlayerChangeDimension` handler, gated by `save_on_dimension_change` config (default false). Protects against mid-teleport crashes.
- **Executor + HikariCP pool stats reporter** — `PoolStatsReporter` logs `[POOL] executor active/queue/idle, hikari active/idle` every 5 minutes. WARN thresholds trigger when queue >400/512 or Hikari active >=14/15.
- **Structured logging events** — `SyncLogger` gained `containerForceClosed`, `modCompatSkip`, `modCompatSaved`, `modCompatRestored`, `storageSave`, `poolStats`, `warnPlayer`, `nbtAnomaly` for finer-grained diagnostics.
### Changed
- **`writeSnapshotToDB` signature** — Now returns `boolean` instead of `void`. `true` means the core UPDATE persisted, `false` means the `last_server` guard blocked. All callers MUST check the return before firing downstream backpack/SS/RS2 writes.
- **Default `auto_save_interval_minutes`** — 10 min (new config key). Trades data-loss window on crash for DB load. Set to 0 to disable.
- **Backpack / SS restore** — Now uses two-step clear (public API + reflection fallback) and defensive NBT copy before upstream setter. Full log line per restore with `cleared_via=api|reflection` and `nbt_keys=N`.
---
### Correctifs (French mirror)
- **Duplication d'items critique lors d'un drop + déconnexion rapide + reconnexion** — Race condition entre la task auto-save background et la task logout background pouvait commiter un snapshot périmé APRÈS le save logout, ressuscitant les items drop. Triple garde maintenant appliquée : check `pendingLogoutSaves` (early + sous lock) et skip via `SELECT online FROM player_data` si le logout a déjà commité. La task logout BG acquiert maintenant `bgLock` en blocking `.lock()` pour sérialiser proprement.
- **Duplication Backpack / Sophisticated Storage par merge au restore** — `setBackpackContents` / `setStorageContents` en amont sont des merges shallow, pas des replaces. Le restore appelle maintenant `removeBackpackContents` / `removeStorageContents` (avec fallback reflection si absent) ET passe une copie défensive du NBT. Corrige la duplication massive d'items dans les backpacks/shulkers à chaque transfert cross-server.
- **Écrasement cross-server des saves** — Quand le guard `last_server` de `writeSnapshotToDB` bloquait l'UPDATE core player_data, les saves downstream backpack/SS/RS2 s'exécutaient quand même et écrasaient les données du serveur ayant claim. La fonction retourne maintenant un boolean ; les 5 callers court-circuitent les writes downstream en cas de guard block.
- **Délai de 30 secondes à la connexion sur serveurs zombies** — Le poll `doPlayerJoin` attendait les 60 tentatives (30s) pour des `server_id` n'existant plus (lignes legacy `server_id=0`, ou peers ayant crashé sans clear `online=0`). Nouveau check `isPeerServerStale` (peer_id=0 OU heartbeat >60s) prend la main immédiatement et force-clear le flag orphelin. Poll max passé de 60 à 120 tentatives (60s) pour couvrir les shutdowns lents légitimes.
- **Wipe Curios sur joueur mort** — La méthode legacy `StoreCurios` écrivait un flatMap vide quand la capability Curios était absente, wipant les données DB. Elle early-return maintenant avec un log WARN.
### Ajouts (French mirror)
- **Hook JVM shutdown (kill -9 / OOM / SIGTERM recovery)** — Nouveau `CrashRecovery.installShutdownHook` enregistre un hook non-daemon qui appelle `VanillaSync.emergencyFlushAll` synchronement pour snapshot et écrire chaque joueur online avant la fin du process. Marque `server_info.enable=0` pour que les peers détectent le shutdown.
- **Recovery des flags orphelins au boot** — `CrashRecovery.clearOrphanedOnlineFlags` tourne au `onServerStarting` pour clear les rows `player_data.online=1` laissées par une sortie ungracieuse précédente. Log le compte via `SyncLogger`.
- **Reporter de peers zombies** — `CrashRecovery.reportZombiePeers` log les `server_id` peers dont le heartbeat est stale ou absent au boot.
- **Service heartbeat** — `HeartbeatService` ping `server_info.last_update` toutes les 10 secondes pour que les peers distinguent live vs dead via le nouveau check `isPeerServerStale`.
- **Scheduler de sauvegarde périodique** — `PeriodicSaveService` déclenche une save complète (player data + backpacks + SS + RS2) pour chaque joueur online synced toutes les `auto_save_interval_minutes` (nouvelle config, défaut 10, plage 0-1440). Indépendant de la cadence vanilla `PlayerEvent.SaveToFile` de NeoForge.
- **Trigger save sur changement de dimension** — Nouveau handler `onPlayerChangeDimension`, gated par la config `save_on_dimension_change` (défaut false). Protège contre les crashes en plein téléport.
- **Reporter stats executor + HikariCP** — `PoolStatsReporter` log `[POOL] executor active/queue/idle, hikari active/idle` toutes les 5 min. Seuils WARN quand queue >400/512 ou Hikari active >=14/15.
- **Événements structurés** — `SyncLogger` a gagné `containerForceClosed`, `modCompatSkip`, `modCompatSaved`, `modCompatRestored`, `storageSave`, `poolStats`, `warnPlayer`, `nbtAnomaly` pour un diagnostic plus fin.
### Modifications
- **Signature `writeSnapshotToDB`** — Retourne maintenant `boolean` au lieu de `void`. `true` = l'UPDATE core a persisté, `false` = le guard `last_server` a bloqué. Tous les callers DOIVENT vérifier le retour avant de déclencher les writes downstream backpack/SS/RS2.
- **Défaut `auto_save_interval_minutes`** — 10 min (nouvelle clé config). Trade-off entre fenêtre de perte de données sur crash et charge DB. 0 pour désactiver.
- **Restore Backpack / SS** — Utilise maintenant un clear en deux étapes (API publique + fallback reflection) et une copie défensive NBT avant le setter upstream. Log complet par restore avec `cleared_via=api|reflection` et `nbt_keys=N`.
---

141
ERROR_LOG.md Normal file
View File

@ -0,0 +1,141 @@
# PlayerSync — Error Log
Journal des erreurs rencontrées et corrigées. Chaque entrée documente un bug, sa cause racine, son correctif et la règle de prévention à appliquer systématiquement.
---
## [2026-04-22 02:54] — Item duplication on drop + quick disconnect + reconnect
**Context** : Un joueur drop un item au sol, se déconnecte très rapidement, puis se reconnecte → l'item est présent deux fois (en inventory restauré + encore au sol).
**Error** : Duplication systématique reproductible en production.
**Root cause** : Race condition entre `onPlayerSaveToFile` background task (auto-save périodique) et `onPlayerLogout` background task.
1. `SaveToFile` capture un snapshot sur main thread AVANT le drop (item encore en inventory) → task async soumise.
2. Le joueur drop l'item → inventory vide, ItemEntity dans le monde.
3. Le joueur disconnect → logout capture un snapshot FRESH (sans item), soumet le write.
4. Les deux BG tasks s'exécutent en parallèle. Si la task auto-save (qui portait une snapshot STALE avec l'item) commit APRÈS la task logout (qui portait FRESH sans l'item), la DB finit en STALE.
5. Reconnexion → inventory restauré avec l'item + ItemEntity toujours au sol → 2 copies.
**Fix** (commit `bea5f80`) : Triple guard dans l'auto-save BG task :
- Early skip si `pendingLogoutSaves.containsKey(uuid)` avant tryLock.
- Re-check sous lock après tryLock (race window fermée).
- `SELECT online FROM player_data WHERE uuid=?` — skip si online=0 (logout a committé).
Logout BG task acquiert maintenant `bgLock.lock()` (blocking) pour sérialiser proprement avec les auto-save BG qui utilisent `tryLock`. `removePlayerLock` réordonné avant `bgLock.unlock()` pour que les auto-save BG qui wake après unlock voient `containsKey=false` et skip.
**Prevention** : **JAMAIS de BG task qui modifie la DB sans un guard `online=0` + `pendingLogoutSaves` check**. Si deux paths peuvent écrire le même row, ils DOIVENT partager un lock blocking OU le path "fresh" doit être détectable via DB state (online flag, version column).
---
## [2026-04-22 03:15] — Backpack duplication on cross-server transfer
**Context** : Un joueur utilise un backpack Sophisticated Backpacks sur Server A, change de serveur, et constate que le contenu du backpack est dupliqué.
**Error** : Duplication systématique d'items dans les backpacks et shulkers Sophisticated Storage lors de transferts cross-server ou reconnexions.
**Root cause** : `BackpackStorage.setBackpackContents()` et `ItemContentsStorage.setStorageContents()` en amont sont des **merges shallow**, pas des replaces. Quand le restore applique le snapshot sauvegardé, il MERGE avec les contents existants en mémoire (SavedData persistée sur disk localement ou vue ouverte par un autre joueur). Les sous-tags "items" survivent → duplication.
**Fix** (commit `c84f920`) :
- Backpack : appel `store.removeBackpackContents(uuid)` EXPLICITE avant `setBackpackContents`. Si l'API throw (absent dans certaines versions), fallback reflection qui parcourt les champs `Map` de `BackpackStorage` et remove l'entrée directement.
- SS : nouveau helper `clearSSStorageContents` qui tente `removeStorageContents(UUID)` via reflection, puis fallback reflection sur champs Map. `setDirty()` appelé pour forcer le flush.
- Les deux paths passent maintenant une **copie défensive** (`nbt.copy()`) à l'upstream setter, jamais la référence partagée.
**Prevention** :
- **Toujours clear avant restore pour toute structure qui merge au lieu de replace** (backpack, SS, RS2 disks).
- **Toujours passer une copie défensive** d'un CompoundTag à un setter qui peut la stocker en interne.
- **Logger `clear_via=api/reflection`** pour diagnostiquer les régressions upstream.
---
## [2026-04-22 03:20] — Cross-server saves can overwrite claimed data
**Context** : Deux serveurs sauvent un même joueur simultanément (edge case lors de changements de serveurs rapides).
**Error** : Les données de l'un écrasent silencieusement les données de l'autre. Backpack/SS/RS2 perdus.
**Root cause** : `writeSnapshotToDB` retournait `void`. Même si son guard `last_server=?` bloquait le write du core player_data (rows affected = 0), les appels downstream `saveBackpackSnapshots` / `saveSSSnapshots` / `saveRS2DisksByLevel` s'exécutaient INCONDITIONNELLEMENT et écrasaient `backpack_data` (qui n'a pas de guard propre — keyé par storage UUID, pas player UUID).
**Fix** (commit `c84f920`) : `writeSnapshotToDB` retourne maintenant `boolean`. Les 5 callers (logout, shutdown, auto-save SaveToFile, staggered auto-save, death-save) vérifient le retour et **short-circuitent** les writes downstream si le core a été blocké.
**Prevention** : **Une fonction qui a un guard silencieux DOIT signaler son résultat au caller**. Ne jamais supposer que les writes downstream sont implicitement protégés par un guard en amont — vérifier explicitement.
---
## [2026-04-22 03:25] — 30s delay on player join (RACE timeout 60/60)
**Context** : À chaque connexion, log flood `Waiting for server X to finish saving (attempt 60/60)` et le joueur attend 30s avant de récupérer ses données.
**Error** : Poll timeout systématique sur des server_ids qui n'existent plus ou sur un server_id=0.
**Root cause** :
- Le poll `doPlayerJoin` attend que l'autre serveur clear `online=0`. Si l'autre serveur a crashé sans le faire (pas de shutdown hook), le poll attend jusqu'à épuisement des 60 tentatives.
- `server_id=0` est une ligne orpheline héritée d'une écriture legacy (avant que le default `Random().nextInt(1, MAX-1)` soit appliqué).
**Fix** (commit `c84f920`) :
- Nouvelle méthode `isPeerServerStale(peerId, staleMs)` qui check `server_info.last_update`. Si l'heartbeat est vieux de >60s OU si `peerId == 0`, le poll considère le serveur comme zombie et force-clear `online=0`.
- Poll max passé de 60 à 120 tentatives (60s total) pour couvrir les shutdowns lents.
- Phase 3 : `HeartbeatService` tick toutes les 10s → permet aux peers de détecter les zombies.
- Phase 3 : `CrashRecovery.clearOrphanedOnlineFlags()` au boot → nettoie les rows stuck à online=1 après un crash ungracieux.
**Prevention** : **Tout état "en cours" en DB doit avoir un heartbeat OU un timeout**. Un flag `online=1` sans heartbeat est un bug en attendant de se produire (le process qui l'a set peut crasher).
---
## [2026-04-22 03:30] — StoreCurios NPE / data wipe on dead player
**Context** : Un joueur meurt puis se déconnecte rapidement. Son curios sont vidés de la DB.
**Error** : Méthode legacy `StoreCurios` écrivait un flatMap vide quand `CuriosApi.getCuriosInventory(player)` retournait un `Optional.empty()` (capability détachée après death).
**Root cause** : La méthode utilisait `handlerOpt.ifPresent(...)` mais fallait au `REPLACE INTO` même si le flatMap était vide → wipe DB data pour un joueur mort.
**Fix** (commit `c84f920`) : Early return avec log `WARN [store-curios] handler unavailable for UUID — skipping write to avoid wiping DB data` si `handlerOpt.isEmpty()`.
**Prevention** : **Ne JAMAIS écrire un état "vide" dans la DB si la source est incertaine**. Une capability absente ≠ joueur sans curios — c'est un état indéterminé. Skip write + log.
---
## [2026-04-22 03:40] — Player data loss on kill -9 / OOM
**Context** : Process serveur tué via `kill -9` ou OOM — au redémarrage, les joueurs qui étaient online ne récupèrent pas leurs données des dernières minutes.
**Error** : `ServerStoppingEvent` n'est pas déclenché lors d'un kill ungracieux, donc aucune save n'est exécutée. Les rows `player_data` restent aussi à `online=1` → le poll de doPlayerJoin sur un autre serveur attend 30s pour rien.
**Fix** (commit `746cb56`, Phase 3) :
- `CrashRecovery.installShutdownHook(() -> emergencyFlushAll())` — JVM hook non-daemon enregistré au boot. Appelle une méthode synchrone qui snapshot et write tous les joueurs online sans passer par l'executor (qui peut être déjà mort).
- Marque `server_info.enable=0` à la sortie pour notifier les peers.
- `CrashRecovery.clearOrphanedOnlineFlags()` au boot suivant — clear les rows stuck et log le nombre via SyncLogger.
- `HeartbeatService` tick toutes les 10s pendant le run — permet aux peers de détecter la mort.
**Prevention** :
- **Tout process long-running doit avoir un JVM shutdown hook** pour couvrir SIGTERM / kill doux / OOM soft.
- **Tout flag "en cours" persistant doit avoir un recovery path au boot suivant**.
- **Un heartbeat périodique est obligatoire** si d'autres processus dépendent de savoir si on est alive.
---
## [2026-04-22 03:50] — Inventory loss window of 30 min between auto-saves
**Context** : Les auto-saves ne se déclenchaient que lors des PlayerEvent.SaveToFile natifs (cadence vanilla = autosave world, typiquement 6000 ticks). Si un crash survenait entre deux saves, jusqu'à 15+ minutes de jeu étaient perdus.
**Fix** (commit `c70ca9f`, Phase 4) :
- `PeriodicSaveService` — scheduler indépendant qui déclenche un full-flush toutes les `auto_save_interval_minutes` (défaut 10). Hops au main thread pour snapshotter, puis soumet les writes async via `snapshotAndQueueSave`.
- `onPlayerChangeDimension` — trigger additionnel gated par `save_on_dimension_change` (défaut false). Sauve avant teleport cross-dimension.
**Prevention** : **Ne jamais dépendre uniquement des events du framework** pour déclencher une sauvegarde critique. Doubler avec un scheduler indépendant et rendre l'intervalle configurable.
---
## [2026-04-22 04:00] — Executor queue saturation invisible
**Context** : Sous charge (35+ joueurs), l'executor `PlayerSync` peut saturer (queue >400) et déclencher `CallerRunsPolicy` qui bloque le main thread. Aucune alerte dans les logs.
**Fix** (commit `bd0482c`, Phase 5) :
- `PoolStatsReporter` — scheduler dédié 5-min qui log `[POOL] executor active/queue/idle, hikari active/idle`.
- WARN log si queue > 400/512 ou hikari active >= 14/15.
- Accesseur `JDBCsetUp.getPoolMXBean()` pour exposer Hikari en read-only.
**Prevention** : **Tout pool/queue critique doit être monitoré périodiquement** avec des seuils d'alerte sous la capacité max. Invisible ≠ sain.
---

523
TEST_PROCEDURE_v2.1.5.html Normal file
View File

@ -0,0 +1,523 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Test Procedure — PlayerSync v2.1.5</title>
<style>
body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; max-width: 1100px; margin: 2em auto; padding: 0 1em; color: #222; line-height: 1.55; }
h1 { border-bottom: 3px solid #007acc; padding-bottom: 0.3em; }
h2 { color: #007acc; margin-top: 1.8em; border-bottom: 1px solid #ddd; padding-bottom: 0.2em; }
h3 { color: #333; margin-top: 1.3em; }
.scenario { background: #f6f8fa; border-left: 4px solid #007acc; padding: 1em 1.2em; margin: 1em 0; border-radius: 4px; }
.scenario.critical { border-left-color: #d73a49; }
.scenario.high { border-left-color: #f0983a; }
.meta { font-size: 0.9em; color: #666; margin-bottom: 0.5em; }
.steps, .expected { margin: 0.5em 0; }
.steps li, .expected li { margin: 0.25em 0; }
code { background: #eef1f4; padding: 0.1em 0.4em; border-radius: 3px; font-size: 0.92em; }
.lang-sep { margin: 4em 0 2em; border-top: 2px dashed #999; padding-top: 2em; }
.checkbox { margin-right: 0.5em; }
.tag { display: inline-block; padding: 0.1em 0.5em; border-radius: 3px; font-size: 0.8em; font-weight: bold; color: white; }
.tag-critical { background: #d73a49; }
.tag-high { background: #f0983a; }
.tag-medium { background: #6f42c1; }
.regression { background: #fff5f5; border: 1px solid #feb2b2; padding: 1em; border-radius: 4px; margin-top: 2em; }
table { border-collapse: collapse; width: 100%; margin: 1em 0; }
th, td { border: 1px solid #ddd; padding: 0.5em 0.8em; text-align: left; }
th { background: #007acc; color: white; }
</style>
</head>
<body>
<h1>Test Procedure — PlayerSync v2.1.5</h1>
<div class="meta">Date : <strong>2026-04-22</strong> &nbsp;|&nbsp; Branch: <code>1.21.1-dev</code> &nbsp;|&nbsp; Minecraft 1.21.1 / NeoForge 21.1.137 / Java 21</div>
<h2>Setup</h2>
<ol>
<li>Démarrer MariaDB dev : <code>docker compose up -d</code></li>
<li>Build : <code>./gradlew build</code> — le JAR apparaît dans <code>build/libs/playersync-1.21.1-2.1.5.jar</code></li>
<li>Deux instances serveur nécessaires : <code>./gradlew runServer</code> (Server A) + copie avec <code>Server_id</code> différent dans <code>run-2/config/playersync-common.toml</code> (Server B)</li>
<li>Adminer : <code>http://localhost:8080</code> (login <code>playersync</code>/<code>playersync</code>)</li>
<li>Monitorer en continu : <code>tail -f run/logs/playersync/sync.log</code></li>
</ol>
<h2>Scenarios to test</h2>
<div class="scenario critical">
<span class="tag tag-critical">CRITICAL</span>
<h3>1. Drop + deco rapide + reco (regression Phase 0)</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Server A, fill inventory with a diamond sword</li>
<li><input type="checkbox" class="checkbox"> Drop the sword with Q</li>
<li><input type="checkbox" class="checkbox"> Immediately disconnect (within 1 second)</li>
<li><input type="checkbox" class="checkbox"> Rejoin Server A</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>Inventory does NOT contain the sword</li>
<li>The ItemEntity is still on the ground where dropped</li>
<li>Player has exactly 1 copy of the sword total</li>
<li>Log shows <code>[SAVE] LOGOUT completed</code> then either no SaveToFile BG write or a <code>[GUARD] SaveToFile BG skipped — player already offline in DB</code></li>
</ul>
</div>
</div>
<div class="scenario critical">
<span class="tag tag-critical">CRITICAL</span>
<h3>2. Backpack duplication (Sophisticated Backpacks)</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Server A, craft a SophisticatedBackpack, fill with 10 diamond blocks</li>
<li><input type="checkbox" class="checkbox"> Disconnect</li>
<li><input type="checkbox" class="checkbox"> Join Server B (configure different Server_id)</li>
<li><input type="checkbox" class="checkbox"> Open backpack, count diamond blocks</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>Exactly 10 diamond blocks (no duplication)</li>
<li>Log shows <code>[restore-backpack] uuid=... nbt_keys=... cleared_via=api</code> (or <code>reflection</code> as fallback)</li>
<li>No WARN about failed removeBackpackContents</li>
</ul>
</div>
</div>
<div class="scenario critical">
<span class="tag tag-critical">CRITICAL</span>
<h3>3. Sophisticated Storage shulker duplication</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Server A, pack a diamond-filled shulker into your inventory</li>
<li><input type="checkbox" class="checkbox"> Have Player B (on same server) open your inventory via admin / trade / viewer</li>
<li><input type="checkbox" class="checkbox"> Disconnect Player A</li>
<li><input type="checkbox" class="checkbox"> Player A reconnects to Server B</li>
<li><input type="checkbox" class="checkbox"> Unpack shulker, count diamonds</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>Exactly original diamond count</li>
<li>Log shows <code>[CONTAINER_CLOSE]</code> for Player B (viewer forced closed)</li>
<li>Log shows <code>[restore-ss] uuid=... nbt_keys=...</code></li>
</ul>
</div>
</div>
<div class="scenario critical">
<span class="tag tag-critical">CRITICAL</span>
<h3>4. Kill -9 / OOM recovery</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Server A, set inventory to known state (put a named diamond)</li>
<li><input type="checkbox" class="checkbox"> Find server java PID : <code>jps | grep Forge</code></li>
<li><input type="checkbox" class="checkbox"> Kill brutally : <code>kill -9 &lt;pid&gt;</code> (or Task Manager → End Task on Windows)</li>
<li><input type="checkbox" class="checkbox"> Restart server A</li>
<li><input type="checkbox" class="checkbox"> Join Server A, check inventory</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>On startup log: <code>[crash-recovery] cleared N orphan online=1 rows</code></li>
<li>On startup log: <code>[crash-recovery] JVM shutdown hook installed</code> AND ideally (if hook ran): <code>[emergency-flush] flushed N players</code></li>
<li>Inventory matches last state before kill (within ~10 min auto-save window)</li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>5. Zombie peer server join (no 30s wait)</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> In Adminer, manually set <code>player_data.last_server=99999</code> and <code>online=1</code> for a test UUID</li>
<li><input type="checkbox" class="checkbox"> Join any running server with that UUID</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>Join happens within a few seconds (not 30s)</li>
<li>Log shows <code>[RACE] Peer server 99999 is dead/zombie — taking over</code></li>
<li>DB now shows <code>last_server=&lt;thisServer&gt;</code>, <code>online=1</code></li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>6. Periodic auto-save (10 min)</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Set <code>auto_save_interval_minutes=1</code> in config for quick test</li>
<li><input type="checkbox" class="checkbox"> Join server, add items to inventory</li>
<li><input type="checkbox" class="checkbox"> Wait 1 minute (watch sync.log)</li>
<li><input type="checkbox" class="checkbox"> Kill -9 server</li>
<li><input type="checkbox" class="checkbox"> Restart, rejoin, check inventory</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>Log shows <code>[periodic-save] queued snapshots for N player(s)</code> after 1 min</li>
<li>Post-crash inventory reflects the state AT the last periodic tick</li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>7. Pool saturation WARN log</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Wait 5 minutes after server start (for first PoolStatsReporter tick)</li>
<li><input type="checkbox" class="checkbox"> Grep sync.log for <code>[POOL]</code></li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>At least one line like <code>[POOL] executor active=0 queue=0 pool_idle=4 | hikari active=0 idle=4</code></li>
<li>No WARN unless under load</li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>8. Heartbeat updates server_info</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> In Adminer, watch <code>server_info.last_update</code> for this server's id</li>
<li><input type="checkbox" class="checkbox"> Refresh every 20s for 1 minute</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li><code>last_update</code> advances by ~10000 ms at every refresh</li>
<li>Log shows <code>[heartbeat] started</code> on boot</li>
</ul>
</div>
</div>
<div class="scenario">
<span class="tag tag-medium">MEDIUM</span>
<h3>9. Curios capability unavailable — no wipe</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Equip curios items, die in lava</li>
<li><input type="checkbox" class="checkbox"> Force-disconnect during death animation</li>
<li><input type="checkbox" class="checkbox"> Reconnect</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>If cap was unavailable: log shows <code>[store-curios] handler unavailable for ... skipping write</code></li>
<li>Curios row in DB NOT wiped</li>
</ul>
</div>
</div>
<div class="scenario">
<span class="tag tag-medium">MEDIUM</span>
<h3>10. Cross-server claim + downstream short-circuit</h3>
<div class="steps">
<strong>Steps:</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Player connected on Server A</li>
<li><input type="checkbox" class="checkbox"> Disconnect then immediately join Server B (within 200ms)</li>
<li><input type="checkbox" class="checkbox"> Check sync.log on Server A</li>
</ol>
</div>
<div class="expected">
<strong>Expected:</strong>
<ul>
<li>Server A may log <code>[GUARD]</code> (last_server guard blocked) if B claimed during A's save</li>
<li>If blocked: <code>[SAVE_SKIP] LOGOUT skipped: core guard blocked</code></li>
<li>Player inventory on B = inventory as it was on A (no merge, no overwrite)</li>
</ul>
</div>
</div>
<h2>Regression checks</h2>
<div class="regression">
<strong>Watch for these regressions after Phase 0-5 deployment:</strong>
<ul>
<li>TPS drop during auto-save ticks (periodic save at 10 min should be invisible to gameplay)</li>
<li>HikariCP leak warnings — <code>leakDetectionThreshold=25000</code>, warnings mean a connection held &gt;25s</li>
<li>CallerRunsPolicy triggering (queue full) — look for WARN <code>[pool-stats] executor queue high</code></li>
<li>Deadlock on logout → join (bgLock serialization) — log should show <code>[SAVE] LOGOUT completed</code> within ~500ms</li>
<li>Reflection fallback firing repeatedly — means upstream removeBackpackContents / removeStorageContents API broke</li>
</ul>
</div>
<div class="lang-sep"></div>
<!-- ================================================================ -->
<!-- FRENCH VERSION -->
<!-- ================================================================ -->
<h1>Procédure de Test — PlayerSync v2.1.5 (Version Française)</h1>
<div class="meta">Date : <strong>2026-04-22</strong> &nbsp;|&nbsp; Branche : <code>1.21.1-dev</code> &nbsp;|&nbsp; Minecraft 1.21.1 / NeoForge 21.1.137 / Java 21</div>
<h2>Mise en place</h2>
<ol>
<li>Démarrer MariaDB dev : <code>docker compose up -d</code></li>
<li>Build : <code>./gradlew build</code> — le JAR sort dans <code>build/libs/playersync-1.21.1-2.1.5.jar</code></li>
<li>Deux instances serveur nécessaires : <code>./gradlew runServer</code> (Serveur A) + copie avec <code>Server_id</code> différent dans <code>run-2/config/playersync-common.toml</code> (Serveur B)</li>
<li>Adminer : <code>http://localhost:8080</code> (login <code>playersync</code>/<code>playersync</code>)</li>
<li>Monitorer en continu : <code>tail -f run/logs/playersync/sync.log</code></li>
</ol>
<h2>Scénarios à tester</h2>
<div class="scenario critical">
<span class="tag tag-critical">CRITIQUE</span>
<h3>1. Drop + déco rapide + reco (régression Phase 0)</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Serveur A, remplir l'inventaire avec une épée de diamant</li>
<li><input type="checkbox" class="checkbox"> Drop l'épée avec Q</li>
<li><input type="checkbox" class="checkbox"> Déconnecter immédiatement (moins d'une seconde)</li>
<li><input type="checkbox" class="checkbox"> Rejoin Serveur A</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>L'inventaire ne contient PAS l'épée</li>
<li>L'ItemEntity est toujours au sol où elle a été drop</li>
<li>Le joueur a exactement 1 copie de l'épée au total</li>
<li>Logs : <code>[SAVE] LOGOUT completed</code> puis soit aucun write SaveToFile BG, soit <code>[GUARD] SaveToFile BG skipped — player already offline in DB</code></li>
</ul>
</div>
</div>
<div class="scenario critical">
<span class="tag tag-critical">CRITIQUE</span>
<h3>2. Duplication Backpack (Sophisticated Backpacks)</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Serveur A, craft un SophisticatedBackpack, remplir avec 10 blocs de diamant</li>
<li><input type="checkbox" class="checkbox"> Déconnecter</li>
<li><input type="checkbox" class="checkbox"> Join Serveur B (configurer un Server_id différent)</li>
<li><input type="checkbox" class="checkbox"> Ouvrir le backpack, compter les blocs de diamant</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>Exactement 10 blocs de diamant (pas de duplication)</li>
<li>Logs : <code>[restore-backpack] uuid=... nbt_keys=... cleared_via=api</code> (ou <code>reflection</code> en fallback)</li>
<li>Aucun WARN sur un removeBackpackContents raté</li>
</ul>
</div>
</div>
<div class="scenario critical">
<span class="tag tag-critical">CRITIQUE</span>
<h3>3. Duplication shulker Sophisticated Storage</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Serveur A, packer un shulker plein de diamants dans l'inventaire</li>
<li><input type="checkbox" class="checkbox"> Faire ouvrir l'inventaire par un autre Joueur B (via admin / échange / viewer)</li>
<li><input type="checkbox" class="checkbox"> Déconnecter le Joueur A</li>
<li><input type="checkbox" class="checkbox"> Joueur A se reconnecte sur Serveur B</li>
<li><input type="checkbox" class="checkbox"> Déballer le shulker, compter les diamants</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>Compte de diamants identique à l'original</li>
<li>Logs : <code>[CONTAINER_CLOSE]</code> pour le Joueur B (viewer force-fermé)</li>
<li>Logs : <code>[restore-ss] uuid=... nbt_keys=...</code></li>
</ul>
</div>
</div>
<div class="scenario critical">
<span class="tag tag-critical">CRITIQUE</span>
<h3>4. Recovery kill -9 / OOM</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Join Serveur A, mettre l'inventaire dans un état connu (poser un diamant nommé)</li>
<li><input type="checkbox" class="checkbox"> Trouver le PID java du serveur : <code>jps | grep Forge</code></li>
<li><input type="checkbox" class="checkbox"> Kill brutal : <code>kill -9 &lt;pid&gt;</code> (ou Task Manager → End Task sur Windows)</li>
<li><input type="checkbox" class="checkbox"> Redémarrer le serveur A</li>
<li><input type="checkbox" class="checkbox"> Join Serveur A, vérifier l'inventaire</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>Au boot : log <code>[crash-recovery] cleared N orphan online=1 rows</code></li>
<li>Au boot : <code>[crash-recovery] JVM shutdown hook installed</code> ET idéalement (si le hook a tourné) : <code>[emergency-flush] flushed N players</code></li>
<li>L'inventaire correspond au dernier état avant kill (dans la fenêtre auto-save ~10 min)</li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>5. Join sur serveur peer zombie (pas d'attente 30s)</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Dans Adminer, setter manuellement <code>player_data.last_server=99999</code> et <code>online=1</code> pour un UUID test</li>
<li><input type="checkbox" class="checkbox"> Joindre n'importe quel serveur en cours avec cet UUID</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>La connexion se fait en quelques secondes (pas 30s)</li>
<li>Logs : <code>[RACE] Peer server 99999 is dead/zombie — taking over</code></li>
<li>La DB affiche maintenant <code>last_server=&lt;thisServer&gt;</code>, <code>online=1</code></li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>6. Auto-save périodique (10 min)</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Setter <code>auto_save_interval_minutes=1</code> en config pour un test rapide</li>
<li><input type="checkbox" class="checkbox"> Join le serveur, ajouter des items à l'inventaire</li>
<li><input type="checkbox" class="checkbox"> Attendre 1 minute (surveiller sync.log)</li>
<li><input type="checkbox" class="checkbox"> Kill -9 du serveur</li>
<li><input type="checkbox" class="checkbox"> Redémarrer, rejoin, vérifier l'inventaire</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>Log : <code>[periodic-save] queued snapshots for N player(s)</code> après 1 min</li>
<li>L'inventaire post-crash reflète l'état AU dernier tick périodique</li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>7. Log WARN sur saturation pool</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Attendre 5 minutes après le boot du serveur (premier tick PoolStatsReporter)</li>
<li><input type="checkbox" class="checkbox"> Grep sync.log pour <code>[POOL]</code></li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>Au moins une ligne comme <code>[POOL] executor active=0 queue=0 pool_idle=4 | hikari active=0 idle=4</code></li>
<li>Aucun WARN sauf sous charge</li>
</ul>
</div>
</div>
<div class="scenario high">
<span class="tag tag-high">HIGH</span>
<h3>8. Heartbeat update server_info</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Dans Adminer, surveiller <code>server_info.last_update</code> pour l'id de ce serveur</li>
<li><input type="checkbox" class="checkbox"> Refresh toutes les 20s pendant 1 minute</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li><code>last_update</code> avance de ~10000 ms à chaque refresh</li>
<li>Log : <code>[heartbeat] started</code> au boot</li>
</ul>
</div>
</div>
<div class="scenario">
<span class="tag tag-medium">MEDIUM</span>
<h3>9. Capability Curios absente — pas de wipe</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Équiper des items curios, mourir dans la lave</li>
<li><input type="checkbox" class="checkbox"> Force-déconnecter pendant l'animation de mort</li>
<li><input type="checkbox" class="checkbox"> Reconnexion</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>Si cap absente : log <code>[store-curios] handler unavailable for ... skipping write</code></li>
<li>Row curios en DB NON wipée</li>
</ul>
</div>
</div>
<div class="scenario">
<span class="tag tag-medium">MEDIUM</span>
<h3>10. Claim cross-server + court-circuit downstream</h3>
<div class="steps">
<strong>Étapes :</strong>
<ol>
<li><input type="checkbox" class="checkbox"> Joueur connecté sur Serveur A</li>
<li><input type="checkbox" class="checkbox"> Déco puis immédiatement join Serveur B (&lt;200ms)</li>
<li><input type="checkbox" class="checkbox"> Vérifier sync.log sur Serveur A</li>
</ol>
</div>
<div class="expected">
<strong>Résultat attendu :</strong>
<ul>
<li>Serveur A peut logger <code>[GUARD]</code> (last_server guard a bloqué) si B a claim pendant la save de A</li>
<li>Si blocké : <code>[SAVE_SKIP] LOGOUT skipped: core guard blocked</code></li>
<li>Inventaire joueur sur B = inventaire tel qu'il était sur A (pas de merge, pas d'overwrite)</li>
</ul>
</div>
</div>
<h2>Vérifications régressions</h2>
<div class="regression">
<strong>Surveiller ces régressions après le déploiement Phases 0-5 :</strong>
<ul>
<li>TPS drop pendant les ticks auto-save (la save périodique à 10 min doit être invisible gameplay)</li>
<li>Warnings HikariCP leak — <code>leakDetectionThreshold=25000</code>, warnings = connexion tenue &gt;25s</li>
<li>Déclenchement CallerRunsPolicy (queue pleine) — WARN <code>[pool-stats] executor queue high</code></li>
<li>Deadlock sur logout → join (sérialisation bgLock) — le log doit montrer <code>[SAVE] LOGOUT completed</code> en ~500ms</li>
<li>Fallback reflection qui tourne répétitivement — signifie que l'API upstream removeBackpackContents / removeStorageContents a été cassée</li>
</ul>
</div>
<p style="text-align: center; color: #999; margin-top: 3em; font-size: 0.9em;">
Author: vyrriox &nbsp;|&nbsp; PlayerSync v2.1.5 &nbsp;|&nbsp; 2026-04-22
</p>
</body>
</html>

228
build.gradle
View File

@ -1,8 +1,14 @@
plugins { plugins {
id 'idea'
id 'java-library' id 'java-library'
id 'idea'
id 'maven-publish' id 'maven-publish'
id 'net.neoforged.moddev.legacyforge' version '2.0.84' // id 'net.neoforged.gradle.userdev' version '7.0.170'
id 'net.neoforged.moddev'
// Adds the Kotlin Gradle plugin
id 'org.jetbrains.kotlin.jvm' version '2.2.20'
// OPTIONAL Kotlin Serialization plugin
id 'org.jetbrains.kotlin.plugin.serialization' version '2.2.20'
} }
tasks.named('wrapper', Wrapper).configure { tasks.named('wrapper', Wrapper).configure {
@ -19,6 +25,17 @@ group = mod_group_id
repositories { repositories {
mavenLocal() mavenLocal()
exclusiveContent {
forRepository {
maven {
name = "Modrinth"
url = "https://api.modrinth.com/maven"
}
}
filter {
includeGroup "maven.modrinth"
}
}
exclusiveContent { exclusiveContent {
forRepository { forRepository {
maven { maven {
@ -29,172 +46,149 @@ repositories {
includeGroup "curse.maven" includeGroup "curse.maven"
} }
} }
maven {
name = 'Kotlin for Forge'
url = 'https://thedarkcolour.github.io/KotlinForForge/'
}
} }
base { base {
archivesName = mod_id archivesName = mod_id
} }
// Mojang ships Java 17 to end users in 1.20.1, so mods should target Java 17. java.toolchain.languageVersion = JavaLanguageVersion.of(21)
java.toolchain.languageVersion = JavaLanguageVersion.of(17)
legacyForge {
// Specify the version of MinecraftForge to use.
version = project.minecraft_version + '-' + project.forge_version // accessTransformers = project.files('src/main/resources/META-INF/accesstransformer.cfg')
neoForge {
version = project.neo_version
parchment { parchment {
mappingsVersion = project.parchment_mappings_version mappingsVersion = project.parchment_mappings_version
minecraftVersion = project.parchment_minecraft_version minecraftVersion = project.parchment_minecraft_version
}
mods {
"${mod_id}" {
sourceSet sourceSets.main
}
} }
// This line is optional. Access Transformers are automatically detected
// accessTransformers = project.files('src/main/resources/META-INF/accesstransformer.cfg')
// Default run configurations.
// These can be tweaked, removed, or duplicated as needed.
runs { runs {
configureEach {
systemProperty 'forge.logging.markers', 'REGISTRIES'
logLevel = org.slf4j.event.Level.DEBUG
}
client { client {
client() client()
systemProperty 'neoforge.enabledGameTestNamespaces', project.mod_id
// Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
systemProperty 'forge.enabledGameTestNamespaces', project.mod_id
} }
server { server {
server() server()
programArgument '--nogui' programArgument '--nogui'
systemProperty 'forge.enabledGameTestNamespaces', project.mod_id systemProperty 'neoforge.enabledGameTestNamespaces', project.mod_id
} }
// This run config launches GameTestServer and runs all registered gametests, then exits.
// By default, the server will crash when no gametests are provided.
// The gametest system is also enabled by default for other run configs under the /test command.
gameTestServer { gameTestServer {
type = "gameTestServer" type = "gameTestServer"
systemProperty 'forge.enabledGameTestNamespaces', project.mod_id systemProperty 'neoforge.enabledGameTestNamespaces', project.mod_id
} }
data { data {
data() data()
// example of overriding the workingDirectory set in configureEach above, uncomment if you want to use it
// gameDirectory = project.file('run-data')
// Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
programArguments.addAll '--mod', project.mod_id, '--all', '--output', file('src/generated/resources/').getAbsolutePath(), '--existing', file('src/main/resources/').getAbsolutePath() programArguments.addAll '--mod', project.mod_id, '--all', '--output', file('src/generated/resources/').getAbsolutePath(), '--existing', file('src/main/resources/').getAbsolutePath()
} }
// applies to all the run configs above
configureEach {
// Recommended logging data for a userdev environment
// The markers can be added/remove as needed separated by commas.
// "SCAN": For mods scan.
// "REGISTRIES": For firing of registry events.
// "REGISTRYDUMP": For getting the contents of all registries.
systemProperty 'forge.logging.markers', 'REGISTRIES'
// Recommended logging level for the console
// You can set various levels here.
// Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
logLevel = org.slf4j.event.Level.DEBUG
}
}
mods {
// define mod <-> source bindings
// these are used to tell the game which sources are for which mod
// mostly optional in a single mod project
// but multi mod projects should define one per mod
"${mod_id}" {
sourceSet(sourceSets.main)
}
} }
} }
// Include resources generated by data generators. // Sets up a dependency configuration called 'localRuntime'.
sourceSets.main.resources { srcDir 'src/generated/resources' } // This configuration should be used instead of 'runtimeOnly' to declare
// Sets up a dependency configuration called 'localRuntime' and a deobfuscating one called 'modLocalRuntime'
// These configurations should be used instead of 'runtimeOnly' to declare
// a dependency that will be present for runtime testing but that is // a dependency that will be present for runtime testing but that is
// "optional", meaning it will not be pulled by dependents of this mod. // "optional", meaning it will not be pulled by dependents of this mod.
configurations { configurations {
runtimeClasspath.extendsFrom localRuntime runtimeClasspath.extendsFrom localRuntime
} }
obfuscation {
createRemappingConfiguration(configurations.localRuntime)
}
dependencies { dependencies {
// If you wish to declare dependencies against mods, make sure to use the 'mod*' configurations so that they're remapped. implementation "net.neoforged:neoforge:${neo_version}"
// See https://github.com/neoforged/ModDevGradle/blob/main/LEGACY.md#remapping-mod-dependencies for more information. compileOnly "curse.maven:curios-309927:6529130"
compileOnly "curse.maven:sophisticated-backpacks-422301:7169832"
compileOnly "curse.maven:sophisticated-core-618298:7168230"
compileOnly "curse.maven:sophisticated-storage-619320:7744168"
// Example optional mod dependency with JEI compileOnly "thedarkcolour:kotlinforforge:5.10.0"
// The JEI API is declared for compile time use, while the full JEI artifact is used at runtime compileOnly "curse.maven:cobblemon-687131:7273151"
// modCompileOnly "mezz.jei:jei-${mc_version}-common-api:${jei_version}"
// modCompileOnly "mezz.jei:jei-${mc_version}-neoforge-api:${jei_version}"
// We add the full version to localRuntime, not runtimeOnly, so that we do not publish a dependency on it
// modLocalRuntime "mezz.jei:jei-${mc_version}-neoforge:${jei_version}"
compileOnly "curse.maven:curios-309927:5266541"
compileOnly "curse.maven:sophisticated-backpacks-422301:6303388"
compileOnly "curse.maven:sophisticated-core-618298:6317048"
// Example mod dependency using a mod jar from ./libs with a flat dir repository // Mod compatibility - Cosmetic Armor Reworked
// This maps to ./libs/coolmod-${mc_version}-${coolmod_version}.jar compileOnly "curse.maven:cosmetic-armor-reworked-237307:5610814"
// The group id is ignored when searching -- in this case, it is "blank" // Mod compatibility - Apotheosis + Placebo
// modImplementation "blank:coolmod-${mc_version}:${coolmod_version}" compileOnly "curse.maven:apotheosis-313970:7444906"
compileOnly "curse.maven:placebo-283644:6926281"
// Mod compatibility - The Aether + Accessories API
compileOnly "curse.maven:aether-255308:7043502"
compileOnly "curse.maven:accessories-938917:7046407"
// Mod compatibility - Refined Storage 2 + Extra Disks
compileOnly "curse.maven:refined-storage-243076:7610477"
compileOnly "curse.maven:extra-disks-351491:7032487"
// Example mod dependency using a file as dependency runtimeOnly "curse.maven:curios-309927:6529130"
// modImplementation files("libs/coolmod-${mc_version}-${coolmod_version}.jar") runtimeOnly "curse.maven:sophisticated-backpacks-422301:7169832"
runtimeOnly "curse.maven:sophisticated-core-618298:7168230"
// Example project dependency using a sister or child project: // Embed the JDBC driver in the mod using jarJar.
// modImplementation project(":myproject") // FIX COMPAT: declare a version RANGE so multi-mod setups (eg. arcadia-lib which
// requires [8.3.0, 9.0.0)) can resolve a single shared MySQL driver instance
// embedd the JDBC driver in the mod using jarJar // without jarJar complaining about incompatible constraints. The `prefer` keeps
// JDBC driver auto-detection is broken in Forge as of v47.4.0 // 9.3.0 as our baseline when PlayerSync is the only consumer.
// i.e. we need to need it both at compile and runtime runtimeOnly "com.mysql:mysql-connector-j:${jdbc_version}"
implementation "com.mysql:mysql-connector-j:${jdbc_version}" jarJar("com.mysql:mysql-connector-j") {
jarJar "com.mysql:mysql-connector-j:${jdbc_version}" version {
strictly "[8.3.0, 10.0.0)"
prefer "${jdbc_version}"
}
}
additionalRuntimeClasspath "com.mysql:mysql-connector-j:${jdbc_version}" additionalRuntimeClasspath "com.mysql:mysql-connector-j:${jdbc_version}"
// HikariCP connection pool — eliminates isValid() ping on every query (no more pingInternal in Spark)
// Exclude slf4j-api: NeoForge already ships it.
// FIX COMPAT: declare a range matching arcadia-lib's [5.1.0, 6.0.0) so jarJar
// resolution succeeds with a single shared instance.
implementation("com.zaxxer:HikariCP:${hikari_version}") {
exclude group: "org.slf4j", module: "slf4j-api"
}
jarJar("com.zaxxer:HikariCP") {
version {
strictly "[5.1.0, 6.0.0)"
prefer "${hikari_version}"
}
exclude group: "org.slf4j", module: "slf4j-api"
}
additionalRuntimeClasspath("com.zaxxer:HikariCP:${hikari_version}") {
exclude group: "org.slf4j", module: "slf4j-api"
}
// For more info: // For more info:
// http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
// http://www.gradle.org/docs/current/userguide/dependency_management.html // http://www.gradle.org/docs/current/userguide/dependency_management.html
} }
// Uncomment the lines below if you wish to configure mixin. The mixin file should be named modid.mixins.json.
/*
mixin {
add sourceSets.main, "${mod_id}.refmap.json"
config "${mod_id}.mixins.json"
}
dependencies {
annotationProcessor 'org.spongepowered:mixin:0.8.5:processor'
}
jar {
manifest.attributes([
"MixinConfigs": "${mod_id}.mixins.json"
])
}
*/
// This block of code expands all declared replace properties in the specified resource targets. // This block of code expands all declared replace properties in the specified resource targets.
// A missing property will result in an error. Properties are expanded using ${} Groovy notation. // A missing property will result in an error. Properties are expanded using ${} Groovy notation.
var generateModMetadata = tasks.register("generateModMetadata", ProcessResources) { var generateModMetadata = tasks.register("generateModMetadata", ProcessResources) {
var replaceProperties = [ var replaceProperties = [
minecraft_version : minecraft_version, minecraft_version : minecraft_version,
minecraft_version_range : minecraft_version_range, minecraft_version_range: minecraft_version_range,
forge_version : forge_version, neo_version : neo_version,
forge_version_range : forge_version_range, neo_version_range : neo_version_range,
loader_version_range : loader_version_range, loader_version_range : loader_version_range,
mod_id : mod_id, mod_id : mod_id,
mod_name : mod_name, mod_name : mod_name,
mod_license : mod_license, mod_license : mod_license,
mod_version : mod_version, mod_version : mod_version,
mod_authors : mod_authors, mod_authors : mod_authors,
mod_description : mod_description mod_description : mod_description
] ]
inputs.properties replaceProperties inputs.properties replaceProperties
expand replaceProperties expand replaceProperties
@ -205,7 +199,7 @@ var generateModMetadata = tasks.register("generateModMetadata", ProcessResources
// this works with both building through Gradle and the IDE. // this works with both building through Gradle and the IDE.
sourceSets.main.resources.srcDir generateModMetadata sourceSets.main.resources.srcDir generateModMetadata
// To avoid having to run "generateModMetadata" manually, make it run on every project reload // To avoid having to run "generateModMetadata" manually, make it run on every project reload
legacyForge.ideSyncTask generateModMetadata neoForge.ideSyncTask generateModMetadata
// Example configuration to allow publishing using the maven-publish plugin // Example configuration to allow publishing using the maven-publish plugin
publishing { publishing {

2
compat-mods/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
*.jar
!.gitkeep

0
compat-mods/.gitkeep Normal file
View File

31
compat-mods/README.md Normal file
View File

@ -0,0 +1,31 @@
# Compat Mods
Drop `.jar` files of mods that must be compatible with **PlayerSync** here for local analysis and testing.
## Purpose
- Reference bundles for writing compatibility shims (see `src/main/java/vip/fubuki/playersync/sync/addons/`).
- Local inspection of mod APIs, capabilities, and data structures.
- NOT loaded by the dev runtime — purely a staging folder for analysis.
## Rules
- `.jar` files are **git-ignored** — do not commit mod binaries.
- Keep one version per mod; rename with version suffix if multiple are needed (e.g. `sophisticatedbackpacks-1.21.1-3.23.0.jar`).
---
# Mods de compatibilité
Déposez les fichiers `.jar` des mods qui doivent être compatibles avec **PlayerSync** ici pour analyse et tests locaux.
## Objectif
- Bundles de référence pour écrire des shims de compatibilité (voir `src/main/java/vip/fubuki/playersync/sync/addons/`).
- Inspection locale des APIs, capabilities et structures de données des mods.
- Non chargé par le runtime de dev — dossier de staging uniquement pour analyse.
## Règles
- Les fichiers `.jar` sont **ignorés par git** — ne pas commit les binaires de mods.
- Une seule version par mod ; renommer avec le suffixe de version si plusieurs sont nécessaires (ex : `sophisticatedbackpacks-1.21.1-3.23.0.jar`).

33
gradle.properties
View File

@ -7,23 +7,19 @@ org.gradle.configuration-cache=true
#read more on this at https://github.com/neoforged/ModDevGradle?tab=readme-ov-file#better-minecraft-parameter-names--javadoc-parchment #read more on this at https://github.com/neoforged/ModDevGradle?tab=readme-ov-file#better-minecraft-parameter-names--javadoc-parchment
# you can also find the latest versions at: https://parchmentmc.org/docs/getting-started # you can also find the latest versions at: https://parchmentmc.org/docs/getting-started
parchment_minecraft_version=1.20.1 parchment_minecraft_version=1.21.1
parchment_mappings_version=2023.09.03 parchment_mappings_version=2024.11.17
# Environment Properties # Environment Properties
# You can find the latest versions here: https://files.minecraftforge.net/net/minecraftforge/forge/index_1.20.1.html # You can find the latest versions here: https://projects.neoforged.net/neoforged/neoforge
# The Minecraft version must agree with the Forge version to get a valid artifact # The Minecraft version must agree with the Neo version to get a valid artifact
minecraft_version=1.20.1 minecraft_version=1.21.1
# The Minecraft version range can use any release version of Minecraft as bounds. # The Minecraft version range can use any release version of Minecraft as bounds.
# Snapshots, pre-releases, and release candidates are not guaranteed to sort properly # Snapshots, pre-releases, and release candidates are not guaranteed to sort properly
# as they do not follow standard versioning conventions. # as they do not follow standard versioning conventions.
minecraft_version_range=[1.20.1, 1.21) minecraft_version_range=[1.21,1.21.3)
# The Forge version must agree with the Minecraft version to get a valid artifact neo_version=21.1.137
forge_version=47.4.0 neo_version_range=[21.1.128,)
# The Forge version range can use any version of Forge as bounds loader_version_range=[4,)
forge_version_range=[47,)
# The loader version range can only use the major version of FML as bounds
loader_version_range=[47,)
## Mod Properties ## Mod Properties
# The unique mod identifier for the mod. Must be lowercase in English locale. Must fit the regex [a-z][a-z0-9_]{1,63} # The unique mod identifier for the mod. Must be lowercase in English locale. Must fit the regex [a-z][a-z0-9_]{1,63}
@ -34,7 +30,7 @@ mod_name=PlayerSync
# The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default. # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
mod_license=GPL-3.0 license mod_license=GPL-3.0 license
# The mod version. See https://semver.org/ # The mod version. See https://semver.org/
mod_version=2.1.0 mod_version=2.1.5
# The group ID for the mod. It is only important when publishing as an artifact to a Maven repository. # The group ID for the mod. It is only important when publishing as an artifact to a Maven repository.
# This should match the base package used for the mod sources. # This should match the base package used for the mod sources.
# See https://maven.apache.org/guides/mini/guide-naming-conventions.html # See https://maven.apache.org/guides/mini/guide-naming-conventions.html
@ -44,6 +40,9 @@ mod_authors=mlus
# The description of the mod. This is a simple multiline text string that is used for display purposes in the mod list. # The description of the mod. This is a simple multiline text string that is used for display purposes in the mod list.
mod_description=make multiserver players' data sync mod_description=make multiserver players' data sync
# JDBC driver version # JDBC driver version
# see https://dev.mysql.com/doc/relnotes/connector-j/en/ for latest version # see https://dev.mysql.com/doc/relnotes/connector-j/en/ for latest version
jdbc_version=9.3.0 jdbc_version=9.3.0
# HikariCP connection pool version
hikari_version=5.1.0

13
settings.gradle
View File

@ -1,3 +1,16 @@
pluginManagement {
repositories {
mavenLocal()
gradlePluginPortal()
maven { url = 'https://maven.neoforged.net/releases' }
}
plugins {
// https://projects.neoforged.net/neoforged/ModDevGradle
id 'net.neoforged.moddev' version '2.0.74'
id 'net.neoforged.moddev.repositories' version '2.0.74'
}
}
plugins { plugins {
id 'org.gradle.toolchains.foojay-resolver-convention' version '0.9.0' id 'org.gradle.toolchains.foojay-resolver-convention' version '0.9.0'
} }

657
src/main/java/vip/fubuki/playersync/CommandInit.java Normal file
View File

@ -0,0 +1,657 @@
package vip.fubuki.playersync;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.arguments.IntegerArgumentType;
import com.mojang.brigadier.arguments.StringArgumentType;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.zaxxer.hikari.HikariPoolMXBean;
import net.minecraft.ChatFormatting;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.commands.Commands;
import net.minecraft.commands.arguments.EntityArgument;
import net.minecraft.commands.arguments.GameProfileArgument;
import net.minecraft.network.chat.Component;
import net.minecraft.server.level.ServerPlayer;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.fml.common.EventBusSubscriber;
import net.neoforged.neoforge.event.RegisterCommandsEvent;
import vip.fubuki.playersync.config.JdbcConfig;
import vip.fubuki.playersync.sync.VanillaSync;
import vip.fubuki.playersync.util.JDBCsetUp;
import vip.fubuki.playersync.util.SyncLogger;
import vip.fubuki.playersync.util.Tables;
import java.sql.ResultSet;
import java.util.Collection;
import java.util.UUID;
import java.util.concurrent.ThreadPoolExecutor;
/**
* Admin commands for PlayerSync. All commands require permission level 2 (op).
*
* <p>Root: {@code /playersync}
*
* <ul>
* <li>{@code status} — server + pool + heartbeat summary</li>
* <li>{@code flush [player]} — force an immediate save</li>
* <li>{@code info <player>} — show DB row metadata</li>
* <li>{@code reload} — reload config from disk</li>
* <li>{@code orphans} — list stuck online=1 rows</li>
* <li>{@code clearorphans [server_id]} — clear them</li>
* <li>{@code peers} — list peer servers</li>
* <li>{@code peerkill <id>} — force-disable a zombie peer</li>
* <li>{@code cleanup} — clear orphans + stale peers in one go</li>
* <li>{@code dump <player>} — dump DB row keys & sizes</li>
* <li>{@code resync <player>} — force re-apply from DB</li>
* <li>{@code poolstats} — immediate pool stats</li>
* <li>{@code wipe <player>} — DANGER: delete all rows for a player</li>
* <li>{@code version} — mod version</li>
* </ul>
*
* @author vyrriox
*/
@EventBusSubscriber(modid = PlayerSync.MODID)
public class CommandInit {
private static final int PERM_OP = 2;
@SubscribeEvent
public static void registerCommand(RegisterCommandsEvent event) {
CommandDispatcher<CommandSourceStack> d = event.getDispatcher();
d.register(Commands.literal("playersync")
.requires(cs -> cs.hasPermission(PERM_OP))
// ---- Status / info ----
.then(Commands.literal("version").executes(CommandInit::runVersion))
.then(Commands.literal("status").executes(CommandInit::runStatus))
.then(Commands.literal("poolstats").executes(CommandInit::runPoolStats))
// ---- Player ops ----
.then(Commands.literal("flush")
.executes(CommandInit::runFlushAll)
.then(Commands.argument("target", EntityArgument.player())
.executes(CommandInit::runFlushPlayer)))
.then(Commands.literal("info")
.then(Commands.argument("player", GameProfileArgument.gameProfile())
.executes(CommandInit::runInfo)))
.then(Commands.literal("dump")
.then(Commands.argument("player", GameProfileArgument.gameProfile())
.executes(CommandInit::runDump)))
.then(Commands.literal("resync")
.then(Commands.argument("target", EntityArgument.player())
.executes(CommandInit::runResync)))
.then(Commands.literal("wipe")
.then(Commands.argument("player", GameProfileArgument.gameProfile())
.then(Commands.literal("confirm")
.executes(CommandInit::runWipe))))
// ---- Inventory viewer ----
.then(Commands.literal("inventory")
.then(Commands.argument("player", GameProfileArgument.gameProfile())
.executes(ctx -> runInventoryView(ctx, "all"))
.then(Commands.literal("main")
.executes(ctx -> runInventoryView(ctx, "main")))
.then(Commands.literal("armor")
.executes(ctx -> runInventoryView(ctx, "armor")))
.then(Commands.literal("ender")
.executes(ctx -> runInventoryView(ctx, "ender")))
.then(Commands.literal("curios")
.executes(ctx -> runInventoryView(ctx, "curios")))
.then(Commands.literal("all")
.executes(ctx -> runInventoryView(ctx, "all")))))
// ---- Cluster ops ----
.then(Commands.literal("orphans").executes(CommandInit::runOrphans))
.then(Commands.literal("clearorphans")
.executes(CommandInit::runClearOrphansAll)
.then(Commands.argument("server_id", IntegerArgumentType.integer(0))
.executes(CommandInit::runClearOrphansId)))
.then(Commands.literal("peers").executes(CommandInit::runPeers))
.then(Commands.literal("peerkill")
.then(Commands.argument("server_id", IntegerArgumentType.integer(0))
.executes(CommandInit::runPeerKill)))
.then(Commands.literal("cleanup").executes(CommandInit::runCleanup))
// ---- Config ----
.then(Commands.literal("reload").executes(CommandInit::runReload))
.then(Commands.literal("help").executes(CommandInit::runHelp))
);
}
// ========================================================================
// Command handlers
// ========================================================================
private static int runVersion(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
ctx.getSource().sendSuccess(() -> Component.literal("§ePlayerSync §f" + PlayerSync.MODID + " §7(NeoForge 1.21.1)"), false);
return 1;
}
private static int runStatus(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
CommandSourceStack src = ctx.getSource();
final int serverId = JdbcConfig.SERVER_ID.get();
// Executor stats
ThreadPoolExecutor exec = VanillaSync.getExecutor();
final int active = exec != null ? exec.getActiveCount() : -1;
final int queue = exec != null ? exec.getQueue().size() : -1;
final int pool = exec != null ? exec.getPoolSize() : -1;
// Hikari stats
HikariPoolMXBean hk = JDBCsetUp.getPoolMXBean();
final int hA = hk != null ? hk.getActiveConnections() : -1;
final int hI = hk != null ? hk.getIdleConnections() : -1;
// Heartbeat age of this server
long hbAgeTmp = -1;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT last_update FROM " + Tables.serverInfo() + " WHERE id=?", serverId)) {
ResultSet rs = qr.resultSet();
if (rs.next()) hbAgeTmp = System.currentTimeMillis() - rs.getLong("last_update");
} catch (Exception ignored) {}
final long hbAge = hbAgeTmp;
final int online = src.getServer().getPlayerList().getPlayerCount();
src.sendSuccess(() -> Component.literal("§a=== PlayerSync status ==="), false);
src.sendSuccess(() -> Component.literal("§7server_id: §f" + serverId
+ " §7heartbeat_age: §f" + (hbAge >= 0 ? hbAge + "ms" : "§c?")), false);
src.sendSuccess(() -> Component.literal("§7players online (this server): §f" + online), false);
src.sendSuccess(() -> Component.literal("§7executor: §factive=" + active + " §7queue=§f" + queue + " §7pool=§f" + pool), false);
src.sendSuccess(() -> Component.literal("§7hikari: §factive=" + hA + " §7idle=§f" + hI), false);
src.sendSuccess(() -> Component.literal("§7auto_save: §f" + JdbcConfig.AUTO_SAVE_INTERVAL_MINUTES.get() + "min"
+ " §7heartbeat_interval: §f" + JdbcConfig.HEARTBEAT_INTERVAL_SECONDS.get() + "s"), false);
return 1;
}
private static int runPoolStats(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
ThreadPoolExecutor exec = VanillaSync.getExecutor();
HikariPoolMXBean hk = JDBCsetUp.getPoolMXBean();
int active = exec != null ? exec.getActiveCount() : -1;
int queue = exec != null ? exec.getQueue().size() : -1;
int idle = exec != null ? exec.getPoolSize() - exec.getActiveCount() : -1;
int hA = hk != null ? hk.getActiveConnections() : -1;
int hI = hk != null ? hk.getIdleConnections() : -1;
SyncLogger.poolStats(active, queue, idle, hA, hI);
ctx.getSource().sendSuccess(() -> Component.literal("§aPool stats logged to sync.log §7(exec a=" + active
+ " q=" + queue + "/" + (exec != null ? exec.getQueue().size() + exec.getQueue().remainingCapacity() : "?")
+ ", hikari a=" + hA + "/" + JdbcConfig.HIKARI_POOL_MAX_SIZE.get() + ")"), false);
return 1;
}
private static int runFlushAll(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
int count = 0;
for (ServerPlayer p : ctx.getSource().getServer().getPlayerList().getPlayers()) {
if (p.getTags().contains("player_synced") && !p.isDeadOrDying()) {
VanillaSync.snapshotAndQueueSave(p, "ADMIN_FLUSH");
count++;
}
}
final int queued = count;
ctx.getSource().sendSuccess(() -> Component.literal("§aFlush queued for §f" + queued + " §aplayer(s)"), true);
SyncLogger.playerEvent("SYSTEM", "ADMIN_FLUSH_ALL", "Triggered by " + ctx.getSource().getTextName() + " (" + queued + " players)");
return queued;
}
private static int runFlushPlayer(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
throws CommandSyntaxException {
ServerPlayer p = EntityArgument.getPlayer(ctx, "target");
VanillaSync.snapshotAndQueueSave(p, "ADMIN_FLUSH");
ctx.getSource().sendSuccess(() -> Component.literal("§aFlush queued for §f" + p.getName().getString()), true);
SyncLogger.playerEvent(p.getUUID().toString(), "ADMIN_FLUSH",
"Triggered by " + ctx.getSource().getTextName());
return 1;
}
private static int runInfo(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
throws CommandSyntaxException {
Collection<com.mojang.authlib.GameProfile> profiles =
GameProfileArgument.getGameProfiles(ctx, "player");
if (profiles.isEmpty()) {
ctx.getSource().sendFailure(Component.literal("§cNo matching player"));
return 0;
}
com.mojang.authlib.GameProfile profile = profiles.iterator().next();
UUID uuid = profile.getId();
String name = profile.getName();
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT last_server, online, LENGTH(inventory) AS inv_len, LENGTH(enderchest) AS ec_len,"
+ " LENGTH(armor) AS arm_len, xp, health FROM " + Tables.playerData() + " WHERE uuid=?",
uuid.toString())) {
ResultSet rs = qr.resultSet();
if (!rs.next()) {
ctx.getSource().sendFailure(Component.literal("§cNo DB row for " + name + " (" + uuid + ")"));
return 0;
}
int lastSrv = rs.getInt("last_server");
int onlineFlag = rs.getInt("online");
int invLen = rs.getInt("inv_len");
int ecLen = rs.getInt("ec_len");
int armLen = rs.getInt("arm_len");
int xp = rs.getInt("xp");
int hp = rs.getInt("health");
ctx.getSource().sendSuccess(() -> Component.literal("§a=== Info: §f" + name + " §7(" + uuid + ")"), false);
ctx.getSource().sendSuccess(() -> Component.literal("§7last_server: §f" + lastSrv
+ (lastSrv == JdbcConfig.SERVER_ID.get() ? " §8(this server)" : "")), false);
ctx.getSource().sendSuccess(() -> Component.literal("§7online: §f" + onlineFlag
+ " §7xp: §f" + xp + " §7health: §f" + hp), false);
ctx.getSource().sendSuccess(() -> Component.literal("§7data sizes: §finventory=" + invLen
+ "B armor=" + armLen + "B enderchest=" + ecLen + "B"), false);
} catch (Exception e) {
ctx.getSource().sendFailure(Component.literal("§cQuery failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runDump(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
throws CommandSyntaxException {
Collection<com.mojang.authlib.GameProfile> profiles =
GameProfileArgument.getGameProfiles(ctx, "player");
if (profiles.isEmpty()) {
ctx.getSource().sendFailure(Component.literal("§cNo matching player"));
return 0;
}
UUID uuid = profiles.iterator().next().getId();
PlayerSync.LOGGER.info("[admin-dump] dumping full row for {} (triggered by {})", uuid, ctx.getSource().getTextName());
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT * FROM " + Tables.playerData() + " WHERE uuid=?", uuid.toString())) {
ResultSet rs = qr.resultSet();
if (!rs.next()) {
ctx.getSource().sendFailure(Component.literal("§cNo row found"));
return 0;
}
int cols = rs.getMetaData().getColumnCount();
StringBuilder sb = new StringBuilder("[admin-dump] ").append(uuid).append(" {");
for (int i = 1; i <= cols; i++) {
String col = rs.getMetaData().getColumnName(i);
Object v = rs.getObject(i);
String val = v == null ? "null" : (v instanceof byte[] ? "<" + ((byte[]) v).length + " bytes>"
: v instanceof String ? "<" + ((String) v).length() + " chars>"
: v.toString());
sb.append(col).append("=").append(val);
if (i < cols) sb.append(", ");
}
sb.append("}");
PlayerSync.LOGGER.info(sb.toString());
SyncLogger.playerEvent(uuid.toString(), "ADMIN_DUMP", "Dumped by " + ctx.getSource().getTextName());
ctx.getSource().sendSuccess(() -> Component.literal("§aDumped to server log — search §f[admin-dump]"), false);
} catch (Exception e) {
ctx.getSource().sendFailure(Component.literal("§cDump failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runResync(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
throws CommandSyntaxException {
ServerPlayer p = EntityArgument.getPlayer(ctx, "target");
p.removeTag("player_synced");
ctx.getSource().sendSuccess(() -> Component.literal("§eKicking §f" + p.getName().getString()
+ " §eto force resync on rejoin"), true);
SyncLogger.playerEvent(p.getUUID().toString(), "ADMIN_RESYNC", "Triggered by " + ctx.getSource().getTextName());
p.connection.disconnect(Component.literal("§ePlayerSync resync — please reconnect"));
return 1;
}
private static int runWipe(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx)
throws CommandSyntaxException {
Collection<com.mojang.authlib.GameProfile> profiles =
GameProfileArgument.getGameProfiles(ctx, "player");
if (profiles.isEmpty()) {
ctx.getSource().sendFailure(Component.literal("§cNo matching player"));
return 0;
}
UUID uuid = profiles.iterator().next().getId();
try {
int d1 = JDBCsetUp.executePreparedUpdateRet("DELETE FROM " + Tables.playerData() + " WHERE uuid=?", uuid.toString());
int d2 = JDBCsetUp.executePreparedUpdateRet("DELETE FROM " + Tables.curios() + " WHERE uuid=?", uuid.toString());
int d3 = JDBCsetUp.executePreparedUpdateRet("DELETE FROM " + Tables.modPlayerData() + " WHERE uuid=?", uuid.toString());
final int total = d1 + d2 + d3;
ctx.getSource().sendSuccess(() -> Component.literal("§cWiped §f" + total
+ " §crow(s) for player §f" + uuid + " §8(player_data=" + d1 + ", curios=" + d2 + ", mod=" + d3 + ")"), true);
SyncLogger.playerEvent(uuid.toString(), "ADMIN_WIPE",
"Wiped " + total + " rows by " + ctx.getSource().getTextName());
PlayerSync.LOGGER.warn("[admin-wipe] {} wiped by {} ({} rows)", uuid, ctx.getSource().getTextName(), total);
} catch (Exception e) {
ctx.getSource().sendFailure(Component.literal("§cWipe failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runOrphans(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
CommandSourceStack src = ctx.getSource();
long staleMs = JdbcConfig.PEER_STALE_THRESHOLD_SECONDS.get() * 1000L;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT p.uuid, p.last_server, s.last_update FROM " + Tables.playerData() + " p"
+ " LEFT JOIN " + Tables.serverInfo() + " s ON s.id = p.last_server"
+ " WHERE p.online=1")) {
ResultSet rs = qr.resultSet();
int count = 0;
long now = System.currentTimeMillis();
int selfId = JdbcConfig.SERVER_ID.get();
while (rs.next()) {
String uuid = rs.getString("uuid");
int ls = rs.getInt("last_server");
long lu = rs.getLong("last_update");
long age = now - lu;
boolean stale = lu == 0 || age > staleMs || ls == 0;
if (stale && ls != selfId) {
count++;
final String u = uuid;
final int l = ls;
final long a = age;
src.sendSuccess(() -> Component.literal("§7- §f" + u + " §7last_server=§f" + l
+ " §7heartbeat_age=§f" + (lu == 0 ? "none" : (a / 1000) + "s")), false);
}
}
final int c = count;
src.sendSuccess(() -> Component.literal("§a" + c + " §aorphan row(s) found (online=1 on dead peer)"), false);
} catch (Exception e) {
src.sendFailure(Component.literal("§cOrphans query failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runClearOrphansAll(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
// Clear online=1 for rows whose last_server heartbeat is stale OR last_server=0
long staleMs = JdbcConfig.PEER_STALE_THRESHOLD_SECONDS.get() * 1000L;
long threshold = System.currentTimeMillis() - staleMs;
int selfId = JdbcConfig.SERVER_ID.get();
try {
int n = JDBCsetUp.executePreparedUpdateRet(
"UPDATE " + Tables.playerData() + " p SET p.online=0"
+ " WHERE p.online=1 AND p.last_server <> ?"
+ " AND (p.last_server = 0 OR NOT EXISTS ("
+ " SELECT 1 FROM " + Tables.serverInfo() + " s WHERE s.id = p.last_server AND s.last_update >= ?))",
selfId, threshold);
ctx.getSource().sendSuccess(() -> Component.literal("§aCleared §f" + n + " §aorphan row(s)"), true);
SyncLogger.playerEvent("SYSTEM", "ADMIN_CLEAR_ORPHANS",
"Cleared " + n + " rows by " + ctx.getSource().getTextName());
} catch (Exception e) {
ctx.getSource().sendFailure(Component.literal("§cClear failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runClearOrphansId(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
int id = IntegerArgumentType.getInteger(ctx, "server_id");
try {
int n = JDBCsetUp.executePreparedUpdateRet(
"UPDATE " + Tables.playerData() + " SET online=0 WHERE last_server=? AND online=1", id);
ctx.getSource().sendSuccess(() -> Component.literal("§aCleared §f" + n
+ " §aorphan row(s) with last_server=§f" + id), true);
SyncLogger.playerEvent("SYSTEM", "ADMIN_CLEAR_ORPHANS_ID",
"Cleared " + n + " rows for server_id=" + id + " by " + ctx.getSource().getTextName());
} catch (Exception e) {
ctx.getSource().sendFailure(Component.literal("§cClear failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runPeers(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
CommandSourceStack src = ctx.getSource();
long staleMs = JdbcConfig.PEER_STALE_THRESHOLD_SECONDS.get() * 1000L;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT id, enable, last_update FROM " + Tables.serverInfo() + " ORDER BY id")) {
ResultSet rs = qr.resultSet();
int self = JdbcConfig.SERVER_ID.get();
long now = System.currentTimeMillis();
src.sendSuccess(() -> Component.literal("§a=== Peer servers ==="), false);
int shown = 0;
while (rs.next()) {
int id = rs.getInt("id");
int enabled = rs.getInt("enable");
long lu = rs.getLong("last_update");
long age = now - lu;
boolean stale = enabled == 1 && age > staleMs;
String tag = id == self ? "§a[SELF]§r "
: stale ? "§c[STALE]§r "
: enabled == 0 ? "§8[STOPPED]§r "
: "§a[ALIVE]§r ";
final String line = "§7id=§f" + id + " §7enable=§f" + enabled
+ " §7age=§f" + (lu == 0 ? "never" : (age / 1000) + "s") + " " + tag;
src.sendSuccess(() -> Component.literal(line), false);
shown++;
}
final int s = shown;
src.sendSuccess(() -> Component.literal("§7Total peers: §f" + s), false);
} catch (Exception e) {
src.sendFailure(Component.literal("§cPeers query failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runPeerKill(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
int id = IntegerArgumentType.getInteger(ctx, "server_id");
if (id == JdbcConfig.SERVER_ID.get()) {
ctx.getSource().sendFailure(Component.literal("§cCannot peer-kill self"));
return 0;
}
try {
int n = JDBCsetUp.executePreparedUpdateRet(
"UPDATE " + Tables.serverInfo() + " SET enable=0 WHERE id=?", id);
ctx.getSource().sendSuccess(() -> Component.literal(
n > 0 ? "§aMarked peer §f" + id + " §aas stopped (enable=0)"
: "§cNo peer found with id=" + id), true);
SyncLogger.playerEvent("SYSTEM", "ADMIN_PEER_KILL",
"Peer " + id + " marked stopped by " + ctx.getSource().getTextName());
} catch (Exception e) {
ctx.getSource().sendFailure(Component.literal("§cPeerkill failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runCleanup(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
runClearOrphansAll(ctx);
long staleMs = JdbcConfig.PEER_STALE_THRESHOLD_SECONDS.get() * 1000L;
long threshold = System.currentTimeMillis() - staleMs;
try {
int n = JDBCsetUp.executePreparedUpdateRet(
"UPDATE " + Tables.serverInfo() + " SET enable=0 WHERE enable=1 AND id <> ? AND last_update < ?",
JdbcConfig.SERVER_ID.get(), threshold);
ctx.getSource().sendSuccess(() -> Component.literal("§aDisabled §f" + n + " §astale peer server(s)"), true);
SyncLogger.playerEvent("SYSTEM", "ADMIN_CLEANUP",
"Cleanup by " + ctx.getSource().getTextName() + " disabled " + n + " stale peers");
} catch (Exception e) {
ctx.getSource().sendFailure(Component.literal("§cCleanup stage 2 failed: " + e.getMessage()));
return 0;
}
return 1;
}
private static int runReload(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
// NeoForge's ModConfigSpec is mostly static and not reloadable at runtime.
// We expose the command as a marker so admins know to restart after edits,
// but also flush in-memory caches that read config lazily (Tables prefix).
ctx.getSource().sendSuccess(() -> Component.literal(
"§eModConfigSpec is loaded at startup; full reload requires a server restart."), false);
ctx.getSource().sendSuccess(() -> Component.literal(
"§7Runtime-readable values (thread pool / heartbeat period / toggles) will take effect on next tick."), false);
return 1;
}
/**
* Pretty-prints a player's inventory / armor / ender chest / curios from the DB.
* Works on offline players too — reads the serialized columns directly instead
* of requiring the entity to be online. Output is compact, per-section, with
* item ID and count per non-empty slot.
*/
private static int runInventoryView(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx, String section)
throws CommandSyntaxException {
Collection<com.mojang.authlib.GameProfile> profiles =
GameProfileArgument.getGameProfiles(ctx, "player");
if (profiles.isEmpty()) {
ctx.getSource().sendFailure(Component.literal("§cNo matching player"));
return 0;
}
com.mojang.authlib.GameProfile profile = profiles.iterator().next();
UUID uuid = profile.getId();
String name = profile.getName();
CommandSourceStack src = ctx.getSource();
String inventoryRaw = null, armorRaw = null, enderRaw = null;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT inventory, armor, enderchest FROM " + Tables.playerData() + " WHERE uuid=?",
uuid.toString())) {
ResultSet rs = qr.resultSet();
if (!rs.next()) {
src.sendFailure(Component.literal("§cNo DB row for " + name + " (" + uuid + ")"));
return 0;
}
inventoryRaw = rs.getString("inventory");
armorRaw = rs.getString("armor");
enderRaw = rs.getString("enderchest");
} catch (Exception e) {
src.sendFailure(Component.literal("§cDB query failed: " + e.getMessage()));
return 0;
}
String curiosRaw = null;
if ("all".equals(section) || "curios".equals(section)) {
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT curios_item FROM " + Tables.curios() + " WHERE uuid=?", uuid.toString())) {
ResultSet rs = qr.resultSet();
if (rs.next()) curiosRaw = rs.getString("curios_item");
} catch (Exception ignored) {}
}
src.sendSuccess(() -> Component.literal("§a=== Inventory of §f" + name + " §7(" + uuid + ")"), false);
int totalShown = 0;
if ("all".equals(section) || "main".equals(section)) {
totalShown += printSection(src, "§6Main inventory", inventoryRaw, 36);
}
if ("all".equals(section) || "armor".equals(section)) {
totalShown += printSection(src, "§6Armor §8(0=boots,1=legs,2=chest,3=helm)", armorRaw, 4);
}
if ("all".equals(section) || "ender".equals(section)) {
totalShown += printSection(src, "§6Ender chest", enderRaw, 27);
}
if ("all".equals(section) || "curios".equals(section)) {
totalShown += printCurios(src, curiosRaw);
}
final int shown = totalShown;
src.sendSuccess(() -> Component.literal("§7— §f" + shown + " §7non-empty slot(s) shown"), false);
return 1;
}
/** Prints a vanilla-style slot section (Map<Integer,String>). Returns non-empty count. */
private static int printSection(CommandSourceStack src, String header, String raw, int expectedSize) {
if (raw == null || raw.length() <= 2) {
src.sendSuccess(() -> Component.literal(header + "§7: §8(empty)"), false);
return 0;
}
java.util.Map<Integer, String> map;
try {
map = vip.fubuki.playersync.util.LocalJsonUtil.StringToEntryMap(raw);
} catch (Exception e) {
src.sendSuccess(() -> Component.literal(header + "§7: §c<parse error: " + e.getMessage() + ">"), false);
return 0;
}
if (map.isEmpty()) {
src.sendSuccess(() -> Component.literal(header + "§7: §8(empty)"), false);
return 0;
}
src.sendSuccess(() -> Component.literal(header + "§7 (" + map.size() + " slot(s) filled of " + expectedSize + "):"), false);
int shown = 0;
for (java.util.Map.Entry<Integer, String> e : new java.util.TreeMap<>(map).entrySet()) {
String line = formatSlotLine(e.getKey().toString(), e.getValue());
if (line != null) {
src.sendSuccess(() -> Component.literal(line), false);
shown++;
}
}
return shown;
}
/** Curios has composite keys ("slotType:index" and "cos:slotType:index"). */
private static int printCurios(CommandSourceStack src, String raw) {
if (raw == null || raw.length() <= 2) {
src.sendSuccess(() -> Component.literal("§6Curios§7: §8(empty)"), false);
return 0;
}
java.util.Map<String, String> map;
try {
map = vip.fubuki.playersync.util.LocalJsonUtil.StringToMap(raw);
} catch (Exception e) {
src.sendSuccess(() -> Component.literal("§6Curios§7: §c<parse error>"), false);
return 0;
}
if (map.isEmpty()) {
src.sendSuccess(() -> Component.literal("§6Curios§7: §8(empty)"), false);
return 0;
}
src.sendSuccess(() -> Component.literal("§6Curios§7 (" + map.size() + " slot(s) filled):"), false);
int shown = 0;
for (java.util.Map.Entry<String, String> e : new java.util.TreeMap<>(map).entrySet()) {
String line = formatSlotLine(e.getKey(), e.getValue());
if (line != null) {
src.sendSuccess(() -> Component.literal(line), false);
shown++;
}
}
return shown;
}
/** Deserializes a single slot payload into a human-readable line. */
private static String formatSlotLine(String slotKey, String payload) {
try {
net.minecraft.world.item.ItemStack stack =
vip.fubuki.playersync.sync.VanillaSync.deserializeAndCreatePlaceholderIfNeeded(payload);
if (stack == null || stack.isEmpty()) return null;
net.minecraft.resources.ResourceLocation id =
net.minecraft.core.registries.BuiltInRegistries.ITEM.getKey(stack.getItem());
String idStr = id == null ? "unknown" : id.toString();
String display = stack.getHoverName().getString();
// Placeholder items (items from a mod not loaded on this server) show up with their
// original id preserved inside CustomData — the deserializer already handled that.
boolean placeholder = idStr.equals("minecraft:paper")
&& stack.getComponents().has(net.minecraft.core.component.DataComponents.CUSTOM_DATA)
&& stack.getComponents().get(net.minecraft.core.component.DataComponents.CUSTOM_DATA)
.copyTag().contains("playersync:original_item_nbt");
String prefix = placeholder ? "§d[placeholder] " : "§f";
return "§7 [" + slotKey + "] " + prefix + idStr + "§7 x§f" + stack.getCount()
+ (display.equals(stack.getItem().getDescription().getString()) ? "" : " §8(" + display + ")");
} catch (Throwable t) {
return "§7 [" + slotKey + "] §c<parse error: " + t.getClass().getSimpleName() + ">";
}
}
private static int runHelp(com.mojang.brigadier.context.CommandContext<CommandSourceStack> ctx) {
CommandSourceStack src = ctx.getSource();
src.sendSuccess(() -> Component.literal("§a=== /playersync command reference ==="), false);
String[] lines = {
"§e/playersync status §7— server + pool + heartbeat summary",
"§e/playersync poolstats §7— log pool stats immediately",
"§e/playersync flush [player] §7— force save all / one",
"§e/playersync info <player> §7— DB row metadata",
"§e/playersync inventory <player> [main|armor|ender|curios|all] §7— pretty-print stored inventory",
"§e/playersync dump <player> §7— dump DB row to server log",
"§e/playersync resync <player> §7— kick to force re-sync",
"§e/playersync wipe <player> confirm §7— DELETE rows (DANGER)",
"§e/playersync orphans §7— list stuck online=1",
"§e/playersync clearorphans [id] §7— clear orphan rows",
"§e/playersync peers §7— list peer servers",
"§e/playersync peerkill <id> §7— force-disable a peer",
"§e/playersync cleanup §7— orphans + stale peers",
"§e/playersync reload §7— status note about config reload",
"§e/playersync version §7— mod version",
};
for (String l : lines) {
src.sendSuccess(() -> Component.literal(l), false);
}
return 1;
}
}

359
src/main/java/vip/fubuki/playersync/PlayerSync.java
View File

@ -1,80 +1,106 @@
package vip.fubuki.playersync; package vip.fubuki.playersync;
import com.mojang.logging.LogUtils; import com.mojang.logging.LogUtils;
import net.minecraftforge.common.MinecraftForge; import net.neoforged.bus.api.IEventBus;
import net.minecraftforge.event.server.ServerStartingEvent; import net.neoforged.bus.api.SubscribeEvent;
import net.minecraftforge.eventbus.api.IEventBus; import net.neoforged.fml.ModContainer;
import net.minecraftforge.eventbus.api.SubscribeEvent; import net.neoforged.fml.ModList;
import net.minecraftforge.fml.ModList; import net.neoforged.fml.common.Mod;
import net.minecraftforge.fml.common.Mod; import net.neoforged.fml.config.ModConfig;
import net.minecraftforge.fml.config.ModConfig; import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; import net.neoforged.neoforge.common.NeoForge;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext; import net.neoforged.neoforge.event.server.ServerStartingEvent;
import net.neoforged.neoforge.event.server.ServerStoppingEvent;
import org.slf4j.Logger; import org.slf4j.Logger;
import vip.fubuki.playersync.config.JdbcConfig; import vip.fubuki.playersync.config.JdbcConfig;
import vip.fubuki.playersync.sync.ChatSync;
import vip.fubuki.playersync.sync.VanillaSync; import vip.fubuki.playersync.sync.VanillaSync;
import vip.fubuki.playersync.util.JDBCsetUp; import vip.fubuki.playersync.util.JDBCsetUp;
import vip.fubuki.playersync.util.Tables;
import java.sql.Connection; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Statement; import java.sql.Statement;
import com.mysql.cj.jdbc.Driver;
@Mod(PlayerSync.MODID) @Mod(PlayerSync.MODID)
public class PlayerSync { public class PlayerSync {
public static final String MODID = "playersync"; public static final String MODID = "playersync";
public static final Logger LOGGER = LogUtils.getLogger(); public static final Logger LOGGER = LogUtils.getLogger();
public PlayerSync(FMLJavaModLoadingContext context) { public PlayerSync(IEventBus modEventBus, ModContainer modContainer) {
IEventBus modEventBus = context.getModEventBus();
context.registerConfig(ModConfig.Type.COMMON, JdbcConfig.COMMON_CONFIG);
modEventBus.addListener(this::commonSetup); modEventBus.addListener(this::commonSetup);
MinecraftForge.EVENT_BUS.register(this); NeoForge.EVENT_BUS.register(this);
modContainer.registerConfig(ModConfig.Type.COMMON, JdbcConfig.COMMON_CONFIG);
} }
private void commonSetup(final FMLCommonSetupEvent event) { private void commonSetup(final FMLCommonSetupEvent event) {
// JDBC driver auto-detection is broken in Forge as of v47.4.0
// We need to register the driver manually
try {
DriverManager.registerDriver(new Driver());
} catch (SQLException e) {
LOGGER.error("Unable to register JDBC MySQL driver", e);
}
VanillaSync.register(); VanillaSync.register();
event.enqueueWork(() -> { // Chat sync removed. The `sync_chat` / `IsChatServer` / `ChatServerIP` /
// read SYNC_CHAT only within the enqueueWork to reliably get the real // `ChatServerPort` keys in existing config files are now silently ignored
// config value and not its default value. // (NeoForge's ModConfig loader skips unknown keys, so no crash on upgrade).
if (JdbcConfig.SYNC_CHAT.get()) {
LOGGER.info("Chat sync enabled.");
ChatSync.register();
}
});
} }
@SubscribeEvent @SubscribeEvent
public void onServerStarting(ServerStartingEvent event) throws SQLException { public void onServerStarting(ServerStartingEvent event) {
// FIX COMPAT (C2): skip all MySQL init on single-player / integrated servers.
// Running PlayerSync in single-player makes no sense (no cross-server sync) and
// attempting to open a MySQL connection with default placeholder credentials on a
// laptop without a MySQL server produces noisy errors + degraded UX.
if (!event.getServer().isDedicatedServer()) {
LOGGER.info("PlayerSync: integrated server detected — skipping MySQL init (dedicated-server only).");
return;
}
// Full init guarded by a single try/catch so a missing / unreachable MySQL
// prints a user-friendly tutorial in the console instead of crashing the
// dedicated server or flooding the log with a raw JDBC stack trace.
try {
onServerStartingUnchecked(event);
} catch (Throwable t) {
printDatabaseTutorialBanner(t);
}
}
private void onServerStartingUnchecked(ServerStartingEvent event) throws SQLException {
String dbName = JdbcConfig.DATABASE_NAME.get(); String dbName = JdbcConfig.DATABASE_NAME.get();
// Step 1: Create the database using a connection that does not select a database. // FIX: Validate database name to prevent SQL injection via config.
JDBCsetUp.executeUpdate("CREATE DATABASE IF NOT EXISTS " + dbName, 1); // Only alphanumeric chars and underscores are allowed in MySQL identifiers.
if (!dbName.matches("[A-Za-z0-9_]+")) {
LOGGER.error("Invalid DATABASE_NAME '{}'. Only alphanumeric characters and underscores are allowed. Aborting.", dbName);
throw new SQLException("Invalid DATABASE_NAME: " + dbName);
}
// Step 2: Explicitly select the database on a connection obtained without default database. // Detect placeholder credentials and surface a tutorial straight away.
String pass = JdbcConfig.PASSWORD.get();
String host = JdbcConfig.HOST.get();
if ("pleaseChangeThisPassword".equals(pass) || "localhost".equals(host)) {
LOGGER.warn("[PlayerSync] Using placeholder credentials (host={}, password={}). Attempting anyway; a tutorial will be printed if the connection fails.",
host, "pleaseChangeThisPassword".equals(pass) ? "<DEFAULT>" : "<set>");
}
// Step 1: Create the database using a raw DriverManager connection (no pool yet).
JDBCsetUp.executeUpdate("CREATE DATABASE IF NOT EXISTS `" + dbName + "`", 1);
// Step 2: Initialise HikariCP pool now that the database exists.
JDBCsetUp.initPool();
// Initialize dedicated PlayerSync log file (logs/playersync/sync.log)
vip.fubuki.playersync.util.SyncLogger.init();
// Step 3: Explicitly select the database on a raw connection (DDL only).
try (Connection conn = JDBCsetUp.getConnection(false); try (Connection conn = JDBCsetUp.getConnection(false);
Statement st = conn.createStatement()) { Statement st = conn.createStatement()) {
st.execute("USE " + dbName); st.execute("USE `" + dbName + "`");
} catch (SQLException e) { } catch (SQLException e) {
LOGGER.error("Error selecting database " + dbName, e); LOGGER.error("Error selecting database " + dbName, e);
throw e; throw e;
} }
// Step 3: Create and alter tables using fully qualified names. // Step 4: Create and alter tables using fully qualified names.
// Create player_data table // Create player_data table
JDBCsetUp.executeUpdate( JDBCsetUp.executeUpdate(
"CREATE TABLE IF NOT EXISTS " + dbName + ".`player_data` (" + "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`" + Tables.playerData() + "` (" +
"`uuid` char(36) NOT NULL," + "`uuid` char(36) NOT NULL," +
"`inventory` mediumblob," + "`inventory` mediumblob," +
"`armor` blob," + "`armor` blob," +
@ -94,100 +120,257 @@ public class PlayerSync {
); );
// Check and alter player_data table if columns are missing // Check and alter player_data table if columns are missing
JDBCsetUp.QueryResult queryResult = JDBCsetUp.executeQuery(
"SELECT COUNT(*) AS column_count " +
"FROM INFORMATION_SCHEMA.COLUMNS " +
"WHERE TABLE_SCHEMA = '" + dbName + "' " +
"AND TABLE_NAME = 'player_data';"
);
ResultSet resultSet = queryResult.resultSet();
int columnCount = 0; int columnCount = 0;
if (resultSet.next()) { try (JDBCsetUp.QueryResult queryResult = JDBCsetUp.executePreparedQuery(
columnCount = resultSet.getInt("column_count"); "SELECT COUNT(*) AS column_count FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?",
dbName, Tables.playerData())) {
ResultSet resultSet = queryResult.resultSet();
if (resultSet.next()) {
columnCount = resultSet.getInt("column_count");
}
} }
if (columnCount < 14) { if (columnCount < 14) {
JDBCsetUp.executeUpdate( JDBCsetUp.executeUpdate(
"ALTER TABLE " + dbName + ".player_data " + "ALTER TABLE `" + dbName + "`.`" + Tables.playerData() + "` " +
"ADD COLUMN left_hand blob, " + "ADD COLUMN left_hand blob, " +
"ADD COLUMN cursors blob;" "ADD COLUMN cursors blob;"
); );
} }
// PHASE 15: 2-phase commit protocol column. Set when a peer starts its async
// logout save; cleared when the save atomically commits. Lets joining servers
// distinguish 'peer saving' from 'ghost session' from 'active dup' deterministically.
try (JDBCsetUp.QueryResult check = JDBCsetUp.executePreparedQuery(
"SELECT COUNT(*) AS c FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA=? AND TABLE_NAME=? AND COLUMN_NAME='logout_started_at'",
dbName, Tables.playerData())) {
ResultSet rs = check.resultSet();
if (rs.next() && rs.getInt("c") == 0) {
JDBCsetUp.executeUpdate(
"ALTER TABLE `" + dbName + "`.`" + Tables.playerData()
+ "` ADD COLUMN logout_started_at BIGINT NULL"
);
LOGGER.info("[migration] added player_data.logout_started_at column (2-phase commit)");
}
}
// Create server_info table // Create server_info table
JDBCsetUp.executeUpdate( JDBCsetUp.executeUpdate(
"CREATE TABLE IF NOT EXISTS " + dbName + ".server_info (" + "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`" + Tables.serverInfo() + "` (" +
"`id` INT NOT NULL," + "`id` INT NOT NULL," +
"`enable` boolean NOT NULL," + "`enable` boolean NOT NULL," +
"`last_update` BIGINT NOT NULL," + "`last_update` BIGINT NOT NULL," +
"PRIMARY KEY (`id`)" + "PRIMARY KEY (`id`)" +
");" ");"
); );
// FIX H-8: Use prepared statements for server_id to prevent SQL injection from config
long current = System.currentTimeMillis(); long current = System.currentTimeMillis();
JDBCsetUp.executeUpdate( JDBCsetUp.executePreparedUpdate(
"INSERT INTO " + dbName + ".server_info(id,enable,last_update) " + "INSERT INTO `" + dbName + "`.`" + Tables.serverInfo() + "`(id,enable,last_update) VALUES(?,true,?) ON DUPLICATE KEY UPDATE id=VALUES(id),enable=1,last_update=VALUES(last_update)",
"VALUES(" + JdbcConfig.SERVER_ID.get() + ",true," + current + ") " + JdbcConfig.SERVER_ID.get(), current
"ON DUPLICATE KEY UPDATE id= " + JdbcConfig.SERVER_ID.get() + ",enable = 1," +
"last_update=" + current + ";"
); );
JDBCsetUp.executeUpdate( JDBCsetUp.executePreparedUpdate(
"UPDATE " + dbName + ".server_info SET last_update=" + System.currentTimeMillis() + "UPDATE `" + dbName + "`.`" + Tables.serverInfo() + "` SET last_update=? WHERE id=?",
" WHERE id='" + JdbcConfig.SERVER_ID.get() + "'" System.currentTimeMillis(), JdbcConfig.SERVER_ID.get()
); );
// Create curios table if the Curios mod is loaded // Create curios table if the Curios mod is loaded
if (ModList.get().isLoaded("curios")) { if (ModList.get().isLoaded("curios")) {
JDBCsetUp.executeUpdate( JDBCsetUp.executeUpdate(
"CREATE TABLE IF NOT EXISTS " + dbName + ".curios (" + "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`" + Tables.curios() + "` (" +
"uuid CHAR(36) NOT NULL, curios_item BLOB, PRIMARY KEY (uuid)" + "uuid CHAR(36) NOT NULL, curios_item BLOB, PRIMARY KEY (uuid)" +
")" ")"
); );
} }
// Cobblemon support removed in this build (sync was main-thread blocking + SQL
// injection in the mixins). Existing `cobblemon` tables in the DB are kept intact
// for backward compat — they are simply no longer read or written.
// Create backpack_data table // Create backpack_data table
if (ModList.get().isLoaded("sophisticatedbackpacks")) { if (ModList.get().isLoaded("sophisticatedbackpacks")) {
JDBCsetUp.executeUpdate( JDBCsetUp.executeUpdate(
"CREATE TABLE IF NOT EXISTS " + dbName + ".backpack_data (" + "CREATE TABLE IF NOT EXISTS `" + dbName + "`.`" + Tables.backpackData() + "` (" +
"uuid CHAR(36) NOT NULL, backpack_nbt MEDIUMBLOB, PRIMARY KEY (uuid)" + "uuid CHAR(36) NOT NULL, backpack_nbt MEDIUMBLOB, PRIMARY KEY (uuid)" +
");", 1 ");", 1
); );
// Check if backpack_data table has the 'uuid' column // Check if backpack_data table has the 'uuid' column
JDBCsetUp.QueryResult backpackColCheck = JDBCsetUp.executeQuery( try (JDBCsetUp.QueryResult backpackColCheck = JDBCsetUp.executePreparedQuery(
"SELECT COUNT(*) AS colCount FROM INFORMATION_SCHEMA.COLUMNS " + "SELECT COUNT(*) AS colCount FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND COLUMN_NAME = 'uuid'",
"WHERE TABLE_SCHEMA = '" + dbName + "' " + dbName, Tables.backpackData())) {
"AND TABLE_NAME = 'backpack_data' " + ResultSet rsBackpackCol = backpackColCheck.resultSet();
"AND COLUMN_NAME = 'uuid';" if (rsBackpackCol.next() && rsBackpackCol.getInt("colCount") == 0) {
); LOGGER.info("Altering backpack_data table to add missing 'uuid' column.");
ResultSet rsBackpackCol = backpackColCheck.resultSet(); JDBCsetUp.executeUpdate("ALTER TABLE `" + dbName + "`.`" + Tables.backpackData() + "` ADD COLUMN uuid CHAR(36) NOT NULL", 1);
if (rsBackpackCol.next() && rsBackpackCol.getInt("colCount") == 0) { JDBCsetUp.executeUpdate("ALTER TABLE `" + dbName + "`.`" + Tables.backpackData() + "` ADD PRIMARY KEY (uuid)", 1);
LOGGER.info("Altering backpack_data table to add missing 'uuid' column."); }
// Add the missing column and set it as primary key.
JDBCsetUp.executeUpdate("ALTER TABLE " + dbName + ".backpack_data ADD COLUMN uuid CHAR(36) NOT NULL", 1);
JDBCsetUp.executeUpdate("ALTER TABLE " + dbName + ".backpack_data ADD PRIMARY KEY (uuid)", 1);
} }
rsBackpackCol.close();
backpackColCheck.connection().close();
} }
// Check and alter the 'advancements' column in player_data if necessary // Check and alter the 'advancements' column in player_data if necessary
JDBCsetUp.QueryResult advColCheck = JDBCsetUp.executeQuery( try (JDBCsetUp.QueryResult advColCheck = JDBCsetUp.executePreparedQuery(
"SELECT DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS " + "SELECT DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND COLUMN_NAME = 'advancements'",
"WHERE TABLE_SCHEMA = '" + dbName + "' " + dbName, Tables.playerData())) {
"AND TABLE_NAME = 'player_data' " + ResultSet rsAdvCol = advColCheck.resultSet();
"AND COLUMN_NAME = 'advancements';" if (rsAdvCol.next()) {
); String dataType = rsAdvCol.getString("DATA_TYPE");
ResultSet rsAdvCol = advColCheck.resultSet(); if (!"mediumblob".equalsIgnoreCase(dataType)) {
if (rsAdvCol.next()) { LOGGER.info("Altering player_data table to modify 'advancements' column to MEDIUMBLOB.");
String dataType = rsAdvCol.getString("DATA_TYPE"); JDBCsetUp.executeUpdate("ALTER TABLE `" + dbName + "`.`" + Tables.playerData() + "` MODIFY COLUMN advancements MEDIUMBLOB", 1);
if (!"mediumblob".equalsIgnoreCase(dataType)) { }
LOGGER.info("Altering player_data table to modify 'advancements' column to MEDIUMBLOB.");
JDBCsetUp.executeUpdate("ALTER TABLE " + dbName + ".player_data MODIFY COLUMN advancements MEDIUMBLOB", 1);
} }
} }
rsAdvCol.close();
// ----- END NEW BLOCK ----- // Create generic mod_player_data table for mod compatibility (Accessories, CosmeticArmor, Aether, etc.)
JDBCsetUp.executeUpdate(
"CREATE TABLE IF NOT EXISTS `" + dbName + "`.`" + Tables.modPlayerData() + "` (" +
"`uuid` CHAR(36) NOT NULL," +
"`mod_id` VARCHAR(64) NOT NULL," +
"`data_value` MEDIUMBLOB," +
"PRIMARY KEY (`uuid`, `mod_id`)" +
");"
);
try {
JDBCsetUp.executePreparedUpdate("UPDATE " + Tables.playerData() + " SET online=0 WHERE last_server=? AND online=1", JdbcConfig.SERVER_ID.get());
} catch (Exception e) {
LOGGER.error("An exception occurred while trying change wrong player-status\n" + e.getMessage());
}
// Phase 3: anti-loss infrastructure.
// 1. Clear orphaned online=1 flags from previous unclean shutdown.
// 2. Report zombie peer servers so admins see them in logs.
// 3. Install JVM shutdown hook — covers kill -9 / OOM / host reboot.
// 4. Start periodic heartbeat so peers can detect us as alive.
vip.fubuki.playersync.util.CrashRecovery.clearOrphanedOnlineFlags();
vip.fubuki.playersync.util.CrashRecovery.reportZombiePeers(60_000L);
vip.fubuki.playersync.util.CrashRecovery.installShutdownHook(() ->
vip.fubuki.playersync.sync.VanillaSync.emergencyFlushAll());
vip.fubuki.playersync.util.HeartbeatService.start();
// Phase 4: periodic full-flush scheduler (default 10 min).
vip.fubuki.playersync.util.PeriodicSaveService.start();
// Phase 5: pool / executor stats reporter (every 5 min into sync.log).
vip.fubuki.playersync.util.PoolStatsReporter.start();
LOGGER.info("PlayerSync is ready!"); LOGGER.info("PlayerSync is ready!");
} }
/**
* Alters a column to {@code targetType} only if its current {@code DATA_TYPE}
* differs. Skips expensive MDL + rebuild on every server start.
*/
private static void alterColumnIfNeeded(String dbName, String table, String column, String targetTypeLower) throws SQLException {
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA=? AND TABLE_NAME=? AND COLUMN_NAME=?",
dbName, table, column)) {
ResultSet rs = qr.resultSet();
if (rs.next()) {
String current = rs.getString("DATA_TYPE");
if (current != null && targetTypeLower.equalsIgnoreCase(current)) {
return;
}
}
}
LOGGER.info("Altering {}.{} column {} to {}", dbName, table, column, targetTypeLower.toUpperCase());
JDBCsetUp.executeUpdate("ALTER TABLE `" + dbName + "`.`" + table + "` MODIFY COLUMN `" + column + "` " + targetTypeLower.toUpperCase());
}
/**
* Prints a big, friendly banner to the console explaining why PlayerSync could
* not initialise its database. Invoked from the top-level try/catch in
* {@link #onServerStarting(ServerStartingEvent)} so the dedicated server boots
* anyway — admins running the mod for the first time get a tutorial instead
* of a cryptic SQLException.
*/
private static void printDatabaseTutorialBanner(Throwable failure) {
String configPath = "config/playersync-common.toml";
String host = safe(JdbcConfig.HOST);
int port = safeInt(JdbcConfig.PORT, 3306);
String user = safe(JdbcConfig.USERNAME);
String db = safe(JdbcConfig.DATABASE_NAME);
boolean defaultPass = "pleaseChangeThisPassword".equals(safe(JdbcConfig.PASSWORD));
String rootCause = rootCauseSummary(failure);
String[] banner = {
"",
"######################################################################",
"# #",
"# PlayerSync — DATABASE NOT AVAILABLE — SERVER STILL STARTED #",
"# #",
"# PlayerSync requires a MySQL / MariaDB database to sync player #",
"# data across servers. Your server will BOOT without sync until #",
"# the connection is fixed. #",
"# #",
"######################################################################",
"",
"What failed: " + rootCause,
"",
"Current config (from " + configPath + "):",
" host = " + host,
" db_port = " + port,
" user_name = " + user,
" db_name = " + db,
" password = " + (defaultPass ? "<PLACEHOLDER — NOT CHANGED>" : "<set>"),
"",
"=== Quick-fix checklist ===",
" 1. Is the database reachable from this host?",
" telnet " + host + " " + port + " (should connect)",
" mysql -h " + host + " -P " + port + " -u " + user + " -p",
"",
" 2. Did you change the password in " + configPath + " ?",
(defaultPass
? " >> NO — you're using the default 'pleaseChangeThisPassword'. <<"
: " OK — password is set."),
"",
" 3. Running on localhost for dev? Use the bundled Docker compose:",
" docker compose up -d # project root",
" (starts MariaDB + Adminer on :3306 / :8080)",
"",
" 4. Firewall / bind-address? MySQL config 'bind-address = 0.0.0.0'",
" and the user must have remote-login grants:",
" GRANT ALL ON " + db + ".* TO '" + user + "'@'%' IDENTIFIED BY '<your-pw>';",
" FLUSH PRIVILEGES;",
"",
" 5. Completely disable PlayerSync for this session — remove the jar",
" or start with -Dplayersync.disabled=true (not enforced by the mod",
" itself, but skips noisy errors if you don't intend to use it).",
"",
"Full exception trace follows for support / bug reports:",
"######################################################################",
"",
};
for (String line : banner) {
LOGGER.error(line);
}
LOGGER.error("PlayerSync initialisation failed — root cause:", failure);
LOGGER.error("######################################################################");
}
private static String safe(net.neoforged.neoforge.common.ModConfigSpec.ConfigValue<?> v) {
try { Object o = v.get(); return o == null ? "<null>" : o.toString(); } catch (Throwable t) { return "<unreadable>"; }
}
private static int safeInt(net.neoforged.neoforge.common.ModConfigSpec.IntValue v, int def) {
try { return v.get(); } catch (Throwable t) { return def; }
}
private static String rootCauseSummary(Throwable t) {
Throwable cur = t;
while (cur.getCause() != null && cur.getCause() != cur) cur = cur.getCause();
String cls = cur.getClass().getSimpleName();
String msg = cur.getMessage() == null ? "(no message)" : cur.getMessage().replaceAll("\\s+", " ").trim();
if (msg.length() > 180) msg = msg.substring(0, 177) + "...";
return cls + ": " + msg;
}
@SubscribeEvent
public void onServerStopping(ServerStoppingEvent event) {
// DO NOT call JDBCsetUp.shutdownPool() or SyncLogger.shutdown() here!
// VanillaSync.onServerShutdown also subscribes to ServerStoppingEvent and
// needs the pool to save all player data AND the logger to trace those saves.
// NeoForge does not guarantee handler ordering across @SubscribeEvent instances,
// so both the pool and the logger are shut down at the very end of
// VanillaSync.onServerShutdown — after parallel saves finish.
}
} }

249
src/main/java/vip/fubuki/playersync/config/JdbcConfig.java
View File

@ -1,7 +1,7 @@
package vip.fubuki.playersync.config; package vip.fubuki.playersync.config;
import net.minecraftforge.common.ForgeConfigSpec; import net.neoforged.neoforge.common.ModConfigSpec;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -9,57 +9,230 @@ import java.util.Random;
public class JdbcConfig { public class JdbcConfig {
public static ForgeConfigSpec COMMON_CONFIG; public static ModConfigSpec COMMON_CONFIG;
public static ForgeConfigSpec.ConfigValue<String> HOST;
public static ForgeConfigSpec.IntValue PORT;
public static ForgeConfigSpec.ConfigValue<String> USERNAME;
public static ForgeConfigSpec.ConfigValue<String> PASSWORD;
public static ForgeConfigSpec.ConfigValue<String> DATABASE_NAME;
public static ForgeConfigSpec.ConfigValue<List<String>> SYNC_WORLD;
public static ForgeConfigSpec.BooleanValue SYNC_ADVANCEMENTS;
public static ForgeConfigSpec.BooleanValue USE_SSL;
public static ForgeConfigSpec.BooleanValue SYNC_CHAT;
public static ForgeConfigSpec.BooleanValue IS_CHAT_SERVER;
public static final ForgeConfigSpec.ConfigValue<String> ITEM_PLACEHOLDER_TITLE_OVERRIDE;
public static final ForgeConfigSpec.ConfigValue<String> ITEM_PLACEHOLDER_DESCRIPTION_OVERRIDE;
public static ForgeConfigSpec.ConfigValue<String> CHAT_SERVER_IP;
public static ForgeConfigSpec.IntValue CHAT_SERVER_PORT;
public static ForgeConfigSpec.BooleanValue USE_LEGACY_SERIALIZATION;
public static ForgeConfigSpec.ConfigValue<Integer> SERVER_ID; // ----- Connection (kept under [general] for backward compat with existing config files) -----
public static ModConfigSpec.ConfigValue<String> HOST;
public static ModConfigSpec.IntValue PORT;
public static ModConfigSpec.ConfigValue<String> USERNAME;
public static ModConfigSpec.ConfigValue<String> PASSWORD;
public static ModConfigSpec.ConfigValue<String> DATABASE_NAME;
public static ModConfigSpec.BooleanValue USE_SSL;
// ----- Core sync behaviour (kept under [general]) -----
public static ModConfigSpec.ConfigValue<List<String>> SYNC_WORLD;
public static ModConfigSpec.BooleanValue SYNC_ADVANCEMENTS;
public static ModConfigSpec.BooleanValue KICK_WHEN_ALREADY_ONLINE;
public static ModConfigSpec.ConfigValue<String> KICK_MESSAGE;
public static ModConfigSpec.IntValue KICK_GRACE_PERIOD_MS;
public static ModConfigSpec.BooleanValue USE_LEGACY_SERIALIZATION;
public static final ModConfigSpec.ConfigValue<String> ITEM_PLACEHOLDER_TITLE_OVERRIDE;
public static final ModConfigSpec.ConfigValue<String> ITEM_PLACEHOLDER_DESCRIPTION_OVERRIDE;
public static ModConfigSpec.ConfigValue<Integer> SERVER_ID;
/** Table-name prefix; see {@link vip.fubuki.playersync.util.Tables}. */
public static ModConfigSpec.ConfigValue<String> TABLE_PREFIX;
// ----- Save triggers (new section) -----
public static ModConfigSpec.IntValue AUTO_SAVE_INTERVAL_MINUTES;
public static ModConfigSpec.BooleanValue SAVE_ON_DIMENSION_CHANGE;
public static ModConfigSpec.BooleanValue SAVE_ON_DEATH;
public static ModConfigSpec.BooleanValue SAVE_ON_RESPAWN;
// ----- Sync toggles (new section) -----
public static ModConfigSpec.BooleanValue SYNC_INVENTORY;
public static ModConfigSpec.BooleanValue SYNC_ENDER_CHEST;
public static ModConfigSpec.BooleanValue SYNC_XP;
public static ModConfigSpec.BooleanValue SYNC_EFFECTS;
public static ModConfigSpec.BooleanValue SYNC_HEALTH_FOOD;
public static ModConfigSpec.BooleanValue SYNC_CURIOS;
public static ModConfigSpec.BooleanValue SYNC_ACCESSORIES;
public static ModConfigSpec.BooleanValue SYNC_BACKPACKS;
public static ModConfigSpec.BooleanValue SYNC_COSMETIC_ARMOR;
public static ModConfigSpec.BooleanValue SYNC_REFINED_STORAGE;
// ----- Performance tuning (new section) -----
public static ModConfigSpec.IntValue HEARTBEAT_INTERVAL_SECONDS;
public static ModConfigSpec.IntValue PEER_STALE_THRESHOLD_SECONDS;
public static ModConfigSpec.IntValue JOIN_POLL_MAX_ATTEMPTS;
public static ModConfigSpec.IntValue JOIN_POLL_INTERVAL_MS;
public static ModConfigSpec.IntValue JOIN_PEER_ALIVE_MAX_WAIT_SECONDS;
public static ModConfigSpec.IntValue POOL_STATS_INTERVAL_MINUTES;
public static ModConfigSpec.IntValue HIKARI_POOL_MAX_SIZE;
public static ModConfigSpec.IntValue HIKARI_LEAK_THRESHOLD_MS;
// ----- Safety / integrity (new section) -----
public static ModConfigSpec.BooleanValue REFUSE_EMPTY_INVENTORY_WRITE;
public static ModConfigSpec.IntValue MAX_INVENTORY_SIZE_BYTES;
public static ModConfigSpec.IntValue SKIP_SAVES_WHEN_TPS_BELOW;
// ----- Observability (new section) -----
public static ModConfigSpec.BooleanValue LOG_STRUCTURED_JSON;
public static ModConfigSpec.IntValue LOG_ROTATION_SIZE_MB;
public static ModConfigSpec.IntValue LOG_ROTATION_MAX_FILES;
static { static {
ForgeConfigSpec.Builder COMMON_BUILDER = new ForgeConfigSpec.Builder(); ModConfigSpec.Builder B = new ModConfigSpec.Builder();
COMMON_BUILDER.comment("General settings").push("general");
HOST=COMMON_BUILDER.comment("The host of the database").define("host", "localhost"); // ==========================================================================
PORT = COMMON_BUILDER.comment("database port").defineInRange("db_port", 3306, 0, 65535); // [general] — Every key that already existed in pre-2.1.5 configs MUST stay
USE_SSL = COMMON_BUILDER.comment("whether use SSL").define("use_ssl", false); // here so existing playersync-common.toml files keep working after an upgrade.
USERNAME = COMMON_BUILDER.comment("username").define("user_name", "playersync"); // New settings go into dedicated sections below.
PASSWORD = COMMON_BUILDER.comment("password").define("password", "pleaseChangeThisPassword"); // ==========================================================================
DATABASE_NAME = COMMON_BUILDER.comment("database name").define("db_name","playersync"); B.comment("General settings").push("general");
SERVER_ID = COMMON_BUILDER.comment("the server id should be unique").define("Server_id", new Random().nextInt(1,Integer.MAX_VALUE-1));
SYNC_WORLD = COMMON_BUILDER.comment("The worlds that will be synchronized. If running on a server, leave array empty.").define("sync_world", new ArrayList<>()); HOST = B.comment("The host of the database").define("host", "localhost");
SYNC_ADVANCEMENTS = COMMON_BUILDER.comment("Whether to sync advancements between servers") PORT = B.comment("database port").defineInRange("db_port", 3306, 0, 65535);
USE_SSL = B.comment("whether use SSL").define("use_ssl", false);
USERNAME = B.comment("username").define("user_name", "playersync");
PASSWORD = B.comment("password").define("password", "pleaseChangeThisPassword");
DATABASE_NAME = B.comment("database name").define("db_name", "playersync");
TABLE_PREFIX = B.comment(
"Optional prefix prepended to every PlayerSync table (player_data, curios, backpack_data, ...).",
"Use to share a single MySQL database with other mods or legacy schemas.",
"Leave empty to keep the historical unprefixed names. Example: 'playersync_'.",
"Only alphanumeric characters and underscores are allowed."
).define("table_prefix", "");
SERVER_ID = B.comment("the server id should be unique")
.define("Server_id", new Random().nextInt(1, Integer.MAX_VALUE - 1));
SYNC_WORLD = B.comment("The worlds that will be synchronized. If running on a server, leave array empty.")
.define("sync_world", new ArrayList<>());
SYNC_ADVANCEMENTS = B.comment("Whether to sync advancements between servers")
.define("sync_advancements", true); .define("sync_advancements", true);
SYNC_CHAT = COMMON_BUILDER.comment("Whether synchronize chat").define("sync_chat", false); KICK_WHEN_ALREADY_ONLINE = B.comment("Whether to kick player when already online on another server")
IS_CHAT_SERVER = COMMON_BUILDER.comment("Whether recieve messages from other servers as host").define("IsChatServer",false); .define("kick_when_already_online", true);
CHAT_SERVER_IP = COMMON_BUILDER.define("ChatServerIP","127.0.0.1"); // NEW in 2.1.5 — safe to add to [general], unknown keys on old rollbacks just get ignored.
CHAT_SERVER_PORT = COMMON_BUILDER.defineInRange("ChatServerPort",7900,0,65535); KICK_MESSAGE = B.comment(
USE_LEGACY_SERIALIZATION = COMMON_BUILDER.comment( "Custom kick message when a duplicate login is detected. Empty = default message.")
.define("kick_message", "");
KICK_GRACE_PERIOD_MS = B.comment(
"Milliseconds to wait before kicking a duplicate-login player. Short grace period lets",
"the legitimate session re-establish on this server. Range 0-10000.")
.defineInRange("kick_grace_period_ms", 500, 0, 10000);
USE_LEGACY_SERIALIZATION = B.comment(
"Use the old (pre-Base64) serialization format for writing data to the database.", "Use the old (pre-Base64) serialization format for writing data to the database.",
"Set to true ONLY if you have older mod versions reading the same database.", "Set to true ONLY if you have older mod versions reading the same database.",
"This only affects writing data, the mod can read both Base64 and pre-Base64 serialization.", "This only affects writing data, the mod can read both Base64 and pre-Base64 serialization.",
"New installations should leave this as 'false'." "New installations should leave this as 'false'."
).define("use_legacy_serialization", false); ).define("use_legacy_serialization", false);
ITEM_PLACEHOLDER_TITLE_OVERRIDE = COMMON_BUILDER ITEM_PLACEHOLDER_TITLE_OVERRIDE = B
.comment("Override the title of placeholder items which are unavailable on the current server.") .comment("Override the title of placeholder items which are unavailable on the current server.")
.define("item_placeholder_title_override", ""); .define("item_placeholder_title_override", "");
ITEM_PLACEHOLDER_DESCRIPTION_OVERRIDE = COMMON_BUILDER ITEM_PLACEHOLDER_DESCRIPTION_OVERRIDE = B
.comment("Override the description of placeholder items which are unavailable on the current server.") .comment("Override the description of placeholder items which are unavailable on the current server.")
.define("item_placeholder_description_override", ""); .define("item_placeholder_description_override", "");
COMMON_BUILDER.pop(); B.pop(); // end [general]
COMMON_CONFIG = COMMON_BUILDER.build();
// ===== [save_triggers] =====
B.comment("When to trigger a save (new in 2.1.5)").push("save_triggers");
AUTO_SAVE_INTERVAL_MINUTES = B.comment(
"Periodic full-flush interval (minutes). Triggers a complete save (player data +",
"backpacks + SS + RS2) for every online player. Set to 0 to disable. Default 10."
).defineInRange("auto_save_interval_minutes", 10, 0, 1440);
SAVE_ON_DIMENSION_CHANGE = B.comment(
"Trigger a full save when a player changes dimension. Protects against mid-teleport",
"crashes. Adds DB load proportional to travel frequency."
).define("save_on_dimension_change", false);
SAVE_ON_DEATH = B.comment(
"Trigger a pre-death snapshot on LivingDeathEvent (before items drop).",
"Recovery insurance if the normal logout handler is skipped after death."
).define("save_on_death", true);
SAVE_ON_RESPAWN = B.comment(
"Trigger a save after player respawn to capture the post-death state immediately.")
.define("save_on_respawn", true);
B.pop();
// ===== [sync_toggles] =====
B.comment("Per-category sync toggles — disable individual data kinds if your server doesn't need them (new in 2.1.5)").push("sync_toggles");
SYNC_INVENTORY = B.comment("Sync main inventory + armor + offhand").define("sync_inventory", true);
SYNC_ENDER_CHEST = B.comment("Sync ender chest contents").define("sync_ender_chest", true);
SYNC_XP = B.comment("Sync total XP / experience levels").define("sync_xp", true);
SYNC_EFFECTS = B.comment("Sync active potion effects").define("sync_effects", true);
SYNC_HEALTH_FOOD = B.comment("Sync current health and food level").define("sync_health_food", true);
SYNC_CURIOS = B.comment("Sync Curios API slots (if the Curios mod is installed)").define("sync_curios", true);
SYNC_ACCESSORIES = B.comment("Sync Accessories API slots (if installed)").define("sync_accessories", true);
SYNC_BACKPACKS = B.comment("Sync Sophisticated Backpacks + Storage contents").define("sync_backpacks", true);
SYNC_COSMETIC_ARMOR = B.comment("Sync Cosmetic Armor Reworked slots").define("sync_cosmetic_armor", true);
SYNC_REFINED_STORAGE = B.comment("Sync Refined Storage 2 disk contents").define("sync_refined_storage", true);
B.pop();
// ===== [performance] =====
B.comment("Performance tuning — touch only if you know what you're doing (new in 2.1.5)").push("performance");
HEARTBEAT_INTERVAL_SECONDS = B.comment(
"How often this server writes its heartbeat to server_info (seconds). Pair with",
"peer_stale_threshold_seconds: peers older than threshold are treated as dead.")
.defineInRange("heartbeat_interval_seconds", 30, 5, 600);
PEER_STALE_THRESHOLD_SECONDS = B.comment(
"How old a peer heartbeat must be before we treat it as a dead (zombie) server.",
"doPlayerJoin short-circuits the last_server poll when the peer is stale.")
.defineInRange("peer_stale_threshold_seconds", 60, 10, 3600);
JOIN_POLL_MAX_ATTEMPTS = B.comment(
"Max attempts for doPlayerJoin's last_server poll before giving up.")
.defineInRange("join_poll_max_attempts", 120, 10, 600);
JOIN_POLL_INTERVAL_MS = B.comment(
"Wait interval between last_server poll attempts (milliseconds).")
.defineInRange("join_poll_interval_ms", 500, 100, 5000);
JOIN_PEER_ALIVE_MAX_WAIT_SECONDS = B.comment(
"How long to wait before force-claiming ownership when the previous server is",
"ALIVE (heartbeat fresh) but the player row still shows online=1. A force-claim",
"reads whatever is currently in the DB — if the peer's async save is still",
"in flight and commits AFTER we claim, any state change the peer recorded (item",
"pickup, drop, deposit) is lost on our side and may look like duplication against",
"an ItemEntity the peer had spawned. Real saves complete in <1s, but a slow DB",
"or heavy batch can push this to many seconds.",
"",
"Default 600s = wait the full poll — never force-claim on an alive peer. SAFE.",
"Lower to 30/15s if you accept the edge-case risk in exchange for faster handling",
"of ghost sessions (player dropped off A's network without clean logout).",
"Set to 0 to force-claim immediately (very aggressive, highest risk).",
"Stale-heartbeat peers are always force-claimed instantly regardless of this value.")
.defineInRange("join_peer_alive_max_wait_seconds", 600, 0, 3600);
POOL_STATS_INTERVAL_MINUTES = B.comment(
"How often PoolStatsReporter logs executor + Hikari stats. 0 to disable.")
.defineInRange("pool_stats_interval_minutes", 5, 0, 1440);
HIKARI_POOL_MAX_SIZE = B.comment(
"Max HikariCP connections. Empirical rule: cores*2 + spindles. Default 15 is good",
"for typical 35-player servers on modest hardware.")
.defineInRange("hikari_pool_max_size", 15, 1, 200);
HIKARI_LEAK_THRESHOLD_MS = B.comment(
"Hikari leak-detection threshold (ms). Lower = more sensitive, but false positives on",
"slow polls. 25000 covers legitimate 15-30s poll bursts.")
.defineInRange("hikari_leak_threshold_ms", 25000, 2000, 600000);
B.pop();
// ===== [safety] =====
B.comment("Safety guards — prevent silent data loss (new in 2.1.5)").push("safety");
REFUSE_EMPTY_INVENTORY_WRITE = B.comment(
"Refuse to UPDATE player_data with an empty inventory if the DB currently has non-empty",
"data. Last-resort guard against on-disconnect wipes. Set to false only for debugging.")
.define("refuse_empty_inventory_write", true);
MAX_INVENTORY_SIZE_BYTES = B.comment(
"Max serialized inventory size (bytes). Snapshots larger than this are rejected with",
"a log entry. Protects against infinite-NBT exploits. Default 10 MB.")
.defineInRange("max_inventory_size_bytes", 10 * 1024 * 1024, 1024, 512 * 1024 * 1024);
SKIP_SAVES_WHEN_TPS_BELOW = B.comment(
"Skip periodic auto-saves when the server MSPT average exceeds the value implied by this",
"TPS threshold. 0 = never skip. Example: 15 skips periodic saves when TPS < 15.")
.defineInRange("skip_saves_when_tps_below", 0, 0, 20);
B.pop();
// ===== [observability] =====
B.comment("Log file & diagnostics (new in 2.1.5)").push("observability");
LOG_STRUCTURED_JSON = B.comment(
"Emit sync.log entries as JSON objects instead of text. Enables ingestion in",
"Loki / ELK / Splunk pipelines.")
.define("log_structured_json", false);
LOG_ROTATION_SIZE_MB = B.comment(
"Max sync.log size before rotation (megabytes).")
.defineInRange("log_rotation_size_mb", 10, 1, 1024);
LOG_ROTATION_MAX_FILES = B.comment(
"Keep at most N rotated sync.log files (oldest deleted).")
.defineInRange("log_rotation_max_files", 5, 1, 100);
B.pop();
COMMON_CONFIG = B.build();
} }
} }

140
src/main/java/vip/fubuki/playersync/sync/ChatSync.java
View File

@ -1,140 +0,0 @@
package vip.fubuki.playersync.sync;
import net.minecraft.network.chat.Component;
import net.minecraft.server.players.PlayerList;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.player.PlayerEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import vip.fubuki.playersync.config.JdbcConfig;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Objects;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.slf4j.Logger;
import com.mojang.logging.LogUtils;
public class ChatSync {
private static final Logger LOGGER = LogUtils.getLogger();
static PlayerList playerList;
static ServerSocket serverSocket;
static Socket clientSocket;
static Set<Socket> SocketList = ConcurrentHashMap.newKeySet();
static ExecutorService executorService = Executors.newCachedThreadPool();
public static void register(){
if(JdbcConfig.IS_CHAT_SERVER.get()) {
LOGGER.info("Launching chat server thread.");
new Thread(ChatSync::ServerSocket).start();
}
ClientSocket();
MinecraftForge.EVENT_BUS.register(ChatSync.class);
}
private static void ServerSocket() {
try {
LOGGER.info("Trying to setup chat server at port " + JdbcConfig.CHAT_SERVER_PORT.get());
serverSocket = new ServerSocket(JdbcConfig.CHAT_SERVER_PORT.get());
while (true) {
Socket newSocket = serverSocket.accept();
SocketList.add(newSocket);
executorService.submit(() -> handleClient(newSocket));
}
} catch (IOException e) {
LOGGER.error("Unable to start chat server");
e.printStackTrace();
} finally {
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void handleClient(Socket socket) {
try (InputStream inputStream = socket.getInputStream()) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) != -1) {
String message = new String(buffer, 0, bytesRead);
broadcastMessage(socket, message);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
SocketList.remove(socket);
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void broadcastMessage(Socket sender, String message) {
for (Socket socket : SocketList) {
if (!socket.equals(sender)) {
try {
OutputStream outputStream = socket.getOutputStream();
outputStream.write(message.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private static void ClientSocket() {
try {
LOGGER.info("Trying to connect to chat server "
+ JdbcConfig.CHAT_SERVER_IP.get()
+ ":"
+ JdbcConfig.CHAT_SERVER_PORT.get());
clientSocket = new Socket(JdbcConfig.CHAT_SERVER_IP.get(), JdbcConfig.CHAT_SERVER_PORT.get());
Scanner scanner = new Scanner(clientSocket.getInputStream());
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
Component textComponents = Component.nullToEmpty(line);
playerList.broadcastSystemMessage(textComponents,true);
}
} catch (IOException e) {
e.printStackTrace();
reconnectClient();
}
}
private static void reconnectClient() {
LOGGER.warn("TODO: implement reconnectClient()");
//TODO
}
@SubscribeEvent
public static void onPlayerChat(net.minecraftforge.event.ServerChatEvent event) throws IOException {
String message= event.getUsername()+":"+event.getMessage();
OutputStream outputStream = clientSocket.getOutputStream();
outputStream.write(message.getBytes());
}
@SubscribeEvent
public static void onPlayerJoin(PlayerEvent.PlayerLoggedInEvent event){
playerList= Objects.requireNonNull(event.getEntity().getServer()).getPlayerList();
}
@SubscribeEvent
public static void onPlayerLeave(PlayerEvent.PlayerLoggedOutEvent event){
playerList= Objects.requireNonNull(event.getEntity().getServer()).getPlayerList();
}
}

200
src/main/java/vip/fubuki/playersync/sync/ModsSupport.java
View File

@ -1,200 +0,0 @@
package vip.fubuki.playersync.sync;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.NbtUtils;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraftforge.common.util.LazyOptional;
import net.minecraftforge.fml.ModList;
import vip.fubuki.playersync.PlayerSync;
import vip.fubuki.playersync.util.JDBCsetUp;
import vip.fubuki.playersync.util.LocalJsonUtil;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import top.theillusivec4.curios.api.CuriosApi;
import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
import top.theillusivec4.curios.api.type.inventory.ICurioStacksHandler;
import top.theillusivec4.curios.api.type.inventory.IDynamicStackHandler;
import java.util.Optional;
import java.util.UUID;
import static vip.fubuki.playersync.sync.VanillaSync.deserializeString;
public class ModsSupport {
/**
* Restores the Curios inventory for a player.
* The saved data is stored as a flat map with composite keys ("slotType:index").
*/
public void onPlayerJoin(net.minecraft.world.entity.player.Player player) throws SQLException {
if (ModList.get().isLoaded("curios")) {
// Obtain the handler from the API.
LazyOptional<ICuriosItemHandler> handlerOpt = CuriosApi.getCuriosInventory(player);
JDBCsetUp.QueryResult qr = JDBCsetUp.executeQuery("SELECT curios_item FROM curios WHERE uuid = '" + player.getUUID() + "'");
ResultSet rs = qr.resultSet();
if (rs.next()) {
String curiosData = rs.getString("curios_item");
if (curiosData.length() <= 2) {
rs.close();
qr.connection().close();
return;
}
// Parse the stored data (assumes a simple Map.toString() format: "{key=value, key2=value2, ...}")
Map<String, String> storedMap = LocalJsonUtil.StringToMap(curiosData);
// Clear current Curios slots to avoid conflicts.
handlerOpt.ifPresent(handler -> handler.getCurios().forEach((slotType, stacksHandler) -> {
// Use the dynamic stack handler to clear slots.
IDynamicStackHandler dynStacks = stacksHandler.getStacks();
for (int i = 0; i < dynStacks.getSlots(); i++) {
dynStacks.setStackInSlot(i, ItemStack.EMPTY);
}
}));
// Restore each saved item.
handlerOpt.ifPresent(handler -> {
for (Map.Entry<String, String> entry : storedMap.entrySet()) {
String compositeKey = entry.getKey(); // Expected format: "slotType:index"
String[] parts = compositeKey.split(":");
if (parts.length != 2) {
continue;
}
String slotType = parts[0];
int slotIndex;
try {
slotIndex = Integer.parseInt(parts[1]);
} catch (NumberFormatException ex) {
continue;
}
String serialized = entry.getValue();
try {
String nbtString = VanillaSync.deserializeString(serialized);
CompoundTag tag = NbtUtils.snbtToStructure(nbtString);
ItemStack stack = ItemStack.of(tag);
if (handler.getCurios().containsKey(slotType)) {
ICurioStacksHandler stacksHandler = handler.getCurios().get(slotType);
IDynamicStackHandler dynStacks = stacksHandler.getStacks();
if (slotIndex < dynStacks.getSlots()) {
dynStacks.setStackInSlot(slotIndex, stack);
}
}
} catch (CommandSyntaxException e) {
throw new RuntimeException("Error deserializing Curio data for key " + compositeKey, e);
}
}
});
rs.close();
qr.connection().close();
} else {
// No stored data; perform an initial save.
StoreCurios(player, true);
}
}
if(ModList.get().isLoaded("sophisticatedbackpacks")){
// --- Begin Backpack Data Restore ---
PlayerSync.LOGGER.info("Restoring backpack data for player " + player.getUUID());
net.p3pp3rf1y.sophisticatedbackpacks.util.PlayerInventoryProvider.get().runOnBackpacks(player, (ItemStack backpackItem, String handler, String identifier, int slot) -> {
backpackItem.getCapability(net.p3pp3rf1y.sophisticatedbackpacks.api.CapabilityBackpackWrapper.getCapabilityInstance())
.ifPresent(wrapper -> {
// Retrieve the contents UUID from the backpack's NBT using NBTHelper
Optional<UUID> uuidOpt = net.p3pp3rf1y.sophisticatedcore.util.NBTHelper.getUniqueId(wrapper.getBackpack(), "contentsUuid");
if (uuidOpt.isPresent()) {
UUID contentsUuid = uuidOpt.get();
try {
JDBCsetUp.QueryResult qrBackpack = JDBCsetUp.executeQuery("SELECT backpack_nbt FROM backpack_data WHERE uuid='" + contentsUuid + "'");
ResultSet rsBackpack = qrBackpack.resultSet();
if (rsBackpack.next()) {
String serialized = rsBackpack.getString("backpack_nbt");
String nbtString = deserializeString(serialized);
CompoundTag backpackNbt = NbtUtils.snbtToStructure(nbtString);
// Update BackpackStorage with the retrieved NBT
net.p3pp3rf1y.sophisticatedbackpacks.backpack.BackpackStorage.get().setBackpackContents(contentsUuid, backpackNbt);
PlayerSync.LOGGER.info("Restored backpack data for UUID " + contentsUuid);
}
rsBackpack.close();
qrBackpack.connection().close();
} catch (SQLException e) {
PlayerSync.LOGGER.error("Error restoring backpack data for UUID " + contentsUuid, e);
} catch (CommandSyntaxException e) {
throw new RuntimeException(e);
}
} else {
PlayerSync.LOGGER.warn("Backpack item in slot " + slot + " has no contentsUuid during restore");
}
});
return false;
});
// --- End Backpack Data Restore ---
}
}
/**
* Saves the current Curios inventory for a player.
* It builds a flat map keyed by "slotType:index" using the dynamic stack handler.
*/
public void onPlayerLeave(net.minecraft.world.entity.player.Player player) throws SQLException {
if (ModList.get().isLoaded("curios")) {
StoreCurios(player, false);
}
}
public void StoreCurios(net.minecraft.world.entity.player.Player player, boolean init) throws SQLException {
LazyOptional<ICuriosItemHandler> handlerOpt = CuriosApi.getCuriosInventory(player);
Map<String, String> flatMap = new HashMap<>();
handlerOpt.ifPresent(handler -> {
// Iterate over each slot type.
handler.getCurios().forEach((slotType, stacksHandler) -> {
IDynamicStackHandler dynStacks = stacksHandler.getStacks();
for (int i = 0; i < dynStacks.getSlots(); i++) {
ItemStack stack = dynStacks.getStackInSlot(i);
if (!stack.isEmpty()) {
String serialized = VanillaSync.serialize(stack.serializeNBT().toString());
flatMap.put(slotType + ":" + i, serialized);
}
}
});
});
String serializedData = flatMap.toString();
if (init) {
JDBCsetUp.executeUpdate("INSERT INTO curios (uuid,curios_item) VALUES ('" + player.getUUID() + "', '" + serializedData + "')");
} else {
JDBCsetUp.executeUpdate("UPDATE curios SET curios_item = '" + serializedData + "' WHERE uuid = '" + player.getUUID() + "'");
}
}
public static void storeSophisticatedBackpacks(Player player) {
PlayerSync.LOGGER.info("Storing backpack data for player " + player.getUUID());
net.p3pp3rf1y.sophisticatedbackpacks.util.PlayerInventoryProvider.get().runOnBackpacks(player, (ItemStack backpackItem, String handler, String identifier, int slot) -> {
backpackItem.getCapability(net.p3pp3rf1y.sophisticatedbackpacks.api.CapabilityBackpackWrapper.getCapabilityInstance())
.ifPresent(wrapper -> {
// Retrieve the contents UUID from the backpack's NBT using NBTHelper
Optional<UUID> uuidOpt = net.p3pp3rf1y.sophisticatedcore.util.NBTHelper.getUniqueId(wrapper.getBackpack(), "contentsUuid");
if (uuidOpt.isPresent()) {
UUID contentsUuid = uuidOpt.get();
// Get internal backpack data from BackpackStorage (creates it if missing)
CompoundTag backpackNbt = net.p3pp3rf1y.sophisticatedbackpacks.backpack.BackpackStorage.get().getOrCreateBackpackContents(contentsUuid);
String serialized = VanillaSync.serialize(backpackNbt.toString());
try {
// Use REPLACE INTO so existing records are updated
JDBCsetUp.executeUpdate("REPLACE INTO backpack_data (uuid, backpack_nbt) VALUES ('" + contentsUuid + "', '" + serialized + "')");
PlayerSync.LOGGER.info("Saved backpack data for UUID " + contentsUuid);
} catch (SQLException e) {
PlayerSync.LOGGER.error("Error saving backpack data for UUID " + contentsUuid, e);
}
} else {
PlayerSync.LOGGER.warn("Backpack item in slot " + slot + " has no contentsUuid");
}
});
return false; // Continue processing all backpack items.
});
}
}

2381
src/main/java/vip/fubuki/playersync/sync/VanillaSync.java
View File

File diff suppressed because it is too large Load Diff

131
src/main/java/vip/fubuki/playersync/sync/addons/CuriosCache.java Normal file
View File

@ -0,0 +1,131 @@
package vip.fubuki.playersync.sync.addons;
import net.minecraft.server.MinecraftServer;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.GameRules;
import net.neoforged.fml.ModList;
import top.theillusivec4.curios.api.CuriosApi;
import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
import top.theillusivec4.curios.api.type.inventory.IDynamicStackHandler;
import vip.fubuki.playersync.PlayerSync;
import vip.fubuki.playersync.sync.VanillaSync;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class CuriosCache {
private static final long CACHE_EXPIRY_MS = 3600000;
public static final ConcurrentHashMap<UUID, CuriosCacheEntry> curiosCache = new ConcurrentHashMap<>();
public static class CuriosCacheEntry {
final long timeStamp;
final String serializedData;
CuriosCacheEntry(String data) {
this.timeStamp = System.currentTimeMillis();
this.serializedData = data;
}
boolean isExpired() {
return System.currentTimeMillis() - timeStamp > CACHE_EXPIRY_MS;
}
}
//If player logged out by "Title Screen" button,you will not be able to get the handlerOpt,and it will make the curios inventory sync failed.
//Create a method to store temporary curios data when player is dead.
//Then check player status in the logged out event,and take a normal sync if player is alive.
//If player is dead or dying,the cache will be used to prevent the empty data from the failure of getting handlerOpt.
// FIX H-5: Cache curios on death regardless of keepInventory. Without this,
// players on servers WITHOUT keepInventory who die then disconnect before respawning
// would have their curios data overwritten with empty data (Curios API returns empty for dead players).
public static void tryStoreCuriosToCache(net.minecraft.world.entity.player.Player player) {
if (!ModList.get().isLoaded("curios")) {
return;
}
try {
Optional<ICuriosItemHandler> handlerOpt = CuriosApi.getCuriosInventory(player);
if (handlerOpt.isEmpty()) {
PlayerSync.LOGGER.error("Obtain the curios api failed,cannot create the cache.");
return;
}
ICuriosItemHandler handler = handlerOpt.get();
String serializedData = serializeCuriosInventory(handler);
if (serializedData.startsWith("{}")) {
PlayerSync.LOGGER.debug("No curios data found,skipping the step of creating cache");
return;
}
UUID playerUuid = player.getUUID();
curiosCache.put(playerUuid, new CuriosCacheEntry(serializedData));
} catch (Exception e) {
PlayerSync.LOGGER.error("An error occurred while creating curios cache:" + e.getMessage());
}
}
private static String serializeCuriosInventory(ICuriosItemHandler handler) {
Map<String, String> flatMap = new HashMap<>();
try {
handler.getCurios().forEach((slotType, stacksHandler) -> {
IDynamicStackHandler dynStacks = stacksHandler.getStacks();
for (int i = 0; i < dynStacks.getSlots(); i++) {
ItemStack stack = dynStacks.getStackInSlot(i);
if (!stack.isEmpty()) {
flatMap.put(slotType + ":" + i, VanillaSync.getNbtForStorage(stack));
}
}
// FIX A2: capture cosmetic stacks in the death cache, matching the
// snapshot/apply format ("cos:slotType:index"). Without this, a player
// who died with a cosmetic curio would lose it on rejoin because the
// apply path clears cosmetic slots unconditionally.
IDynamicStackHandler cosStacks = stacksHandler.getCosmeticStacks();
for (int i = 0; i < cosStacks.getSlots(); i++) {
ItemStack stack = cosStacks.getStackInSlot(i);
if (!stack.isEmpty()) {
flatMap.put("cos:" + slotType + ":" + i, VanillaSync.getNbtForStorage(stack));
}
}
});
} catch (Exception e) {
PlayerSync.LOGGER.error("Failed to serialize curios data:" + e.getMessage());
}
return flatMap.isEmpty() ? "{}" : flatMap.toString();
}
public static boolean isKeepInventoryActive(Player player) {
MinecraftServer server = player.getServer();
if (server == null) {
PlayerSync.LOGGER.error("Trying to get the gamerule(KeepInventory),but server is null");
return false;
}
return server.getGameRules().getBoolean(GameRules.RULE_KEEPINVENTORY);
}
public static void RemoveExpiredCuriosCache() {
long startMs = System.currentTimeMillis();
int cacheSize = curiosCache.size();
if (cacheSize == 0) {
PlayerSync.LOGGER.debug("No curios caches,skipping cleaning");
return;
}
int removed = 0;
Iterator<Map.Entry<UUID, CuriosCacheEntry>> iterator = curiosCache.entrySet().iterator();
while (iterator.hasNext()) {
if (iterator.next().getValue().isExpired()) {
iterator.remove();
removed ++;
}
}
if (removed > 0) {
PlayerSync.LOGGER.info("Cleaned {} curios cache(s),{} left,took {} Ms",
removed, curiosCache.size(), System.currentTimeMillis() - startMs);
}
}
}

644
src/main/java/vip/fubuki/playersync/sync/addons/ModCompatSync.java Normal file
View File

@ -0,0 +1,644 @@
package vip.fubuki.playersync.sync.addons;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.neoforged.fml.ModList;
import vip.fubuki.playersync.PlayerSync;
import vip.fubuki.playersync.sync.VanillaSync;
import vip.fubuki.playersync.util.JDBCsetUp;
import vip.fubuki.playersync.util.LocalJsonUtil;
import vip.fubuki.playersync.util.Tables;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
/**
* Mod compatibility handlers for syncing player data from:
* - Accessories API (used by The Aether for pendant, cape, gloves, rings, etc.)
* - Cosmetic Armor Reworked (4 cosmetic armor slots)
* - Apotheosis (item DataComponents travel with inventory - automatic)
*/
public class ModCompatSync {
// FIX PERF (C4): Cache reflection Method lookups for NeoForge AttachmentHolder.
// Previously resolved on every snapshot/apply (35 players × auto-save = thousands of
// reflective lookups / hour). Static-init once, reuse forever.
private static final java.lang.reflect.Method SERIALIZE_ATTACHMENTS;
private static final java.lang.reflect.Method DESERIALIZE_ATTACHMENTS;
static {
java.lang.reflect.Method ser = null, des = null;
try {
ser = net.neoforged.neoforge.attachment.AttachmentHolder.class
.getDeclaredMethod("serializeAttachments", net.minecraft.core.HolderLookup.Provider.class);
ser.setAccessible(true);
des = net.neoforged.neoforge.attachment.AttachmentHolder.class
.getDeclaredMethod("deserializeAttachments",
net.minecraft.core.HolderLookup.Provider.class,
net.minecraft.nbt.CompoundTag.class);
des.setAccessible(true);
} catch (NoSuchMethodException e) {
PlayerSync.LOGGER.error("[PlayerSync] Could not cache AttachmentHolder reflection methods; NeoForge attachment sync will be disabled.", e);
}
SERIALIZE_ATTACHMENTS = ser;
DESERIALIZE_ATTACHMENTS = des;
}
// ============================
// Accessories API (Aether slots)
// ============================
/**
* Saves Accessories inventory (used by The Aether and other mods).
* Works identically to Curios sync but uses the Accessories API.
*/
public static void storeAccessories(Player player) {
if (!ModList.get().isLoaded("accessories")) return;
try {
Map<String, String> flatMap = new HashMap<>();
io.wispforest.accessories.api.AccessoriesCapability cap =
io.wispforest.accessories.api.AccessoriesCapability.get(player);
if (cap == null) {
PlayerSync.LOGGER.debug("No Accessories capability for player {}", player.getUUID());
return;
}
Map<String, io.wispforest.accessories.api.AccessoriesContainer> containers = cap.getContainers();
for (Map.Entry<String, io.wispforest.accessories.api.AccessoriesContainer> entry : containers.entrySet()) {
String slotType = entry.getKey();
io.wispforest.accessories.api.AccessoriesContainer container = entry.getValue();
var accessories = container.getAccessories();
for (int i = 0; i < accessories.getContainerSize(); i++) {
ItemStack stack = accessories.getItem(i);
if (!stack.isEmpty()) {
flatMap.put(slotType + ":" + i, VanillaSync.getNbtForStorage(stack));
}
}
}
String serializedData = flatMap.toString();
JDBCsetUp.executePreparedUpdate(
"REPLACE INTO " + Tables.modPlayerData() + " (uuid, mod_id, data_value) VALUES (?, ?, ?)",
player.getUUID().toString(), "accessories", serializedData);
PlayerSync.LOGGER.debug("Saved Accessories data for player {}", player.getUUID());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error saving Accessories data for player {}", player.getUUID(), e);
}
}
/**
* Restores Accessories inventory for a player.
* Same logic as Curios restore: validate data before clearing, then restore items.
*/
public static void restoreAccessories(Player player) {
if (!ModList.get().isLoaded("accessories")) return;
try {
io.wispforest.accessories.api.AccessoriesCapability cap =
io.wispforest.accessories.api.AccessoriesCapability.get(player);
if (cap == null) {
PlayerSync.LOGGER.debug("No Accessories capability for player {}", player.getUUID());
return;
}
String accessoriesData;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT data_value FROM " + Tables.modPlayerData() + " WHERE uuid=? AND mod_id=?",
player.getUUID().toString(), "accessories")) {
ResultSet rs = qr.resultSet();
if (!rs.next()) {
// No data yet, perform initial save
storeAccessories(player);
return;
}
accessoriesData = rs.getString("data_value");
}
// Validate data before clearing
if (accessoriesData == null || accessoriesData.length() <= 2) {
PlayerSync.LOGGER.debug("Empty Accessories data for player {}, skipping restore", player.getUUID());
return;
}
Map<String, String> storedMap = LocalJsonUtil.StringToMap(accessoriesData);
if (storedMap.isEmpty()) return;
Map<String, io.wispforest.accessories.api.AccessoriesContainer> containers = cap.getContainers();
// Clear all Accessories slots ONLY after confirming valid data
for (io.wispforest.accessories.api.AccessoriesContainer container : containers.values()) {
var accessories = container.getAccessories();
for (int i = 0; i < accessories.getContainerSize(); i++) {
accessories.setItem(i, ItemStack.EMPTY);
}
}
// Restore items
for (Map.Entry<String, String> entry : storedMap.entrySet()) {
String compositeKey = entry.getKey();
int lastColon = compositeKey.lastIndexOf(':');
if (lastColon < 0) continue;
String slotType = compositeKey.substring(0, lastColon);
int slotIndex;
try {
slotIndex = Integer.parseInt(compositeKey.substring(lastColon + 1));
} catch (NumberFormatException ex) {
continue;
}
try {
ItemStack stack = VanillaSync.deserializeAndCreatePlaceholderIfNeeded(entry.getValue());
if (containers.containsKey(slotType)) {
var accessories = containers.get(slotType).getAccessories();
if (slotIndex < accessories.getContainerSize()) {
accessories.setItem(slotIndex, stack);
}
}
} catch (CommandSyntaxException e) {
PlayerSync.LOGGER.error("Error deserializing Accessories data for key {}. Skipping.", compositeKey, e);
} catch (Exception e) {
PlayerSync.LOGGER.error("Unexpected error restoring Accessories data for key {}. Skipping.", compositeKey, e);
}
}
PlayerSync.LOGGER.debug("Restored Accessories data for player {}", player.getUUID());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error restoring Accessories data for player {}", player.getUUID(), e);
}
}
/**
* Applies pre-read Accessories data to the player entity (NO DB access).
* Used by doPlayerJoin to avoid DB reads on the main thread.
*/
public static void applyAccessoriesFromData(Player player, String accessoriesData) {
if (!ModList.get().isLoaded("accessories")) return;
if (!vip.fubuki.playersync.config.JdbcConfig.SYNC_ACCESSORIES.get()) return; // PHASE 8: toggle
try {
io.wispforest.accessories.api.AccessoriesCapability cap =
io.wispforest.accessories.api.AccessoriesCapability.get(player);
if (cap == null) return;
Map<String, io.wispforest.accessories.api.AccessoriesContainer> containers = cap.getContainers();
// FIX ANTI-DUPLICATION: ALWAYS clear accessories slots first to wipe stale
// data from Minecraft's .dat file, then only restore if DB has valid data.
for (io.wispforest.accessories.api.AccessoriesContainer container : containers.values()) {
var accessories = container.getAccessories();
for (int i = 0; i < accessories.getContainerSize(); i++) {
accessories.setItem(i, ItemStack.EMPTY);
}
}
if (accessoriesData == null || accessoriesData.length() <= 2) return;
Map<String, String> storedMap = LocalJsonUtil.StringToMap(accessoriesData);
if (storedMap.isEmpty()) return;
for (Map.Entry<String, String> entry : storedMap.entrySet()) {
String compositeKey = entry.getKey();
int lastColon = compositeKey.lastIndexOf(':');
if (lastColon < 0) continue;
String slotType = compositeKey.substring(0, lastColon);
int slotIndex;
try { slotIndex = Integer.parseInt(compositeKey.substring(lastColon + 1)); }
catch (NumberFormatException ex) { continue; }
try {
ItemStack stack = VanillaSync.deserializeAndCreatePlaceholderIfNeeded(entry.getValue());
if (containers.containsKey(slotType)) {
var acc = containers.get(slotType).getAccessories();
if (slotIndex < acc.getContainerSize()) {
acc.setItem(slotIndex, stack);
}
}
} catch (Exception e) {
PlayerSync.LOGGER.error("Error applying Accessories data for key {}", compositeKey, e);
}
}
PlayerSync.LOGGER.info("Applied Accessories data for player {}", player.getUUID());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error applying Accessories data for player {}", player.getUUID(), e);
}
}
// ============================
// Cosmetic Armor Reworked
// ============================
/**
* Saves Cosmetic Armor slots (4 cosmetic equipment slots: head, chest, legs, feet).
*/
public static void storeCosmeticArmor(Player player) {
if (!ModList.get().isLoaded("cosmeticarmorreworked")) return;
try {
Map<Integer, String> flatMap = new HashMap<>();
lain.mods.cos.impl.inventory.InventoryCosArmor cosInv =
lain.mods.cos.impl.ModObjects.invMan.getCosArmorInventory(player.getUUID());
if (cosInv == null) {
PlayerSync.LOGGER.debug("No CosmeticArmor inventory for player {}", player.getUUID());
return;
}
for (int i = 0; i < cosInv.getContainerSize(); i++) {
ItemStack stack = cosInv.getItem(i);
if (!stack.isEmpty()) {
flatMap.put(i, VanillaSync.getNbtForStorage(stack));
}
}
String serializedData = flatMap.toString();
JDBCsetUp.executePreparedUpdate(
"REPLACE INTO " + Tables.modPlayerData() + " (uuid, mod_id, data_value) VALUES (?, ?, ?)",
player.getUUID().toString(), "cosmeticarmor", serializedData);
PlayerSync.LOGGER.debug("Saved CosmeticArmor data for player {}", player.getUUID());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error saving CosmeticArmor data for player {}", player.getUUID(), e);
}
}
/**
* Restores Cosmetic Armor slots for a player.
*/
public static void restoreCosmeticArmor(Player player) {
if (!ModList.get().isLoaded("cosmeticarmorreworked")) return;
try {
lain.mods.cos.impl.inventory.InventoryCosArmor cosInv =
lain.mods.cos.impl.ModObjects.invMan.getCosArmorInventory(player.getUUID());
if (cosInv == null) {
PlayerSync.LOGGER.debug("No CosmeticArmor inventory for player {}", player.getUUID());
return;
}
String cosmeticData;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT data_value FROM " + Tables.modPlayerData() + " WHERE uuid=? AND mod_id=?",
player.getUUID().toString(), "cosmeticarmor")) {
ResultSet rs = qr.resultSet();
if (!rs.next()) {
// No data yet, perform initial save
storeCosmeticArmor(player);
return;
}
cosmeticData = rs.getString("data_value");
}
// Validate before clearing
if (cosmeticData == null || cosmeticData.length() <= 2) {
PlayerSync.LOGGER.debug("Empty CosmeticArmor data for player {}, skipping restore", player.getUUID());
return;
}
Map<Integer, String> storedMap = LocalJsonUtil.StringToEntryMap(cosmeticData);
if (storedMap.isEmpty()) return;
// Clear cosmetic armor slots
for (int i = 0; i < cosInv.getContainerSize(); i++) {
cosInv.setItem(i, ItemStack.EMPTY);
}
// Restore items
for (Map.Entry<Integer, String> entry : storedMap.entrySet()) {
int slot = entry.getKey();
try {
ItemStack stack = VanillaSync.deserializeAndCreatePlaceholderIfNeeded(entry.getValue());
if (slot < cosInv.getContainerSize()) {
cosInv.setItem(slot, stack);
}
} catch (CommandSyntaxException e) {
PlayerSync.LOGGER.error("Error deserializing CosmeticArmor slot {}. Skipping.", slot, e);
} catch (Exception e) {
PlayerSync.LOGGER.error("Unexpected error restoring CosmeticArmor slot {}. Skipping.", slot, e);
}
}
// Mark the inventory as changed so the mod syncs to the client
cosInv.setChanged();
PlayerSync.LOGGER.debug("Restored CosmeticArmor data for player {}", player.getUUID());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error restoring CosmeticArmor data for player {}", player.getUUID(), e);
}
}
/**
* Applies pre-read CosmeticArmor data to the player entity (NO DB access).
*/
public static void applyCosmeticArmorFromData(Player player, String cosmeticArmorData) {
if (!ModList.get().isLoaded("cosmeticarmorreworked")) return;
if (!vip.fubuki.playersync.config.JdbcConfig.SYNC_COSMETIC_ARMOR.get()) return; // PHASE 8: toggle
try {
lain.mods.cos.impl.inventory.InventoryCosArmor cosInv =
lain.mods.cos.impl.ModObjects.invMan.getCosArmorInventory(player.getUUID());
if (cosInv == null) return;
// FIX ANTI-DUPLICATION: ALWAYS clear cosmetic armor slots first to wipe stale
// data from Minecraft's .dat file, then only restore if DB has valid data.
for (int i = 0; i < cosInv.getContainerSize(); i++) {
cosInv.setItem(i, ItemStack.EMPTY);
}
if (cosmeticArmorData == null || cosmeticArmorData.length() <= 2) return;
Map<Integer, String> storedMap = LocalJsonUtil.StringToEntryMap(cosmeticArmorData);
if (storedMap.isEmpty()) return;
for (Map.Entry<Integer, String> entry : storedMap.entrySet()) {
int slot = entry.getKey();
try {
ItemStack stack = VanillaSync.deserializeAndCreatePlaceholderIfNeeded(entry.getValue());
if (slot < cosInv.getContainerSize()) {
cosInv.setItem(slot, stack);
}
} catch (Exception e) {
PlayerSync.LOGGER.error("Error applying CosmeticArmor slot {}", slot, e);
}
}
cosInv.setChanged();
PlayerSync.LOGGER.info("Applied CosmeticArmor data for player {}", player.getUUID());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error applying CosmeticArmor data for player {}", player.getUUID(), e);
}
}
// ============================
// Generic NeoForge Attachment Sync
// ============================
/**
* Saves ALL NeoForge player attachments to the database.
* This covers per-player data from ALL mods, including:
* - Ars Nouveau (mana, glyph knowledge)
* - Iron's Spellbooks (mana, learned spells)
* - Pehkui (player scale)
* - Spice of Life: Onion (food diversity)
* - Any other mod using NeoForge's attachment system
*
* Uses player.saveWithoutId() to extract the attachments tag from the
* player's full serialized NBT, ensuring we capture ALL mod data.
*/
public static void storeNeoForgeAttachments(Player player) {
try {
if (!(player instanceof net.minecraft.server.level.ServerPlayer serverPlayer)) return;
if (SERIALIZE_ATTACHMENTS == null) return;
net.minecraft.nbt.CompoundTag attachments = (net.minecraft.nbt.CompoundTag)
SERIALIZE_ATTACHMENTS.invoke(player, serverPlayer.getServer().registryAccess());
if (attachments != null && !attachments.isEmpty()) {
String serialized = VanillaSync.serializeTagToBinaryBase64(attachments);
JDBCsetUp.executePreparedUpdate(
"REPLACE INTO " + Tables.modPlayerData() + " (uuid, mod_id, data_value) VALUES (?, ?, ?)",
player.getUUID().toString(), "neoforge_attachments", serialized);
PlayerSync.LOGGER.debug("Saved NeoForge attachments for player {} ({} keys)",
player.getUUID(), attachments.getAllKeys().size());
}
} catch (Exception e) {
PlayerSync.LOGGER.error("Error saving NeoForge attachments for player {}", player.getUUID(), e);
}
}
/**
* Restores NeoForge player attachments from the database.
* Uses reflection to call NeoForge's internal deserializeAttachments method,
* which ensures the exact same deserialization path as a normal player load.
*
* FIX: The method signature is deserializeAttachments(HolderLookup.Provider, CompoundTag),
* NOT deserializeAttachments(CompoundTag). The old code passed wrong parameters causing
* silent failure - no NeoForge attachment data (SOL Onion, Ars Nouveau, etc.) was restored.
*/
public static void restoreNeoForgeAttachments(Player player) {
try {
if (!(player instanceof net.minecraft.server.level.ServerPlayer serverPlayer)) return;
if (DESERIALIZE_ATTACHMENTS == null) return;
String serialized;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT data_value FROM " + Tables.modPlayerData() + " WHERE uuid=? AND mod_id=?",
player.getUUID().toString(), "neoforge_attachments")) {
ResultSet rs = qr.resultSet();
if (!rs.next()) return;
serialized = rs.getString("data_value");
}
if (serialized == null || !serialized.startsWith("BNBT:")) return;
net.minecraft.nbt.CompoundTag attachments = VanillaSync.deserializeBinaryBase64Tag(serialized);
if (attachments.isEmpty()) return;
net.minecraft.nbt.CompoundTag wrapper = new net.minecraft.nbt.CompoundTag();
wrapper.put("neoforge:attachments", attachments);
DESERIALIZE_ATTACHMENTS.invoke(player, serverPlayer.getServer().registryAccess(), wrapper);
PlayerSync.LOGGER.debug("Restored NeoForge attachments for player {} ({} keys)",
player.getUUID(), attachments.getAllKeys().size());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error restoring NeoForge attachments for player {}", player.getUUID(), e);
}
}
/**
* Applies pre-read NeoForge attachments data to the player entity (NO DB access).
*/
public static void applyAttachmentsFromData(Player player, String serialized) {
if (serialized == null || !serialized.startsWith("BNBT:")) return;
if (DESERIALIZE_ATTACHMENTS == null) return;
try {
if (!(player instanceof net.minecraft.server.level.ServerPlayer serverPlayer)) return;
net.minecraft.nbt.CompoundTag attachments = VanillaSync.deserializeBinaryBase64Tag(serialized);
if (attachments.isEmpty()) return;
net.minecraft.nbt.CompoundTag wrapper = new net.minecraft.nbt.CompoundTag();
wrapper.put("neoforge:attachments", attachments);
DESERIALIZE_ATTACHMENTS.invoke(player, serverPlayer.getServer().registryAccess(), wrapper);
PlayerSync.LOGGER.info("Applied NeoForge attachments for player {} ({} keys)",
player.getUUID(), attachments.getAllKeys().size());
} catch (Exception e) {
PlayerSync.LOGGER.error("Error applying NeoForge attachments for player {}", player.getUUID(), e);
}
}
// ============================
// Snapshot methods (main thread - entity reads only, NO DB writes)
// These are used by auto-save and SaveToFile to capture entity state on the
// main thread, then the actual DB writes happen on a background thread.
// ============================
/**
* Captures Accessories slot data on the main thread.
* Returns serialized string or null if mod not loaded / no data.
*/
public static String snapshotAccessories(Player player) {
if (!ModList.get().isLoaded("accessories")) return null;
try {
io.wispforest.accessories.api.AccessoriesCapability cap =
io.wispforest.accessories.api.AccessoriesCapability.get(player);
// FIX ANTI-LOSS (A2): cap==null means the capability isn't attached yet —
// return null to SKIP write and preserve DB. Do NOT return "{}" here, as that
// would wipe a legitimate accessories record.
if (cap == null) {
vip.fubuki.playersync.util.SyncLogger.modCompatSkip(
player.getUUID().toString(), "accessories",
"capability unavailable — skipping write to preserve DB");
return null;
}
Map<String, String> flatMap = new HashMap<>();
for (Map.Entry<String, io.wispforest.accessories.api.AccessoriesContainer> entry : cap.getContainers().entrySet()) {
String slotType = entry.getKey();
var accessories = entry.getValue().getAccessories();
for (int i = 0; i < accessories.getContainerSize(); i++) {
ItemStack stack = accessories.getItem(i);
if (!stack.isEmpty()) {
flatMap.put(slotType + ":" + i, VanillaSync.getNbtForStorage(stack));
}
}
}
// Cap read OK — "{}" is intentional for truly empty slots so apply clears stale .dat.
return flatMap.toString();
} catch (Exception e) {
PlayerSync.LOGGER.error("Error snapshotting Accessories for player {}", player.getUUID(), e);
return null;
}
}
/**
* Captures Cosmetic Armor slot data on the main thread.
* Returns serialized string or null if mod not loaded / no data.
*/
public static String snapshotCosmeticArmor(Player player) {
if (!ModList.get().isLoaded("cosmeticarmorreworked")) return null;
try {
lain.mods.cos.impl.inventory.InventoryCosArmor cosInv =
lain.mods.cos.impl.ModObjects.invMan.getCosArmorInventory(player.getUUID());
// FIX ANTI-LOSS (A2): null manager → cannot read → SKIP write, preserve DB.
if (cosInv == null) return null;
Map<Integer, String> flatMap = new HashMap<>();
for (int i = 0; i < cosInv.getContainerSize(); i++) {
ItemStack stack = cosInv.getItem(i);
if (!stack.isEmpty()) {
flatMap.put(i, VanillaSync.getNbtForStorage(stack));
}
}
// Read OK — "{}" for truly empty slots so apply clears stale .dat.
return flatMap.toString();
} catch (Exception e) {
PlayerSync.LOGGER.error("Error snapshotting CosmeticArmor for player {}", player.getUUID(), e);
return null;
}
}
/**
* Captures NeoForge attachment data on the main thread via reflection.
* Returns BNBT-serialized string or null if no data.
*/
public static String snapshotAttachments(Player player) {
if (SERIALIZE_ATTACHMENTS == null) return null;
try {
if (!(player instanceof net.minecraft.server.level.ServerPlayer serverPlayer)) return null;
net.minecraft.nbt.CompoundTag attachments = (net.minecraft.nbt.CompoundTag)
SERIALIZE_ATTACHMENTS.invoke(player, serverPlayer.getServer().registryAccess());
if (attachments == null || attachments.isEmpty()) return null;
return VanillaSync.serializeTagToBinaryBase64(attachments);
} catch (Exception e) {
PlayerSync.LOGGER.error("Error snapshotting NeoForge attachments for player {}", player.getUUID(), e);
return null;
}
}
/**
* Writes pre-snapshotted mod data to the DB.
* NO entity access — safe to call from a background thread.
*
* @param uuid player UUID string
* @param accessoriesData serialized Accessories slots (may be null → skipped)
* @param cosmeticArmor serialized Cosmetic Armor slots (may be null → skipped)
* @param attachments serialized NeoForge attachments (may be null → skipped)
*/
/**
* Writes pre-snapshotted mod data to the DB, guarded by last_server to prevent
* stale servers from overwriting fresher data after a player switched servers.
*/
public static void writeModSnapshot(String uuid, String accessoriesData, String cosmeticArmor, String attachments, int serverId) throws SQLException {
// FIX ANTI-DUPLICATION: Only write if this server still owns the player.
// Uses UPDATE + INSERT IGNORE pattern guarded by last_server subquery.
if (accessoriesData != null) {
writeGuardedModData(uuid, "accessories", accessoriesData, serverId);
}
if (cosmeticArmor != null) {
writeGuardedModData(uuid, "cosmeticarmor", cosmeticArmor, serverId);
}
if (attachments != null) {
writeGuardedModData(uuid, "neoforge_attachments", attachments, serverId);
}
}
/** Backwards-compatible overload (no server guard — used by direct store methods). */
public static void writeModSnapshot(String uuid, String accessoriesData, String cosmeticArmor, String attachments) throws SQLException {
if (accessoriesData != null) {
JDBCsetUp.executePreparedUpdate(
"REPLACE INTO " + Tables.modPlayerData() + " (uuid, mod_id, data_value) VALUES (?, ?, ?)",
uuid, "accessories", accessoriesData);
}
if (cosmeticArmor != null) {
JDBCsetUp.executePreparedUpdate(
"REPLACE INTO " + Tables.modPlayerData() + " (uuid, mod_id, data_value) VALUES (?, ?, ?)",
uuid, "cosmeticarmor", cosmeticArmor);
}
if (attachments != null) {
JDBCsetUp.executePreparedUpdate(
"REPLACE INTO " + Tables.modPlayerData() + " (uuid, mod_id, data_value) VALUES (?, ?, ?)",
uuid, "neoforge_attachments", attachments);
}
}
private static void writeGuardedModData(String uuid, String modId, String data, int serverId) throws SQLException {
// FIX: Handle legacy rows with last_server IS NULL (same pattern as writeSnapshotToDB)
String serverGuard = "(last_server=? OR last_server IS NULL)";
// Update existing row only if this server still owns the player
JDBCsetUp.executePreparedUpdate(
"UPDATE " + Tables.modPlayerData() + " SET data_value=? WHERE uuid=? AND mod_id=? AND EXISTS (SELECT 1 FROM " + Tables.playerData() + " WHERE uuid=? AND " + serverGuard + ")",
data, uuid, modId, uuid, serverId);
// Insert if row doesn't exist yet (first save)
JDBCsetUp.executePreparedUpdate(
"INSERT IGNORE INTO " + Tables.modPlayerData() + " (uuid, mod_id, data_value) SELECT ?, ?, ? FROM " + Tables.playerData() + " WHERE uuid=? AND " + serverGuard,
uuid, modId, data, uuid, serverId);
}
// ============================
// Convenience methods
// ============================
/**
* Saves all mod-specific data for a player synchronously.
* Called on logout and server shutdown (main thread — entity reads are safe here).
*/
public static void storeAll(Player player) {
storeAccessories(player);
storeCosmeticArmor(player);
storeNeoForgeAttachments(player);
}
/**
* Restores all mod-specific data for a player.
* Called on join.
*/
public static void restoreAll(Player player) {
restoreAccessories(player);
restoreCosmeticArmor(player);
restoreNeoForgeAttachments(player);
}
}

1449
src/main/java/vip/fubuki/playersync/sync/addons/ModsSupport.java Normal file
View File

File diff suppressed because it is too large Load Diff

131
src/main/java/vip/fubuki/playersync/util/CrashRecovery.java Normal file
View File

@ -0,0 +1,131 @@
package vip.fubuki.playersync.util;
import vip.fubuki.playersync.PlayerSync;
import vip.fubuki.playersync.config.JdbcConfig;
import java.sql.ResultSet;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Crash-recovery + shutdown-hook helper.
*
* <p>Installs a JVM shutdown hook that flushes pending saves and writes a
* graceful-shutdown marker into {@code server_info}. On next startup, scans
* {@code player_data} for rows stuck at {@code online=1} on this server and
* clears them — covers {@code kill -9} / OOM / JVM abort scenarios where the
* normal ServerStoppingEvent path never ran.
*
* <p>Companion of {@link HeartbeatService} which keeps {@code server_info.last_update}
* fresh so peer servers can detect this one as alive.
*
* @author vyrriox
*/
public final class CrashRecovery {
private CrashRecovery() {}
private static final AtomicBoolean HOOK_INSTALLED = new AtomicBoolean(false);
private static volatile Runnable flushCallback;
/**
* Registers a JVM shutdown hook. Called once from PlayerSync.onServerStarting
* AFTER the DB pool is up. The {@code flushTask} is invoked on JVM shutdown —
* use it to snapshot all still-online players synchronously (no async executor,
* the pool may already be draining).
*/
public static void installShutdownHook(Runnable flushTask) {
if (!HOOK_INSTALLED.compareAndSet(false, true)) return;
flushCallback = flushTask;
Thread hook = new Thread(() -> {
try {
PlayerSync.LOGGER.warn("[crash-recovery] JVM shutdown hook fired — flushing pending saves");
SyncLogger.playerEvent("SYSTEM", "JVM_SHUTDOWN_HOOK", "Flushing pending saves before JVM exit");
if (flushCallback != null) {
try {
flushCallback.run();
} catch (Throwable t) {
PlayerSync.LOGGER.error("[crash-recovery] flush callback threw", t);
}
}
// Mark this server as gracefully stopped so peers know it's dead.
try {
JDBCsetUp.executePreparedUpdate(
"UPDATE " + Tables.serverInfo() + " SET enable=0, last_update=? WHERE id=?",
System.currentTimeMillis(), JdbcConfig.SERVER_ID.get());
} catch (Exception e) {
PlayerSync.LOGGER.warn("[crash-recovery] could not mark server stopped: {}", e.getMessage());
}
} catch (Throwable t) {
// NEVER let the hook throw — it would block JVM exit.
PlayerSync.LOGGER.error("[crash-recovery] hook failed", t);
}
}, "PlayerSync-shutdown-hook");
hook.setDaemon(false); // MUST be non-daemon: daemon threads are killed on exit
Runtime.getRuntime().addShutdownHook(hook);
PlayerSync.LOGGER.info("[crash-recovery] JVM shutdown hook installed");
}
/**
* Scans {@code player_data} for orphaned online=1 rows on this server and
* clears them. Called from PlayerSync.onServerStarting AFTER the tables are
* created. This is the recovery path for players who were online when the
* server was killed ungracefully (kill -9, OOM, host reboot).
*/
public static void clearOrphanedOnlineFlags() {
int serverId = JdbcConfig.SERVER_ID.get();
try {
// Count first so we know what we're about to clear.
int count = 0;
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT COUNT(*) AS c FROM " + Tables.playerData() + " WHERE last_server=? AND online=1",
serverId)) {
ResultSet rs = qr.resultSet();
if (rs.next()) count = rs.getInt("c");
}
JDBCsetUp.executePreparedUpdate(
"UPDATE " + Tables.playerData() + " SET online=0 WHERE last_server=? AND online=1",
serverId);
if (count > 0) {
PlayerSync.LOGGER.warn("[crash-recovery] cleared {} orphan online=1 rows from previous session (server_id={})",
count, serverId);
SyncLogger.playerEvent("SYSTEM", "ORPHAN_CLEAR",
"Cleared " + count + " online=1 rows left by previous session crash");
} else {
PlayerSync.LOGGER.info("[crash-recovery] no orphan online=1 rows found — previous shutdown was clean");
}
} catch (Exception e) {
PlayerSync.LOGGER.error("[crash-recovery] failed to scan for orphans", e);
}
}
/**
* Reports peer servers whose heartbeat is stale. Informational — useful to
* surface zombie server_ids that could trip doPlayerJoin's poll. Called once
* on startup.
*/
public static void reportZombiePeers(long staleAfterMs) {
try (JDBCsetUp.QueryResult qr = JDBCsetUp.executePreparedQuery(
"SELECT id, last_update FROM " + Tables.serverInfo() + " WHERE enable=1 AND id<>?",
JdbcConfig.SERVER_ID.get())) {
ResultSet rs = qr.resultSet();
long now = System.currentTimeMillis();
int zombies = 0;
while (rs.next()) {
int id = rs.getInt("id");
long last = rs.getLong("last_update");
long age = now - last;
if (id == 0 || age > staleAfterMs) {
zombies++;
PlayerSync.LOGGER.warn("[crash-recovery] peer server_id={} is zombie (last_update age={}ms, enabled=true)",
id, age);
}
}
if (zombies > 0) {
SyncLogger.playerEvent("SYSTEM", "ZOMBIE_PEERS", zombies + " peer server(s) appear stale");
}
} catch (Exception e) {
PlayerSync.LOGGER.warn("[crash-recovery] zombie peer scan failed: {}", e.getMessage());
}
}
}

75
src/main/java/vip/fubuki/playersync/util/HeartbeatService.java Normal file
View File

@ -0,0 +1,75 @@
package vip.fubuki.playersync.util;
import vip.fubuki.playersync.PlayerSync;
import vip.fubuki.playersync.config.JdbcConfig;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Periodic {@code server_info.last_update} heartbeat.
*
* <p>Runs on a dedicated single-threaded scheduler at a fixed interval so peer
* servers can detect this server as alive via {@code isPeerServerStale()} in
* {@code VanillaSync.doPlayerJoin}. Without this, a server that stops issuing
* updates (e.g. hung main thread) would be treated as alive indefinitely by
* rejoining players on other servers, causing the 30s poll timeouts seen in
* production logs.
*
* @author vyrriox
*/
public final class HeartbeatService {
private HeartbeatService() {}
/**
* Heartbeat period: configurable via {@code heartbeat_interval_seconds}.
* Paired with {@code peer_stale_threshold_seconds}.
*/
private static long currentPeriodMs() {
try {
return JdbcConfig.HEARTBEAT_INTERVAL_SECONDS.get() * 1000L;
} catch (Throwable t) {
return 30_000L;
}
}
private static final AtomicBoolean RUNNING = new AtomicBoolean(false);
private static ScheduledExecutorService scheduler;
public static void start() {
if (!RUNNING.compareAndSet(false, true)) return;
scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
Thread t = new Thread(r, "PlayerSync-heartbeat");
t.setDaemon(true);
t.setPriority(Thread.MIN_PRIORITY);
return t;
});
long period = currentPeriodMs();
scheduler.scheduleAtFixedRate(HeartbeatService::tick, period, period, TimeUnit.MILLISECONDS);
PlayerSync.LOGGER.info("[heartbeat] started (period={}ms, server_id={})", period, JdbcConfig.SERVER_ID.get());
}
public static void stop() {
if (!RUNNING.compareAndSet(true, false)) return;
if (scheduler != null) {
scheduler.shutdownNow();
scheduler = null;
}
PlayerSync.LOGGER.info("[heartbeat] stopped");
}
private static void tick() {
try {
int serverId = JdbcConfig.SERVER_ID.get();
JDBCsetUp.executePreparedUpdate(
"UPDATE " + Tables.serverInfo() + " SET last_update=?, enable=1 WHERE id=?",
System.currentTimeMillis(), serverId);
} catch (Throwable t) {
// Do not kill the scheduler on a transient DB error — log and retry next tick.
PlayerSync.LOGGER.warn("[heartbeat] tick failed: {}", t.getMessage());
}
}
}

334
src/main/java/vip/fubuki/playersync/util/JDBCsetUp.java
View File

@ -1,97 +1,313 @@
package vip.fubuki.playersync.util; package vip.fubuki.playersync.util;
import com.mojang.logging.LogUtils;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.slf4j.Logger;
import vip.fubuki.playersync.config.JdbcConfig; import vip.fubuki.playersync.config.JdbcConfig;
import java.sql.*; import java.sql.*;
import org.slf4j.Logger; /**
* JDBC utility backed by HikariCP connection pool.
import com.mojang.logging.LogUtils; *
* Why HikariCP instead of the old manual pool?
* - Old pool called conn.isValid(2) on every borrow → SELECT 1 round-trip → visible as
* "pingInternal" in Spark profiler (~1% server thread constantly).
* - HikariCP uses TCP keepalive and only validates idle connections at a configurable
* interval (keepaliveTime=5min), never on hot-path queries.
* - Automatic reconnection, proper idle-connection eviction, and thread-safe internals
* are all handled by HikariCP without manual LinkedBlockingQueue management.
*/
public class JDBCsetUp { public class JDBCsetUp {
private static final Logger LOGGER = LogUtils.getLogger(); private static final Logger LOGGER = LogUtils.getLogger();
private static volatile HikariDataSource dataSource;
// -------------------------------------------------------------------------
// Pool lifecycle
// -------------------------------------------------------------------------
/** /**
* Returns a connection to the MySQL server. * Initialises the HikariCP pool. Must be called once after the MySQL database
* @param selectDatabase if true, the returned URL includes the configured database name. * has been created (i.e. at the end of the CREATE DATABASE step in PlayerSync).
* @return a Connection object with the database explicitly selected. * Safe to call again on server-restart scenarios — closes the old pool first.
* @throws SQLException if a database access error occurs.
*/ */
public static Connection getConnection(boolean selectDatabase) throws SQLException { public static void initPool() {
String dbName = JdbcConfig.DATABASE_NAME.get(); if (dataSource != null && !dataSource.isClosed()) {
// Build the base URL dataSource.close();
String url = "jdbc:mysql://" + JdbcConfig.HOST.get() + ":" + JdbcConfig.PORT.get();
if (selectDatabase && dbName != null && !dbName.isEmpty()) {
url += "/" + dbName;
} }
url += "?useUnicode=true&characterEncoding=utf-8&useSSL=" + JdbcConfig.USE_SSL.get()
+ "&serverTimezone=UTC&allowPublicKeyRetrieval=true"; HikariConfig cfg = new HikariConfig();
Connection conn = DriverManager.getConnection(url, JdbcConfig.USERNAME.get(), JdbcConfig.PASSWORD.get()); cfg.setJdbcUrl(buildUrl(true));
// Ensure that the connection uses the desired database by explicitly issuing "USE dbName" cfg.setUsername(JdbcConfig.USERNAME.get());
if (selectDatabase && dbName != null && !dbName.isEmpty()) { cfg.setPassword(JdbcConfig.PASSWORD.get());
try (Statement st = conn.createStatement()) {
st.execute("USE " + dbName); // FIX PERF (C9): right-sized pool. 25 was oversized; empirical HikariCP rule is
} // ~ cores*2 + spindles. 15 handles 35 concurrent players comfortably and reduces
} // MySQL server-side context switching.
return conn; cfg.setMaximumPoolSize(15);
cfg.setMinimumIdle(4);
// Connection lifecycle
cfg.setConnectionTimeout(10_000L); // 10 s – fail fast on MySQL outage
cfg.setIdleTimeout(300_000L); // 5 min – evict idle connections sooner
cfg.setMaxLifetime(1_800_000L); // 30 min – recycle before MySQL wait_timeout
cfg.setKeepaliveTime(300_000L); // 5 min – ping idle connections (NOT hot path)
cfg.setAutoCommit(true);
cfg.setPoolName("PlayerSync");
// FIX PERF (C9): 25s threshold — covers worst-case doPlayerJoin poll bursts without
// flooding logs with false positives. Previous 10s fired during legitimate 15-30s polls.
cfg.setLeakDetectionThreshold(25_000L);
dataSource = new HikariDataSource(cfg);
LOGGER.info("[PlayerSync] HikariCP pool ready (maxPool={}, minIdle={})",
cfg.getMaximumPoolSize(), cfg.getMinimumIdle());
}
/**
* Closes all pooled connections. Called on server shutdown.
*/
public static void shutdownPool() {
if (dataSource != null && !dataSource.isClosed()) {
dataSource.close();
dataSource = null;
LOGGER.info("[PlayerSync] HikariCP pool closed.");
}
}
/**
* Exposes the HikariCP MBean for monitoring. Returns {@code null} if the
* pool is not initialised or already closed. Used by PoolStatsReporter.
*/
public static com.zaxxer.hikari.HikariPoolMXBean getPoolMXBean() {
try {
if (dataSource == null || dataSource.isClosed()) return null;
return dataSource.getHikariPoolMXBean();
} catch (Throwable t) {
return null;
}
}
// -------------------------------------------------------------------------
// Internal helpers
// -------------------------------------------------------------------------
private static String buildUrl(boolean selectDatabase) {
String dbName = JdbcConfig.DATABASE_NAME.get();
String url = "jdbc:mysql://" + JdbcConfig.HOST.get() + ":" + JdbcConfig.PORT.get();
if (selectDatabase && !dbName.isEmpty()) {
url += "/" + dbName;
}
// No autoReconnect — HikariCP handles reconnection transparently.
// FIX PERF: Added MySQL performance parameters:
// - rewriteBatchedStatements: rewrites batch INSERTs into multi-row (5-30x faster)
// - cachePrepStmts + useServerPrepStmts: server-side prepared statement cache (15-25% CPU reduction)
// - prepStmtCacheSize=256: keeps compiled statements in cache across queries
// - useCompression: compresses network traffic (40-60% reduction for large NBT blobs)
// - tcpNoDelay: disable Nagle's algorithm for lower latency
url += "?useUnicode=true&characterEncoding=utf-8&useSSL=" + JdbcConfig.USE_SSL.get()
+ "&serverTimezone=UTC&allowPublicKeyRetrieval=true"
+ "&rewriteBatchedStatements=true"
+ "&cachePrepStmts=true"
+ "&useServerPrepStmts=true"
+ "&prepStmtCacheSize=256"
+ "&prepStmtCacheSqlLimit=2048"
+ "&useCompression=true"
+ "&tcpNoDelay=true";
return url;
}
/**
* Returns a connection from the HikariCP pool (selectDatabase=true)
* or a raw DriverManager connection (selectDatabase=false, used only for
* startup DDL that must run without a selected database).
*
* With HikariCP, calling connection.close() returns the connection to the
* pool — no separate returnConnection() call needed.
*/
public static Connection getConnection(boolean selectDatabase) throws SQLException {
if (!selectDatabase) {
// Raw connection for DDL that runs before/without the pool database
return DriverManager.getConnection(
buildUrl(false), JdbcConfig.USERNAME.get(), JdbcConfig.PASSWORD.get());
}
if (dataSource == null || dataSource.isClosed()) {
throw new SQLException("[PlayerSync] HikariCP pool is not initialised — call initPool() first.");
}
return dataSource.getConnection();
} }
// Default connection always includes the database.
public static Connection getConnection() throws SQLException { public static Connection getConnection() throws SQLException {
return getConnection(true); return getConnection(true);
} }
/** // -------------------------------------------------------------------------
* Executes a query using a connection that includes the database. // Query helpers (API unchanged — callers need no modification)
*/ // -------------------------------------------------------------------------
public static QueryResult executeQuery(String sql) throws SQLException {
LOGGER.trace(sql);
Connection connection = getConnection(); // With database selected (and "USE" already run)
PreparedStatement queryStatement = connection.prepareStatement(sql);
ResultSet resultSet = queryStatement.executeQuery();
return new QueryResult(connection, resultSet);
}
/** public static QueryResult executeQuery(String sqlFormatString, Object... args) throws SQLException {
* Executes an update using a connection that includes the database. String sql = String.format(sqlFormatString, args);
*/
public static void executeUpdate(String sql) throws SQLException {
LOGGER.trace(sql); LOGGER.trace(sql);
try (Connection connection = getConnection()) { // With database selected Connection connection = getConnection();
try (PreparedStatement updateStatement = connection.prepareStatement(sql)) { try {
updateStatement.executeUpdate(); PreparedStatement stmt = connection.prepareStatement(sql);
} ResultSet rs = stmt.executeQuery();
return new QueryResult(connection, stmt, rs);
} catch (SQLException e) {
try { connection.close(); } catch (SQLException ignored) {}
throw e;
} }
} }
/** private static void executeUpdateInternal(boolean selectDatabase, String sqlFormatString, Object... args) throws SQLException {
* Executes an update using a connection that does NOT include a default database. String sql = String.format(sqlFormatString, args);
* This method is used for commands like "CREATE DATABASE IF NOT EXISTS ..." LOGGER.trace(sql);
*/ try (Connection conn = getConnection(selectDatabase);
PreparedStatement stmt = conn.prepareStatement(sql)) {
stmt.executeUpdate();
// conn.close() is called by try-with-resources:
// - pool connection → returned to HikariCP pool
// - raw connection → truly closed
}
}
public static void executeUpdate(String sqlFormatString, Object... args) throws SQLException {
executeUpdateInternal(true, sqlFormatString, args);
}
/** Overload used by startup DDL that must bypass the pool (selectDatabase=false). */
public static void executeUpdate(String sql, int dummy) throws SQLException { public static void executeUpdate(String sql, int dummy) throws SQLException {
LOGGER.trace(sql); LOGGER.trace(sql);
try (Connection connection = getConnection(false)) { // Without default database try (Connection conn = getConnection(false);
try (PreparedStatement updateStatement = connection.prepareStatement(sql)) { PreparedStatement stmt = conn.prepareStatement(sql)) {
updateStatement.executeUpdate(); stmt.executeUpdate();
}
}
public static void update(String sql, String... argument) throws SQLException {
LOGGER.trace(sql);
try (Connection conn = getConnection();
PreparedStatement stmt = conn.prepareStatement(sql)) {
for (int i = 0; i < argument.length; i++) {
stmt.setString(i + 1, argument[i]);
} }
stmt.executeUpdate();
}
}
public static void executePreparedUpdate(String sql, Object... params) throws SQLException {
executePreparedUpdateRet(sql, params);
}
/**
* Variant of {@link #executePreparedUpdate(String, Object...)} that returns the
* number of rows affected. Used by admin commands (clearorphans, peerkill, wipe)
* to report meaningful counts to the operator.
*/
public static int executePreparedUpdateRet(String sql, Object... params) throws SQLException {
LOGGER.trace(sql);
try (Connection conn = getConnection();
PreparedStatement stmt = conn.prepareStatement(sql)) {
for (int i = 0; i < params.length; i++) {
stmt.setObject(i + 1, params[i]);
}
return stmt.executeUpdate();
} }
} }
/** /**
* A helper method for updates with parameters. * FIX PERF: Execute multiple SQL statements in a SINGLE transaction on ONE connection.
* Previously, writeSnapshotToDB called executePreparedUpdate 4-8 times per player,
* each opening a new connection from the pool. With 35 players: 140-280 connection
* borrows + network round-trips. This batches them into 1 connection + 1 commit.
*
* Each entry is {sql, params...}. All execute in order within one transaction.
* If any fails, the entire batch is rolled back.
*
* @return array of per-statement affected-row counts (parallel to {@code statements}).
* Callers can inspect the first entry to detect silent no-ops caused by
* {@code AND last_server=?} guards blocking a stale write.
*/ */
public static void update(String sql, String... argument) throws SQLException { public static int[] executeBatchTransaction(Object[]... statements) throws SQLException {
LOGGER.trace(sql); int[] counts = new int[statements.length];
try (Connection connection = getConnection()) { // With database selected try (Connection conn = getConnection()) {
PreparedStatement updateStatement = connection.prepareStatement(sql); conn.setAutoCommit(false);
for (int i = 0; i < argument.length; i++) { try {
updateStatement.setString(i + 1, argument[i]); for (int idx = 0; idx < statements.length; idx++) {
Object[] entry = statements[idx];
String sql = (String) entry[0];
LOGGER.trace(sql);
try (PreparedStatement stmt = conn.prepareStatement(sql)) {
for (int i = 1; i < entry.length; i++) {
stmt.setObject(i, entry[i]);
}
counts[idx] = stmt.executeUpdate();
}
}
conn.commit();
} catch (SQLException e) {
try { conn.rollback(); } catch (SQLException rbEx) {
LOGGER.error("[PlayerSync] Rollback failed while handling batch transaction error", rbEx);
}
throw e;
} finally {
conn.setAutoCommit(true);
} }
updateStatement.executeUpdate(); }
return counts;
}
public static QueryResult executePreparedQuery(String sql, Object... params) throws SQLException {
LOGGER.trace(sql);
Connection conn = getConnection();
try {
PreparedStatement stmt = conn.prepareStatement(sql);
for (int i = 0; i < params.length; i++) {
stmt.setObject(i + 1, params[i]);
}
ResultSet rs = stmt.executeQuery();
return new QueryResult(conn, stmt, rs);
} catch (SQLException e) {
try { conn.close(); } catch (SQLException ignored) {}
throw e;
} }
} }
public record QueryResult(Connection connection, ResultSet resultSet) { // -------------------------------------------------------------------------
// QueryResult — holds connection open until caller closes it
// -------------------------------------------------------------------------
/**
* Auto-closeable holder for a live query result.
* Closing it releases the ResultSet and PreparedStatement, then calls
* connection.close() which returns the connection to the HikariCP pool.
*/
public record QueryResult(
Connection connection,
PreparedStatement preparedStatement,
ResultSet resultSet
) implements AutoCloseable {
@Override
public void close() {
if (resultSet != null) {
try { resultSet.close(); } catch (SQLException e) {
LOGGER.error("[PlayerSync] Error closing ResultSet", e);
}
}
if (preparedStatement != null) {
try { preparedStatement.close(); } catch (SQLException e) {
LOGGER.error("[PlayerSync] Error closing PreparedStatement", e);
}
}
if (connection != null) {
try { connection.close(); } catch (SQLException e) {
LOGGER.error("[PlayerSync] Error returning connection to pool", e);
}
}
}
} }
} }

67
src/main/java/vip/fubuki/playersync/util/LocalJsonUtil.java
View File

@ -2,31 +2,58 @@ package vip.fubuki.playersync.util;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.function.Function;
public class LocalJsonUtil { public class LocalJsonUtil {
public static Map<String,String> StringToMap(String param) { private static <K> Map<K, String> stringToGenericMap(String param, Function<String, K> keyParser) {
Map<String,String> map = new HashMap<>(); Map<K, String> map = new HashMap<>();
String s1 = param.substring(1,param.length()-1);
String s2 = s1.trim(); // check if string is at least minimal json
String[] split = s2.split(","); if (param == null || param.length() < 2 || param.equals("{}")) {
for (int i = split.length - 1; i >= 0; i--) { return map;
String trim = split[i].trim(); }
String[] split1 = trim.split("=");
map.put(split1[0],split1[1]); // extract string within outermost json brackets {}
String s1 = param.substring(param.indexOf('{')+1, param.lastIndexOf('}')).trim();
if (s1.isEmpty()) {
return map;
}
// split all json elements
for (String split : s1.split(",")) {
String trim = split.trim();
// only check for the first "=" as the values also contain additional "="
int equalIndex = trim.indexOf('=');
if (equalIndex < 0)
continue;
String key = trim.substring(0, equalIndex);
String value = trim.substring(equalIndex + 1);
// FIX M-1: Catch parse exceptions per-entry to prevent one malformed key
// from emptying the entire map (e.g. cosmetic armor slots all lost)
try {
map.put(keyParser.apply(key), value);
} catch (Exception e) {
// Skip malformed entries instead of crashing the whole parse
}
} }
return map; return map;
} }
public static Map<Integer,String> StringToEntryMap(String param) { public static Map<String, String> StringToMap(String param) {
Map<Integer,String> map = new HashMap<>(); return stringToGenericMap(param, Function.identity());
String s1 = param.substring(1,param.length()-1); }
String s2 = s1.trim();
String[] split = s2.split(","); public static Map<Integer, String> StringToEntryMap(String param) {
for (int i = split.length - 1; i >= 0; i--) { return stringToGenericMap(param, Integer::parseInt);
String trim = split[i].trim(); }
String[] split1 = trim.split("=");
map.put(Integer.parseInt(split1[0]),split1[1]); public static String cleanSnbt(String snbt) {
} if (snbt == null) return null;
return map;
return snbt.replaceAll(",\\s*\\{\"\":\"\"}", "")
.replaceAll("\\{\"\":\"\"}\\s*,", "")
.replaceAll("\\{\"\":\"\"}", "");
} }
} }

90
src/main/java/vip/fubuki/playersync/util/PeriodicSaveService.java Normal file
View File

@ -0,0 +1,90 @@
package vip.fubuki.playersync.util;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerPlayer;
import net.neoforged.neoforge.server.ServerLifecycleHooks;
import vip.fubuki.playersync.PlayerSync;
import vip.fubuki.playersync.config.JdbcConfig;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Independent scheduler that triggers a full periodic flush for every online
* player at {@code auto_save_interval_minutes} intervals.
*
* <p>This is decoupled from NeoForge's {@code PlayerEvent.SaveToFile} so the
* cadence is predictable and configurable — NeoForge's event fires on the
* vanilla autosave tick, which an admin may have tuned elsewhere. We delegate
* the actual save work to the main thread via {@code server.execute(...)} so
* snapshots run on the safe thread, then the save itself hops to the BG pool
* via the usual {@code PlayerEvent.SaveToFile} path.
*
* @author vyrriox
*/
public final class PeriodicSaveService {
private PeriodicSaveService() {}
private static final AtomicBoolean RUNNING = new AtomicBoolean(false);
private static ScheduledExecutorService scheduler;
public static void start() {
int minutes = JdbcConfig.AUTO_SAVE_INTERVAL_MINUTES.get();
if (minutes <= 0) {
PlayerSync.LOGGER.info("[periodic-save] disabled (auto_save_interval_minutes=0)");
return;
}
if (!RUNNING.compareAndSet(false, true)) return;
scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
Thread t = new Thread(r, "PlayerSync-periodic-save");
t.setDaemon(true);
t.setPriority(Thread.MIN_PRIORITY);
return t;
});
long periodMs = minutes * 60_000L;
// First tick after one full period, not immediately — gives the server
// time to finish startup before we start scheduling DB work.
scheduler.scheduleAtFixedRate(PeriodicSaveService::tick, periodMs, periodMs, TimeUnit.MILLISECONDS);
PlayerSync.LOGGER.info("[periodic-save] started (interval={}min)", minutes);
}
public static void stop() {
if (!RUNNING.compareAndSet(true, false)) return;
if (scheduler != null) {
scheduler.shutdownNow();
scheduler = null;
}
PlayerSync.LOGGER.info("[periodic-save] stopped");
}
private static void tick() {
try {
MinecraftServer server = ServerLifecycleHooks.getCurrentServer();
if (server == null || !server.isRunning()) return;
// Hop to main thread — snapshots must happen on server thread.
// PHASE 7 PERF: skip the whole tick if no one is online.
if (server.getPlayerList().getPlayers().isEmpty()) return;
// PHASE 18: instead of hopping to main thread and snapshotting every player
// in one tick (the lag spike every 10 min), ENQUEUE all online players into
// the existing 1-player/tick staggered auto-save queue. Drain happens in
// onServerTick at a rate of 1 player per tick (20/sec), so 35 players take
// 1.75s to fully process — imperceptible per-tick.
server.execute(() -> {
try {
int before = server.getPlayerList().getPlayerCount();
vip.fubuki.playersync.sync.VanillaSync.enqueueAllOnlineForStaggeredSave(server);
PlayerSync.LOGGER.info("[periodic-save] enqueued {} players for staggered save", before);
SyncLogger.playerEvent("SYSTEM", "PERIODIC_TICK",
"Enqueued " + before + " player(s) for staggered save");
} catch (Throwable t) {
PlayerSync.LOGGER.error("[periodic-save] tick body failed", t);
}
});
} catch (Throwable t) {
PlayerSync.LOGGER.warn("[periodic-save] scheduling tick failed: {}", t.getMessage());
}
}
}

96
src/main/java/vip/fubuki/playersync/util/PoolStatsReporter.java Normal file
View File

@ -0,0 +1,96 @@
package vip.fubuki.playersync.util;
import com.zaxxer.hikari.HikariPoolMXBean;
import vip.fubuki.playersync.PlayerSync;
import java.lang.reflect.Method;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Periodic reporter that logs executor + HikariCP stats every 5 minutes into
* the PlayerSync sync.log. Lets admins spot queue saturation or pool
* exhaustion trends without waiting for a crash. Non-invasive — pure read-only.
*
* @author vyrriox
*/
public final class PoolStatsReporter {
private PoolStatsReporter() {}
private static final AtomicBoolean RUNNING = new AtomicBoolean(false);
private static ScheduledExecutorService scheduler;
public static void start() {
int minutes;
try {
minutes = vip.fubuki.playersync.config.JdbcConfig.POOL_STATS_INTERVAL_MINUTES.get();
} catch (Throwable t) {
minutes = 5;
}
if (minutes <= 0) {
PlayerSync.LOGGER.info("[pool-stats] disabled (pool_stats_interval_minutes=0)");
return;
}
if (!RUNNING.compareAndSet(false, true)) return;
scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
Thread t = new Thread(r, "PlayerSync-pool-stats");
t.setDaemon(true);
t.setPriority(Thread.MIN_PRIORITY);
return t;
});
long periodMs = minutes * 60_000L;
scheduler.scheduleAtFixedRate(PoolStatsReporter::tick, periodMs, periodMs, TimeUnit.MILLISECONDS);
PlayerSync.LOGGER.info("[pool-stats] reporter started (period={}ms)", periodMs);
}
public static void stop() {
if (!RUNNING.compareAndSet(true, false)) return;
if (scheduler != null) {
scheduler.shutdownNow();
scheduler = null;
}
}
private static void tick() {
try {
// Pull executor stats via reflection — VanillaSync.executorService is package-private static
ThreadPoolExecutor exec = getExecutor();
int active = exec != null ? exec.getActiveCount() : -1;
int queue = exec != null ? exec.getQueue().size() : -1;
int idle = exec != null ? exec.getPoolSize() - exec.getActiveCount() : -1;
HikariPoolMXBean hikari = JDBCsetUp.getPoolMXBean();
int hActive = hikari != null ? hikari.getActiveConnections() : -1;
int hIdle = hikari != null ? hikari.getIdleConnections() : -1;
SyncLogger.poolStats(active, queue, idle, hActive, hIdle);
// Warn if queue is getting dangerously full
if (queue > 400) {
PlayerSync.LOGGER.warn("[pool-stats] executor queue high: {}/512 — risk of CallerRunsPolicy blocking main thread", queue);
SyncLogger.warnPlayer("SYSTEM", "Executor queue high: " + queue + "/512");
}
if (hActive >= 0 && hActive >= 14) {
PlayerSync.LOGGER.warn("[pool-stats] HikariCP active connections high: {}/15 — risk of connection starvation", hActive);
SyncLogger.warnPlayer("SYSTEM", "HikariCP active: " + hActive + "/15");
}
} catch (Throwable t) {
PlayerSync.LOGGER.warn("[pool-stats] tick failed: {}", t.getMessage());
}
}
private static ThreadPoolExecutor getExecutor() {
try {
Class<?> c = Class.forName("vip.fubuki.playersync.sync.VanillaSync");
java.lang.reflect.Field f = c.getDeclaredField("executorService");
f.setAccessible(true);
Object o = f.get(null);
if (o instanceof ThreadPoolExecutor tpe) return tpe;
} catch (Throwable ignored) {}
return null;
}
}

282
src/main/java/vip/fubuki/playersync/util/SyncLogger.java Normal file
View File

@ -0,0 +1,282 @@
package vip.fubuki.playersync.util;
import vip.fubuki.playersync.config.JdbcConfig;
import java.io.*;
import java.nio.file.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Dedicated file logger for PlayerSync diagnostics.
* Writes to logs/playersync/sync.log with automatic rotation (max 10MB per file, 5 files kept).
*
* Tracks: saves, restores, errors, potential duplications, data loss warnings,
* cross-server race conditions, and performance metrics.
*
* Thread-safe: uses a lock-free queue + async flush to avoid blocking the main thread.
*
* @author vyrriox
*/
public class SyncLogger {
private static final String LOG_DIR = "logs/playersync";
private static final String LOG_FILE = "sync.log";
private static final long MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
private static final int MAX_FILES = 5;
private static final DateTimeFormatter TIME_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
// Lock-free queue for async writes (no main thread blocking)
private static final ConcurrentLinkedQueue<String> writeQueue = new ConcurrentLinkedQueue<>();
private static final AtomicBoolean initialized = new AtomicBoolean(false);
private static Path logPath;
// FIX PERF (C3): Dedicated daemon scheduler so log() never opens/closes the file on
// the caller thread. Previous impl called flushQueue() inline → every log call from
// the main thread opened a FileWriter, wrote, and closed synchronously.
private static final ScheduledExecutorService FLUSH_EXEC = Executors.newSingleThreadScheduledExecutor(r -> {
Thread t = new Thread(r, "PlayerSync-logflush");
t.setDaemon(true);
t.setPriority(Thread.MIN_PRIORITY);
return t;
});
// -------------------------------------------------------------------------
// Initialization
// -------------------------------------------------------------------------
public static void init() {
if (initialized.getAndSet(true)) return;
try {
Path dir = Paths.get(LOG_DIR);
Files.createDirectories(dir);
logPath = dir.resolve(LOG_FILE);
rotateIfNeeded();
writeRaw("=".repeat(80));
writeRaw("PlayerSync Log — Server ID: " + JdbcConfig.SERVER_ID.get() + " — Started: " + LocalDateTime.now().format(TIME_FMT));
writeRaw("=".repeat(80));
// FIX PERF (C3): single background flush every 500ms — no file I/O on hot path.
FLUSH_EXEC.scheduleWithFixedDelay(SyncLogger::flushQueue, 500, 500, TimeUnit.MILLISECONDS);
} catch (Exception e) {
System.err.println("[PlayerSync] Failed to initialize SyncLogger: " + e.getMessage());
}
}
// -------------------------------------------------------------------------
// Public API — categorized log methods
// -------------------------------------------------------------------------
/** Normal sync operations (save/restore completed successfully) */
public static void info(String message, Object... args) {
log("INFO", message, args);
}
/** Warnings that may indicate issues (timeouts, fallbacks, edge cases) */
public static void warn(String message, Object... args) {
log("WARN", message, args);
}
/** Errors that caused data loss or corruption */
public static void error(String message, Object... args) {
log("ERROR", message, args);
}
/** Potential duplication detected — highest severity */
public static void dupeRisk(String playerUuid, String detail) {
log("DUPE_RISK", "[{}] {}", playerUuid, detail);
}
/** Potential data loss detected */
public static void dataLoss(String playerUuid, String detail) {
log("DATA_LOSS", "[{}] {}", playerUuid, detail);
}
/** Cross-server race condition event */
public static void raceCondition(String playerUuid, String detail) {
log("RACE", "[{}] {}", playerUuid, detail);
}
/** Performance metric */
public static void perf(String operation, long durationMs) {
if (durationMs > 50) { // Only log slow operations (> 50ms)
log("PERF_SLOW", "{} took {}ms", operation, durationMs);
}
}
/** Player join/leave tracking */
public static void playerEvent(String playerUuid, String eventType, String detail) {
log("EVENT", "[{}] {} — {}", playerUuid, eventType, detail);
}
// -------------------------------------------------------------------------
// Save tracking — logs every save with metadata for debugging
// -------------------------------------------------------------------------
public static void saveStarted(String playerUuid, String saveType) {
log("SAVE", "[{}] {} started", playerUuid, saveType);
}
public static void saveCompleted(String playerUuid, String saveType, long durationMs) {
log("SAVE", "[{}] {} completed in {}ms", playerUuid, saveType, durationMs);
}
public static void saveFailed(String playerUuid, String saveType, String reason) {
log("SAVE_FAIL", "[{}] {} FAILED: {}", playerUuid, saveType, reason);
}
public static void saveSkipped(String playerUuid, String saveType, String reason) {
log("SAVE_SKIP", "[{}] {} skipped: {}", playerUuid, saveType, reason);
}
/** Logs when a write was blocked by the last_server guard (stale server tried to write) */
public static void guardBlocked(String playerUuid, int thisServerId, String detail) {
log("GUARD", "[{}] Write blocked (server={}) — {}", playerUuid, thisServerId, detail);
}
// -------------------------------------------------------------------------
// Restore tracking
// -------------------------------------------------------------------------
public static void restoreStarted(String playerUuid) {
log("RESTORE", "[{}] Data restore started", playerUuid);
}
public static void restoreCompleted(String playerUuid, long durationMs) {
log("RESTORE", "[{}] Data restore completed in {}ms", playerUuid, durationMs);
}
public static void restoreFailed(String playerUuid, String reason) {
log("RESTORE_FAIL", "[{}] Data restore FAILED: {}", playerUuid, reason);
}
// -------------------------------------------------------------------------
// Phase 5: structured diagnostic events
// -------------------------------------------------------------------------
/** Force-close of a container on player logout (anti-duplication). */
public static void containerForceClosed(String playerUuid, String reason) {
log("CONTAINER_CLOSE", "[{}] {}", playerUuid, reason);
}
/** Mod-compat save skipped because capability/handler was unavailable. */
public static void modCompatSkip(String playerUuid, String modId, String reason) {
log("MOD_SKIP", "[{}] {} — {}", playerUuid, modId, reason);
}
/** Mod-compat save succeeded with metadata (e.g. slot count, NBT keys). */
public static void modCompatSaved(String playerUuid, String modId, String detail) {
log("MOD_SAVE", "[{}] {} — {}", playerUuid, modId, detail);
}
/** Mod-compat restore succeeded with metadata. */
public static void modCompatRestored(String playerUuid, String modId, String detail) {
log("MOD_RESTORE", "[{}] {} — {}", playerUuid, modId, detail);
}
/** RS2/backpack/SS storage-level save detail (keyed by storage UUID, not player). */
public static void storageSave(String storageUuid, String kind, String detail) {
log("STORAGE", "[{}] {} — {}", storageUuid, kind, detail);
}
/** Periodic pool / queue status snapshot (every N minutes). */
public static void poolStats(int active, int queueSize, int idle, int hikariActive, int hikariIdle) {
log("POOL", "executor active={} queue={} pool_idle={} | hikari active={} idle={}",
active, queueSize, idle, hikariActive, hikariIdle);
}
/** Generic warning with player context. */
public static void warnPlayer(String playerUuid, String detail) {
log("WARN", "[{}] {}", playerUuid, detail);
}
/** Detected NBT anomaly (suspicious shape / size). */
public static void nbtAnomaly(String playerUuid, String detail) {
log("NBT_ANOMALY", "[{}] {}", playerUuid, detail);
}
// -------------------------------------------------------------------------
// Internal — async file writing
// -------------------------------------------------------------------------
private static void log(String level, String message, Object... args) {
if (!initialized.get()) return;
try {
String formatted = formatMessage(message, args);
String line = String.format("[%s] [%s] [%s] %s",
LocalDateTime.now().format(TIME_FMT),
Thread.currentThread().getName(),
level,
formatted);
writeQueue.add(line);
// FIX PERF (C3): no inline flush — background scheduler drains the queue.
} catch (Exception ignored) {}
}
private static String formatMessage(String template, Object... args) {
if (args == null || args.length == 0) return template;
// Simple {} placeholder replacement (like SLF4J)
StringBuilder sb = new StringBuilder();
int argIdx = 0;
int i = 0;
while (i < template.length()) {
if (i < template.length() - 1 && template.charAt(i) == '{' && template.charAt(i + 1) == '}' && argIdx < args.length) {
sb.append(args[argIdx++]);
i += 2;
} else {
sb.append(template.charAt(i));
i++;
}
}
return sb.toString();
}
private static void flushQueue() {
if (logPath == null) return;
try (BufferedWriter writer = new BufferedWriter(new FileWriter(logPath.toFile(), true))) {
String line;
int count = 0;
while ((line = writeQueue.poll()) != null && count < 100) {
writer.write(line);
writer.newLine();
count++;
}
} catch (IOException ignored) {}
}
private static void writeRaw(String line) {
writeQueue.add(line);
}
private static void rotateIfNeeded() {
if (logPath == null) return;
try {
if (Files.exists(logPath) && Files.size(logPath) > MAX_FILE_SIZE) {
// Rotate: sync.log → sync.1.log → sync.2.log → ... → delete oldest
for (int i = MAX_FILES - 1; i >= 1; i--) {
Path src = Paths.get(LOG_DIR, "sync." + i + ".log");
Path dst = Paths.get(LOG_DIR, "sync." + (i + 1) + ".log");
if (Files.exists(src)) {
if (i == MAX_FILES - 1) {
Files.delete(src);
} else {
Files.move(src, dst, StandardCopyOption.REPLACE_EXISTING);
}
}
}
Files.move(logPath, Paths.get(LOG_DIR, "sync.1.log"), StandardCopyOption.REPLACE_EXISTING);
}
} catch (IOException ignored) {}
}
/** Call on server shutdown to flush remaining entries and stop the background writer. */
public static void shutdown() {
try { FLUSH_EXEC.shutdown(); } catch (Exception ignored) {}
try { FLUSH_EXEC.awaitTermination(2, TimeUnit.SECONDS); } catch (InterruptedException ignored) {}
flushQueue();
}
}

56
src/main/java/vip/fubuki/playersync/util/Tables.java Normal file
View File

@ -0,0 +1,56 @@
package vip.fubuki.playersync.util;
import vip.fubuki.playersync.config.JdbcConfig;
import java.util.regex.Pattern;
/**
* Central source of truth for PlayerSync table names.
*
* <p>Reads the optional {@code table_prefix} config at every call so that
* administrators can safely share a single MySQL database with other mods
* without colliding on generic names such as {@code player_data} or
* {@code server_info}. The prefix defaults to an empty string to preserve
* backward compatibility with existing installations.
*
* <p>Only the <em>table</em> identifier is prefixed. The database schema
* qualifier (if any) must be added by the caller, e.g. via
* {@code "`" + dbName + "`." + Tables.playerData()}.
*
* @author vyrriox
*/
public final class Tables {
private Tables() {}
// FIX PERF: precompile the validation pattern and cache the validated prefix.
// String.matches() recompiles the regex on every call; this was invoked from
// every SQL statement the mod issues (heartbeat, auto-save, join, logout, ...).
// The config value cannot change at runtime, so a lazy singleton cache is safe.
private static final Pattern VALID_PREFIX = Pattern.compile("[A-Za-z0-9_]*");
private static volatile String cachedPrefix;
private static volatile String cachedRaw;
private static String prefix() {
String raw;
try { raw = JdbcConfig.TABLE_PREFIX.get(); }
catch (Exception e) { return ""; }
if (raw == null) raw = "";
// Fast path: same raw value as last call → return cached validated prefix.
String lastRaw = cachedRaw;
if (lastRaw != null && lastRaw.equals(raw)) {
return cachedPrefix;
}
// Validate and cache.
String validated = VALID_PREFIX.matcher(raw).matches() ? raw : "";
cachedPrefix = validated;
cachedRaw = raw;
return validated;
}
public static String playerData() { return prefix() + "player_data"; }
public static String serverInfo() { return prefix() + "server_info"; }
public static String curios() { return prefix() + "curios"; }
public static String backpackData() { return prefix() + "backpack_data"; }
public static String modPlayerData() { return prefix() + "mod_player_data"; }
}

6
src/main/resources/assets/playersync/lang/en_us.json
View File

@ -1,5 +1,7 @@
{ {
"playersync.item_placeholder_description": "Item is unknown on this server. This can either\nbe a modded item, an added, or a removed vanilla\nitem.\nThis voucher will automatically be replaced with\nthe corresponding item when joining a server\nwhere the item is known.","playersync.placeholder_titel_override": "Item Voucher", "playersync.item_placeholder_description": "Item is unknown on this server. This can either\nbe a modded item, an added, or a removed vanilla\nitem.\nThis voucher will automatically be replaced with\nthe corresponding item when joining a server\nwhere the item is known.",
"playersync.item_placeholder_title": "Item Voucher", "playersync.item_placeholder_title": "Item Voucher",
"playersync.already_online": "You can't join more than one synchronization server at the same time." "playersync.already_online": "You can't join more than one synchronization server at the same time.",
"playersync.sqlexception": "SqlException detected!Connection lost,please contact with your admin.",
"playersync.wrong_entity_status": "An error occurred while creating playerEntity in the world,please login again."
} }

8
src/main/resources/assets/playersync/lang/zh_cn.json
View File

@ -1,3 +1,7 @@
{ {
"playersync.already_online": "你不能同时加入多个同步的服务器。" "playersync.item_placeholder_description": "物品在此服务器未知。这可能是一个模组物品,或是不同版本的原版物品。\n这张券将会在加入可识别此物品的服务器后自动替换为对应物品。",
} "playersync.item_placeholder_title": "物品券",
"playersync.already_online": "你不能同时加入多个同步的服务器。",
"playersync.sqlexception": "检测到Sql异常!连接已中断,请联系管理员",
"playersync.wrong_entity_status": "在世界中尝试创建玩家实体时发生了错误,请尝试重新进入"
}

12
src/main/resources/playersync.mixins.json Normal file
View File

@ -0,0 +1,12 @@
{
"required": true,
"package": "vip.fubuki.playersync.mixin",
"compatibilityLevel": "JAVA_21",
"refmap": "thirst.refmap.json",
"mixins": [],
"client": [],
"injectors": {
"defaultRequire": 1
},
"minVersion": "0.8.4"
}

45
src/main/templates/META-INF/mods.toml → src/main/templates/META-INF/neoforge.mods.toml
View File

@ -1,13 +1,7 @@
# This is an example mods.toml file. It contains the data relating to the loading mods.
# There are several mandatory fields (#mandatory), and many more that are optional (#optional).
# The overall format is standard TOML format, v0.5.0.
# Note that there are a couple of TOML lists in this file.
# Find more information on toml format here: https://github.com/toml-lang/toml
# The name of the mod loader type to load - for regular FML @Mod mods it should be javafml
modLoader="javafml" #mandatory modLoader="javafml" #mandatory
# A version range to match for said mod loader - for regular FML @Mod it will be the forge version # A version range to match for said mod loader - for regular FML @Mod it will be the FML version. This is currently 2.
loaderVersion="${loader_version_range}" #mandatory This is typically bumped every Minecraft version by Forge. See our download page for lists of versions. loaderVersion="${loader_version_range}" #mandatory
# The license for you mod. This is mandatory metadata and allows for easier comprehension of your redistributive properties. # The license for you mod. This is mandatory metadata and allows for easier comprehension of your redistributive properties.
# Review your options at https://choosealicense.com/. All rights reserved is the default copyright stance, and is thus the default here. # Review your options at https://choosealicense.com/. All rights reserved is the default copyright stance, and is thus the default here.
@ -28,7 +22,7 @@ version="${mod_version}" #mandatory
# A display name for the mod # A display name for the mod
displayName="${mod_name}" #mandatory displayName="${mod_name}" #mandatory
# A URL to query for updates for this mod. See the JSON update specification https://docs.minecraftforge.net/en/latest/misc/updatechecker/ # A URL to query for updates for this mod. See the JSON update specification https://docs.neoforged.net/docs/misc/updatechecker/
#updateJSONURL="https://change.me.example.invalid/updates.json" #optional #updateJSONURL="https://change.me.example.invalid/updates.json" #optional
# A URL for the "homepage" for this mod, displayed in the mod UI # A URL for the "homepage" for this mod, displayed in the mod UI
@ -36,34 +30,37 @@ displayURL="https://github.com/mlus-asuka/PlayerSync"
# A file name (in the root of the mod JAR) containing a logo for display # A file name (in the root of the mod JAR) containing a logo for display
logoFile="logo.png" #optional logoFile="logo.png" #optional
# A text field displayed in the mod UI # A text field displayed in the mod UI
credits="Based on Mysql" #optional credits="Based on Mysql" #optional
# A text field displayed in the mod UI # A text field displayed in the mod UI
authors="${mod_authors}" #optional authors="${mod_authors}" #optional
# Display Test controls the display for your mod in the server connection screen
# MATCH_VERSION means that your mod will cause a red X if the versions on client and server differ. This is the default behaviour and should be what you choose if you have server and client elements to your mod.
# IGNORE_SERVER_VERSION means that your mod will not cause a red X if it's present on the server but not on the client. This is what you should use if you're a server only mod.
# IGNORE_ALL_VERSION means that your mod will not cause a red X if it's present on the client or the server. This is a special case and should only be used if your mod has no server component.
# NONE means that no display test is set on your mod. You need to do this yourself, see IExtensionPoint.DisplayTest for more information. You can define any scheme you wish with this value.
# IMPORTANT NOTE: this is NOT an instruction as to which environments (CLIENT or DEDICATED SERVER) your mod loads on. Your mod should load (and maybe do nothing!) whereever it finds itself.
displayTest="IGNORE_SERVER_VERSION"
# The description text for the mod (multi line!) (#mandatory) # The description text for the mod (multi line!) (#mandatory)
description='''${mod_description}''' description='''${mod_description}'''
# The [[mixins]] block allows you to declare your mixin config to FML so that it gets loaded.
[[mixins]]
config="${mod_id}.mixins.json"
# The [[accessTransformers]] block allows you to declare where your AT file is.
# If this block is omitted, a fallback attempt will be made to load an AT from META-INF/accesstransformer.cfg
#[[accessTransformers]]
#file="META-INF/accesstransformer.cfg"
# The coremods config file path is not configurable and is always loaded from META-INF/coremods.json
# A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional. # A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
[[dependencies.${mod_id}]] #optional [[dependencies.${mod_id}]] #optional
# the modid of the dependency # the modid of the dependency
modId="forge" #mandatory modId="neoforge" #mandatory
# Does this dependency have to exist - if not, ordering below must be specified # The type of the dependency. Can be one of "required", "optional", "incompatible" or "discouraged" (case insensitive).
mandatory=true #mandatory # 'required' requires the mod to exist, 'optional' does not
# 'incompatible' will prevent the game from loading when the mod exists, and 'discouraged' will show a warning
type="required" #mandatory
# Optional field describing why the dependency is required or why it is incompatible # Optional field describing why the dependency is required or why it is incompatible
# reason="..." # reason="..."
# The version range of the dependency # The version range of the dependency
versionRange="${forge_version_range}" #mandatory versionRange="${neo_version_range}" #mandatory
# An ordering relationship for the dependency. # An ordering relationship for the dependency.
# BEFORE - This mod is loaded BEFORE the dependency # BEFORE - This mod is loaded BEFORE the dependency
# AFTER - This mod is loaded AFTER the dependency # AFTER - This mod is loaded AFTER the dependency
@ -74,7 +71,7 @@ description='''${mod_description}'''
# Here's another dependency # Here's another dependency
[[dependencies.${mod_id}]] [[dependencies.${mod_id}]]
modId="minecraft" modId="minecraft"
mandatory=true type="required"
# This version range declares a minimum of the current minecraft version up to but not including the next major version # This version range declares a minimum of the current minecraft version up to but not including the next major version
versionRange="${minecraft_version_range}" versionRange="${minecraft_version_range}"
ordering="NONE" ordering="NONE"