commit 43ac0412788794ecd9a77e3b844235e4d1f7d295 Author: Théo Gastinel <264859180+gastinelt@users.noreply.github.com> Date: Sun Oct 11 01:57:24 2026 +0200 Premier commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6babfc7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,66 @@ + +# --- double-push : exclusions generiques (secrets, builds, binaires, gros fichiers) --- +target/ +node_modules/ +build/ +build-*/ +dist/ +out/ +.gradle/ +.idea/ +venv/ +.venv/ +env/ +__pycache__/ +*.pyc +.cache/ +.next/ +.env +.env.* +!.env.example +accounts.json +Clee.API/ +*.pem +*.key +*.p12 +*.pfx +*.jks +*.keystore +keystore.properties +id_rsa* +id_ed25519* +*.kdbx +*.odt +*.sqlite +*.sqlite3 +*.db +*.log +*.exe +*.dll +*.msi +*.jar +*.zip +*.7z +*.rar +*.tar +*.tar.gz +*.tgz +*.gguf +*.safetensors +*.onnx +*.pt +*.pth +*.bin +*.iso +*.gws +*.apk +*.aab +*.so +*.o +*.a +*.lib +*.pdb +*.mp4 +*.mkv +*.wav +*.flac diff --git a/README.md b/README.md new file mode 100644 index 0000000..55fece7 --- /dev/null +++ b/README.md @@ -0,0 +1,47 @@ +# Migration d'UUID (totoche10) + +Script : `migrer-uuid.py` (Python 3 stdlib, NBT lu/écrit à la main) + `retour.sh`. +Sur le serveur : `~/staging/migration-uuid/` (copie de test dans `copie/`, marquée par le fichier `COPIE-MIGRATION`). + +| UUID | Origine | +|---|---| +| `25b71084-eb1b-4988-8cfe-458026f7e514` | Microsoft (online-mode=true, données jusqu'au 09/10 21:20) | +| `e1769fd1-91f1-377b-b2ac-999a4a7c9c9e` | hors-ligne `OfflinePlayer:totoche10` (données depuis le 09/10) | + +## Quand l'utiliser +**Uniquement** au moment de repasser en `online-mode=true` (ou l'inverse), **serveur ARRÊTÉ**, **avec le feu vert de Théo**. +Ne jamais lancer `--appliquer` serveur en marche : le serveur réécrirait playerdata/claims à l'arrêt. + +## Ce qui est traité +ops.json, whitelist.json, usercache.json, usernamecache.json, banned-players.json (doublons retirés), +`neW512/gastineltpa-homes.json`, tous les `neW512/data/*.dat` contenant l'UUID (dont `gastinelclaims.dat` : +18 `owner` = 17 claims + 1 liste d'amis), `playerdata/*.dat|.dat_old`, `advancements`, `stats`, `skinrestorer`. +UUID reconnus sous forme int[4], chaîne, clé de compound et paires `…Most/…Least`. +Non traité : régions `.mca` (entités apprivoisées/propriétaires dans le monde), autres mods (gravestone, etc.). + +## Playerdata +- `--garder les-deux` (défaut) : l'inventaire de l'UUID **source** gagne ; l'ancien fichier de l'UUID cible + et le fichier source sont conservés en `.dat.avant-migration`. +- `--garder source` : idem (la source gagne). +- `--garder cible` : l'inventaire déjà présent sous l'UUID d'arrivée gagne (ex. en `--vers-microsoft`, l'ancien + inventaire Microsoft du 09/10 plutôt que le récent hors-ligne). + +## Commandes +```bash +cd ~/staging/migration-uuid +D=~/server-infra/stacks/minecraft-neoforge/data +python3 migrer-uuid.py --dossier "$D" --vers-microsoft # À BLANC (défaut) : n'écrit rien, OK serveur en marche +# le jour J, serveur arrêté + feu vert : +python3 migrer-uuid.py --dossier "$D" --vers-microsoft --appliquer --serveur-arrete-confirme +bash retour.sh "$D" "$D/sauvegarde-migration-AAAAMMJJ-HHMMSS" # retour arrière +``` +`--appliquer` refuse si `docker ps` montre `minecraft-neoforge` (ou si docker ne répond pas), et refuse un dossier +qui n'est pas une copie sans `--serveur-arrete-confirme`. Sauvegarde préalable dans `sauvegarde-migration-/` +(+ `MANIFESTE.json` utilisé par `retour.sh`). + +## PIÈGE : l'ami à pseudo spécial +La liste d'amis de totoche10 contient `e65f2350-…` = `OfflinePlayer:gabybou201` (sans guillemet). +Or le joueur se connecte réellement en `gabybou201"` (avec guillemet) → UUID hors-ligne `128c0f10-9643-37ff-941d-afa49cdb30ec` +(usercache du 10/10 00:28). **L'amitié actuelle ne vise donc pas le compte réellement utilisé.** +Le script ne touche pas aux UUID des amis. En repassant en online-mode, gabybou aura un 3ᵉ UUID (Microsoft, inconnu +ici) : il faudra refaire `/friend add` une fois qu'il s'est connecté, ou ajouter un mappage dédié après vérification. diff --git a/appliquer-pendant-arret.sh b/appliquer-pendant-arret.sh new file mode 100644 index 0000000..f30a27b --- /dev/null +++ b/appliquer-pendant-arret.sh @@ -0,0 +1,172 @@ +#!/bin/bash +# Déploiement des correctifs « pseudos avec guillemet » PENDANT l'arrêt de maintenance de Minecraft. +# GastinelClaims 1.1.1 + GastinelTpa 1.2.1 + correction de la liste d'amis de totoche10 (e65f2350 -> 128c0f10). +# +# Usage : appliquer-pendant-arret.sh [--a-blanc] [--retour] +# (sans option) : applique ; idempotent (relancé, il constate que tout est déjà en place). +# --a-blanc : vérifie tout, n'écrit rien. +# --retour : remet les anciens jars et la liste d'amis d'origine. +# Garde-fou : NE FAIT RIEN si le conteneur minecraft-neoforge n'est pas arrêté (ou si docker ne répond pas). +# Si une étape échoue pendant l'application, tout est restauré (retour automatique) et le code de sortie est 1. +# Ce script ne démarre ni n'arrête JAMAIS Minecraft. +set -u +ST="${PSEUDOS_ST:-$HOME/staging/deploiement-pseudos}" # PSEUDOS_ST : tests uniquement +MC="$HOME/server-infra/stacks/minecraft-neoforge" +D="${PSEUDOS_DATA:-$MC/data}" # PSEUDOS_DATA : uniquement pour les tests sur une copie +MODS="$D/mods" +JARS="$ST/jars" +LOG="$ST/appliquer.log" +SUF=".avant-pseudos" +MODE=appliquer +for a in "$@"; do + case "$a" in + --retour) MODE=retour ;; + --a-blanc) MODE=blanc ;; + *) echo "option inconnue : $a" >&2; exit 2 ;; + esac +done +mkdir -p "$ST" +log() { echo "$(date '+%F %T') [pseudos] $*" | tee -a "$LOG"; } + +# ---- garde-fou : conteneur ARRÊTÉ (état connu et non-running) +etat=$(docker inspect -f '{{.State.Running}}' minecraft-neoforge 2>/dev/null) || etat="inconnu" +# Test sur une COPIE (dossier marqué COPIE-MIGRATION, jamais le vrai) : le garde-fou docker est contourné +if [ "${PSEUDOS_TEST_COPIE:-0}" = 1 ] && [ -f "$D/COPIE-MIGRATION" ]; then etat=false; fi +if [ "$etat" != "false" ]; then + log "Minecraft n'est pas arrêté (état : $etat) : je ne touche à rien." + exit 0 +fi + +MODIDS="gastinelclaims gastineltpa" +JAR_gastinelclaims="gastinelclaims-neoforge-1.21.1-1.1.1.jar" +JAR_gastineltpa="gastineltpa-neoforge-1.21.1-1.2.1.jar" +VER_gastinelclaims="1.1.1" +VER_gastineltpa="1.2.1" + +# modId déclaré dans un jar (neoforge.mods.toml) -> affiche "modId version" +info_jar() { + python3 -I - "$1" <<'PY' +import re, sys, zipfile +try: + z = zipfile.ZipFile(sys.argv[1]) + t = z.read("META-INF/neoforge.mods.toml").decode("utf-8", "replace") + mid = re.search(r'modId\s*=\s*"([^"]+)"', t) + ver = re.search(r'^version\s*=\s*"([^"]+)"', t, re.M) + print((mid.group(1) if mid else "?"), (ver.group(1) if ver else "?")) +except Exception as e: + print("? ?") +PY +} + +hash_de() { sha256sum "$1" | cut -d' ' -f1; } + +# ---- jars actifs (dans mods/, finissant par .jar) déclarant un modId donné +jars_du_modid() { + local want="$1" f + for f in "$MODS"/*.jar; do + [ -f "$f" ] || continue + set -- $(info_jar "$f") + [ "$1" = "$want" ] && echo "$f" + done +} + +# ---- retour arrière +retour() { + log "RETOUR ARRIÈRE" + local m jar f + for m in $MODIDS; do + eval "jar=\$JAR_$m" + # retire le jar du correctif (seulement s'il est bien le nôtre) + if [ -f "$MODS/$jar" ] && [ "$(hash_de "$MODS/$jar")" = "$(grep " $jar\$" "$JARS/SHA256SUMS" | cut -d' ' -f1)" ]; then + rm -f "$MODS/$jar" && log "retiré $jar" + fi + # remet les anciens jars sauvegardés + for f in "$MODS"/${m}-neoforge-*.jar"$SUF"; do + [ -f "$f" ] || continue + mv -f "$f" "${f%$SUF}" && log "restauré ${f%$SUF}" + done + done + # liste d'amis : fichier de sauvegarde si le .dat n'a pas changé depuis, sinon mappage inverse + local dat="$D/neW512/data/gastinelclaims.dat" + if [ -f "$dat$SUF" ]; then + if [ -f "$ST/etat-hash-dat-apres" ] && [ "$(hash_de "$dat")" = "$(cat "$ST/etat-hash-dat-apres")" ]; then + cp -p "$dat$SUF" "$dat" && log "liste d'amis restaurée depuis la sauvegarde" + else + python3 -I "$ST/corriger-amis-gabybou.py" --dossier "$D" --appliquer --inverse >>"$LOG" 2>&1 \ + && log "liste d'amis : mappage inverse appliqué (le .dat avait changé)" \ + || log "ATTENTION : retour de la liste d'amis impossible automatiquement" + fi + fi + rm -f "$ST/etat-applique" "$ST/etat-hash-dat-apres" + log "retour terminé" +} + +if [ "$MODE" = retour ]; then retour; exit 0; fi + +# ---- vérifications préalables (rien n'est modifié ici) +echec=0 +[ -d "$MODS" ] || { log "ERREUR : $MODS absent"; exit 1; } +[ -f "$JARS/SHA256SUMS" ] || { log "ERREUR : $JARS/SHA256SUMS absent"; exit 1; } +for m in $MODIDS; do + eval "jar=\$JAR_$m"; eval "ver=\$VER_$m" + src="$JARS/$jar" + if [ ! -s "$src" ]; then log "ERREUR : $src absent ou vide"; echec=1; continue; fi + attendu=$(grep " $jar\$" "$JARS/SHA256SUMS" | cut -d' ' -f1) + reel=$(hash_de "$src") + if [ -z "$attendu" ] || [ "$attendu" != "$reel" ]; then log "ERREUR : hash de $jar ($reel) différent de l'attendu ($attendu)"; echec=1; continue; fi + set -- $(info_jar "$src") + if [ "$1" != "$m" ] || [ "$2" != "$ver" ]; then log "ERREUR : $jar déclare modId=$1 version=$2 (attendu $m $ver)"; echec=1; continue; fi + log "jar OK : $jar ($(stat -c %s "$src") octets, sha256 ${reel:0:12}…)" +done +[ -f "$ST/corriger-amis-gabybou.py" ] && [ -f "$ST/migrer-uuid.py" ] || { log "ERREUR : script d'amis ou migrer-uuid.py absent dans $ST"; echec=1; } +[ -f "$D/neW512/data/gastinelclaims.dat" ] || { log "ERREUR : gastinelclaims.dat absent"; echec=1; } +[ $echec -eq 0 ] || { log "Vérifications en échec : rien modifié."; exit 1; } + +if [ "$MODE" = blanc ]; then + for m in $MODIDS; do eval "jar=\$JAR_$m"; log "(à blanc) jars actifs du mod $m : $(jars_du_modid "$m" | tr '\n' ' ')-> $jar"; done + python3 -I "$ST/corriger-amis-gabybou.py" --dossier "$D" 2>&1 | tee -a "$LOG" + log "(à blanc) terminé, rien écrit." + exit 0 +fi + +# ---- application +fail() { log "ÉCHEC : $* -> retour arrière automatique"; retour; exit 1; } + +for m in $MODIDS; do + eval "jar=\$JAR_$m" + src="$JARS/$jar" + # 1) anciens jars du même mod_id (quel que soit leur nom) : renommés en .avant-pseudos (jamais écrasés) + for old in $(jars_du_modid "$m"); do + [ "$(basename "$old")" = "$jar" ] && continue + if [ -e "$old$SUF" ]; then fail "sauvegarde $old$SUF déjà présente"; fi + mv "$old" "$old$SUF" || fail "renommage de $old" + log "ancien jar mis de côté : $(basename "$old")$SUF" + done + # 2) nouveau jar (copie atomique, mêmes droits que les autres) + if [ -f "$MODS/$jar" ] && [ "$(hash_de "$MODS/$jar")" = "$(hash_de "$src")" ]; then + log "$jar déjà en place (identique)" + else + if [ -f "$MODS/$jar" ]; then + [ -e "$MODS/$jar$SUF" ] && fail "sauvegarde $jar$SUF déjà présente" + mv "$MODS/$jar" "$MODS/$jar$SUF" || fail "mise de côté de $jar différent" + fi + cp "$src" "$MODS/.$jar.tmp" || fail "copie de $jar" + chmod 644 "$MODS/.$jar.tmp" + mv -f "$MODS/.$jar.tmp" "$MODS/$jar" || fail "mise en place de $jar" + [ "$(hash_de "$MODS/$jar")" = "$(hash_de "$src")" ] || fail "hash de $jar après copie" + log "installé : $jar" + fi + # 3) un seul jar actif pour ce mod_id + n=$(jars_du_modid "$m" | wc -l) + [ "$n" -eq 1 ] || fail "$n jars actifs pour le mod $m (attendu 1)" +done + +# 4) liste d'amis +python3 -I "$ST/corriger-amis-gabybou.py" --dossier "$D" --appliquer >>"$LOG" 2>&1 || fail "correctif de la liste d'amis" +# hash du .dat juste après la correction (sert au retour) : seulement à la première application +[ -f "$ST/etat-applique" ] || hash_de "$D/neW512/data/gastinelclaims.dat" > "$ST/etat-hash-dat-apres" +log "liste d'amis vérifiée/corrigée" + +date '+%F %T' > "$ST/etat-applique" +log "TERMINÉ : GastinelClaims 1.1.1, GastinelTpa 1.2.1, amis corrigés. Minecraft n'a pas été touché." +exit 0 diff --git a/corriger-amis-gabybou.py b/corriger-amis-gabybou.py new file mode 100644 index 0000000..3aa13ea --- /dev/null +++ b/corriger-amis-gabybou.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""Correctif dédié : dans la liste d'AMIS de totoche10, e65f2350-… (« gabybou201 » sans guillemet) +devient 128c0f10-… (« gabybou201" », le compte réellement utilisé). RIEN d'autre n'est modifié : +ni les claims (owner), ni les autres fichiers, ni les amis des autres joueurs. + +Python 3 stdlib. Réutilise le lecteur/écrivain NBT de migrer-uuid.py (même dossier). + + --dossier DIR racine des données (contient neW512/data/gastinelclaims.dat) + --appliquer écrit (défaut : À BLANC). Refuse si le conteneur minecraft-neoforge tourne, + sauf dossier marqué COPIE-MIGRATION. + --retour restaure gastinelclaims.dat depuis gastinelclaims.dat.avant-pseudos + --inverse applique le mappage inverse (sans toucher à la sauvegarde existante) +Idempotent : relancé après application, il ne trouve plus rien à faire. +Sauvegarde : .avant-pseudos (créée une seule fois, jamais écrasée). +""" +import argparse, importlib.util, os, shutil, subprocess, sys + +PROP = "e1769fd1-91f1-377b-b2ac-999a4a7c9c9e" # totoche10 (hors-ligne) +ANCIEN = "e65f2350-d100-3a51-ae80-50fbcce624c0" # OfflinePlayer:gabybou201 +NOUVEAU = "128c0f10-9643-37ff-941d-afa49cdb30ec" # OfflinePlayer:gabybou201" +CONTENEUR = "minecraft-neoforge" + + +def charger_nbt(): + ici = os.path.dirname(os.path.abspath(__file__)) + spec = importlib.util.spec_from_file_location("migrer_uuid", os.path.join(ici, "migrer-uuid.py")) + m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m) + return m + + +def serveur_en_ligne(): + try: + r = subprocess.run(["docker", "ps", "--filter", "name=^%s$" % CONTENEUR, "--format", "{{.Names}}"], + capture_output=True, text=True, timeout=15) + if r.returncode != 0: + return True + return CONTENEUR in r.stdout + except Exception: + return True + + +def trouver_listes_amis(tag, out): + """Toutes les entrées de listes nommées 'friends' (compound avec owner + friends).""" + if tag.t == 10: + for k, s in tag.v.items(): + if k == "friends" and s.t == 9 and s.v[0] == 10: + for ent in s.v[1]: + out.append(ent) + trouver_listes_amis(s, out) + elif tag.t == 9: + for s in tag.v[1]: + trouver_listes_amis(s, out) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("--dossier", required=True) + ap.add_argument("--appliquer", action="store_true") + ap.add_argument("--retour", action="store_true") + ap.add_argument("--inverse", action="store_true", + help="mappage inverse (128c0f10 -> e65f2350) : retour logique si le .dat a changé depuis") + a = ap.parse_args() + global ANCIEN, NOUVEAU + if a.inverse: + ANCIEN, NOUVEAU = NOUVEAU, ANCIEN + D = os.path.abspath(a.dossier) + dat = os.path.join(D, "neW512", "data", "gastinelclaims.dat") + bak = dat + ".avant-pseudos" + copie = os.path.exists(os.path.join(D, "COPIE-MIGRATION")) + if not os.path.exists(dat): + print("ERREUR : %s absent" % dat); return 2 + if (a.appliquer or a.retour) and serveur_en_ligne() and not copie: + print("REFUS : Minecraft tourne (ou docker ne répond pas). Rien n'est modifié."); return 3 + + if a.retour: + if not os.path.exists(bak): + print("Rien à restaurer (%s absent)." % bak); return 0 + shutil.copy2(bak, dat); print("Restauré :", dat); return 0 + + m = charger_nbt() + gz, nom, rac = m.lire_nbt(dat) + ents = []; trouver_listes_amis(rac, ents) + si, di, pi = m.u2ints(ANCIEN), m.u2ints(NOUVEAU), m.u2ints(PROP) + avant_claims = None + modifs = 0 + for ent in ents: + d = ent.v + if "owner" not in d or d["owner"].t != 11 or d["owner"].v != pi: + continue + lst = d["friends"]; et, items = lst.v + valeurs = [it.v for it in items] + a_ancien = si in valeurs + a_nouveau = di in valeurs + print("amis de totoche10 : ancien=%s nouveau=%s (%d amis)" % (a_ancien, a_nouveau, len(items))) + if not a_ancien: + continue + nouveaux = [] + for it in items: + if it.v == si: + if a_nouveau or any(n.v == di for n in nouveaux): + continue # le bon est déjà là : on retire seulement l'ancien + it.v = list(di) + nouveaux.append(it) + lst.v = (et, nouveaux); modifs += 1 + if modifs == 0: + print("RIEN À FAIRE (déjà corrigé ou ancien UUID absent)."); return 0 + if not a.appliquer: + print("À BLANC : 1 liste d'amis serait corrigée (%s -> %s). Rien écrit." % (ANCIEN, NOUVEAU)); return 0 + if not os.path.exists(bak): + shutil.copy2(dat, bak) + m.ecrire_nbt(dat, gz, nom, rac) + print("APPLIQUÉ : %s -> %s dans les amis de totoche10. Sauvegarde : %s" % (ANCIEN, NOUVEAU, bak)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/migrer-uuid.py b/migrer-uuid.py new file mode 100644 index 0000000..9bb7fea --- /dev/null +++ b/migrer-uuid.py @@ -0,0 +1,281 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""Migration d'UUID d'un joueur (totoche10) entre UUID Microsoft et UUID hors-ligne. + +Par défaut : À BLANC (rien n'est écrit). Python 3 stdlib uniquement (NBT lu/écrit à la main). + + --vers-microsoft : e1769fd1-… (hors-ligne) -> 25b71084-… (Microsoft) [défaut] + --vers-horsligne : 25b71084-… -> e1769fd1-… + --dossier DIR : racine des données (contient ops.json, neW512/…). DOIT être une copie + sauf --appliquer --serveur-arrete-confirme sur le vrai dossier. + --garder {source,cible,les-deux} : quel playerdata devient celui de l'UUID cible + source = l'inventaire de l'UUID de départ gagne (ex. le récent hors-ligne en --vers-microsoft) + cible = l'inventaire déjà présent sous l'UUID d'arrivée gagne + les-deux = (défaut) la source gagne MAIS l'ancien fichier cible est conservé en + .dat.avant-migration (rien n'est jamais perdu) + --appliquer : écrit. Refuse si le conteneur Minecraft tourne, si le dossier n'est pas + une copie (fichier COPIE-MIGRATION absent) sauf --serveur-arrete-confirme. + Sauvegarde d'abord tous les fichiers touchés dans /sauvegarde-migration-/. +""" +import argparse, gzip, io, json, os, shutil, struct, subprocess, sys, time, uuid as uuidlib + +MS = "25b71084-eb1b-4988-8cfe-458026f7e514" +HL = "e1769fd1-91f1-377b-b2ac-999a4a7c9c9e" +MONDE = "neW512" +CONTENEUR = "minecraft-neoforge" + +# ---------------------------------------------------------------- NBT minimal +class Tag: + __slots__ = ("t", "v") + def __init__(self, t, v): self.t, self.v = t, v + +def _rs(f): + n = struct.unpack(">H", f.read(2))[0] + return f.read(n).decode("utf-8", "surrogatepass") # MUTF-8 approx (suffisant ici) + +def _ws(f, s): + b = s.encode("utf-8", "surrogatepass"); f.write(struct.pack(">H", len(b))); f.write(b) + +def lire_payload(f, t): + if t == 1: return struct.unpack(">b", f.read(1))[0] + if t == 2: return struct.unpack(">h", f.read(2))[0] + if t == 3: return struct.unpack(">i", f.read(4))[0] + if t == 4: return struct.unpack(">q", f.read(8))[0] + if t == 5: return struct.unpack(">f", f.read(4))[0] + if t == 6: return struct.unpack(">d", f.read(8))[0] + if t == 7: n = struct.unpack(">i", f.read(4))[0]; return bytearray(f.read(n)) + if t == 8: return _rs(f) + if t == 9: + et = f.read(1)[0]; n = struct.unpack(">i", f.read(4))[0] + return (et, [Tag(et, lire_payload(f, et)) for _ in range(n)]) + if t == 10: + d = {} + while True: + ct = f.read(1)[0] + if ct == 0: return d + nom = _rs(f); d[nom] = Tag(ct, lire_payload(f, ct)) + if t == 11: n = struct.unpack(">i", f.read(4))[0]; return list(struct.unpack(">%di" % n, f.read(4 * n))) + if t == 12: n = struct.unpack(">i", f.read(4))[0]; return list(struct.unpack(">%dq" % n, f.read(8 * n))) + raise ValueError("tag NBT inconnu %r" % t) + +def ecrire_payload(f, t, v): + if t == 1: f.write(struct.pack(">b", v)) + elif t == 2: f.write(struct.pack(">h", v)) + elif t == 3: f.write(struct.pack(">i", v)) + elif t == 4: f.write(struct.pack(">q", v)) + elif t == 5: f.write(struct.pack(">f", v)) + elif t == 6: f.write(struct.pack(">d", v)) + elif t == 7: f.write(struct.pack(">i", len(v))); f.write(bytes(v)) + elif t == 8: _ws(f, v) + elif t == 9: + et, items = v; f.write(bytes([et])); f.write(struct.pack(">i", len(items))) + for it in items: ecrire_payload(f, et, it.v) + elif t == 10: + for nom, tg in v.items(): + f.write(bytes([tg.t])); _ws(f, nom); ecrire_payload(f, tg.t, tg.v) + f.write(b"\x00") + elif t == 11: f.write(struct.pack(">i", len(v))); f.write(struct.pack(">%di" % len(v), *v)) + elif t == 12: f.write(struct.pack(">i", len(v))); f.write(struct.pack(">%dq" % len(v), *v)) + +def lire_nbt(chemin): + brut = open(chemin, "rb").read() + gz = brut[:2] == b"\x1f\x8b" + if gz: brut = gzip.decompress(brut) + f = io.BytesIO(brut); t = f.read(1)[0]; nom = _rs(f) + return gz, nom, Tag(t, lire_payload(f, t)) + +def ecrire_nbt(chemin, gz, nom, racine): + f = io.BytesIO(); f.write(bytes([racine.t])); _ws(f, nom); ecrire_payload(f, racine.t, racine.v) + data = f.getvalue() + if gz: data = gzip.compress(data, mtime=0) + tmp = chemin + ".tmp-migration"; open(tmp, "wb").write(data); os.replace(tmp, chemin) + +# représentations d'un UUID dans NBT +def u2ints(u): + b = uuidlib.UUID(u).bytes; return list(struct.unpack(">4i", b)) +def u2longs(u): + b = uuidlib.UUID(u).bytes; return struct.unpack(">2q", b) + +def remplacer_nbt(tag, src, dst, chemin, log): + """Remplace src->dst sous toutes ses formes (int[4], string, Most/Least). Retourne nb.""" + n = 0 + si, di = u2ints(src), u2ints(dst); (sm, sl), (dm, dl) = u2longs(src), u2longs(dst) + if tag.t == 11 and tag.v == si: + tag.v = list(di); log.append(f"{chemin} : int[4] UUID"); return 1 + if tag.t == 8 and src in tag.v: + log.append(f"{chemin} : chaîne {tag.v!r}"); tag.v = tag.v.replace(src, dst); return 1 + if tag.t == 10: + d = tag.v + # paire xxxMost / xxxLeast + for k in list(d): + if k.endswith("Most") and d[k].t == 4 and d[k].v == sm: + kl = k[:-4] + "Least" + if kl in d and d[kl].v == sl: + d[k].v, d[kl].v = dm, dl; log.append(f"{chemin}.{k[:-4]} : Most/Least"); n += 1 + # clés de compound égales à l'UUID + for k in list(d): + if src in k: + nk = k.replace(src, dst) + if nk in d: log.append(f"{chemin} : CONFLIT clé {nk} existe déjà (non fusionné)") + else: + d = {(nk if kk == k else kk): vv for kk, vv in d.items()}; tag.v = d + log.append(f"{chemin} : clé {k}"); n += 1 + for k, sub in tag.v.items(): n += remplacer_nbt(sub, src, dst, f"{chemin}.{k}", log) + elif tag.t == 9: + for i, sub in enumerate(tag.v[1]): n += remplacer_nbt(sub, src, dst, f"{chemin}[{i}]", log) + return n + +def compter_nbt(tag, u): + si = u2ints(u); m, l = u2longs(u); c = 0 + if tag.t == 11 and tag.v == si: return 1 + if tag.t == 8 and u in tag.v: return 1 + if tag.t == 10: + for k, s in tag.v.items(): + if u in k: c += 1 + if k.endswith("Most") and s.t == 4 and s.v == m: c += 1 + c += compter_nbt(s, u) + elif tag.t == 9: + for s in tag.v[1]: c += compter_nbt(s, u) + return c + +# ---------------------------------------------------------------- JSON +def remplacer_json(obj, src, dst, chemin, log): + if isinstance(obj, dict): + res = {} + for k, v in obj.items(): + nk = k + if src in k: + nk = k.replace(src, dst) + if nk in obj: log.append(f"{chemin} : CONFLIT clé {nk} déjà présente -> la source GAGNE, ancienne valeur loggée : {json.dumps(obj[nk], ensure_ascii=False)[:200]}") + else: log.append(f"{chemin} : clé {k} -> {nk}") + res[nk] = remplacer_json(v, src, dst, f"{chemin}.{nk}", log) + return res + if isinstance(obj, list): + out = [remplacer_json(v, src, dst, f"{chemin}[{i}]", log) for i, v in enumerate(obj)] + # dédoublonnage (ops/whitelist/usercache : même uuid deux fois après migration) + vus, dedup = set(), [] + for e in out: + cle = json.dumps(e, sort_keys=True) if not isinstance(e, dict) else e.get("uuid", json.dumps(e, sort_keys=True)) + if cle in vus: log.append(f"{chemin} : doublon retiré {json.dumps(e, ensure_ascii=False)}"); continue + vus.add(cle); dedup.append(e) + return dedup + if isinstance(obj, str) and src in obj: + log.append(f"{chemin} : valeur {obj!r}"); return obj.replace(src, dst) + return obj + +# ---------------------------------------------------------------- plan +def serveur_en_ligne(): + try: + r = subprocess.run(["docker", "ps", "--filter", f"name=^{CONTENEUR}$", "--format", "{{.Names}}"], + capture_output=True, text=True, timeout=15) + if r.returncode != 0: return True, "docker ps a échoué (prudence : considéré EN LIGNE)" + return (CONTENEUR in r.stdout), r.stdout.strip() or "aucun conteneur" + except Exception as e: + return True, f"docker indisponible ({e}) : considéré EN LIGNE" + +def main(): + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + g = ap.add_mutually_exclusive_group() + g.add_argument("--vers-microsoft", action="store_true") + g.add_argument("--vers-horsligne", action="store_true") + m = ap.add_mutually_exclusive_group() + m.add_argument("--a-blanc", action="store_true") + m.add_argument("--appliquer", action="store_true") + ap.add_argument("--dossier", required=True) + ap.add_argument("--garder", choices=["source", "cible", "les-deux"], default="les-deux") + ap.add_argument("--serveur-arrete-confirme", action="store_true", + help="autorise --appliquer sur un dossier qui n'est pas une copie (vrai monde, serveur ARRÊTÉ)") + ap.add_argument("--ignorer-docker", action="store_true", help="tests sur une machine sans le conteneur (copie uniquement)") + a = ap.parse_args() + src, dst = (MS, HL) if a.vers_horsligne else (HL, MS) + D = os.path.abspath(a.dossier); W = os.path.join(D, MONDE) + appliquer = a.appliquer + est_copie = os.path.exists(os.path.join(D, "COPIE-MIGRATION")) + print(f"== migration {src} -> {dst} dossier={D} mode={'APPLIQUER' if appliquer else 'À BLANC'} copie={est_copie} garder={a.garder}") + + if appliquer: + enl, info = serveur_en_ligne() + if enl and not (a.ignorer_docker and est_copie): + sys.exit(f"REFUS : serveur Minecraft en ligne ou état inconnu ({info}). Arrêter le serveur d'abord.") + if not est_copie and not a.serveur_arrete_confirme: + sys.exit("REFUS : le dossier n'est pas une copie (fichier COPIE-MIGRATION absent). " + "Sur le vrai monde : serveur ARRÊTÉ + feu vert de Théo + --serveur-arrete-confirme.") + if os.path.exists(os.path.join(W, "session.lock")) and not est_copie: + print(" note : session.lock présent (normal même serveur arrêté) ; docker a confirmé l'arrêt.") + + actions = [] # (type, chemin, fonction d'écriture) + touches = [] + crees = [] + + # 1) JSON racine + homes + skinrestorer + jsons = [os.path.join(D, n) for n in ("ops.json", "whitelist.json", "usercache.json", "usernamecache.json", "banned-players.json")] + jsons.append(os.path.join(W, "gastineltpa-homes.json")) + for p in jsons: + if not os.path.exists(p): print(f"[absent] {os.path.relpath(p, D)}"); continue + obj = json.load(open(p, encoding="utf-8")); log = [] + nouv = remplacer_json(obj, src, dst, os.path.basename(p), log) + if log: + print(f"[JSON] {os.path.relpath(p, D)} : {len(log)} changement(s)") + for l in log: print(" " + l) + touches.append(p) + actions.append(lambda p=p, nouv=nouv: open(p, "w", encoding="utf-8").write(json.dumps(nouv, indent=2, ensure_ascii=False) + "\n")) + else: print(f"[JSON] {os.path.relpath(p, D)} : rien") + + # 2) NBT data/ (claims, amis…) — tous les .dat de data/ contenant l'UUID + ddir = os.path.join(W, "data") + for n in sorted(os.listdir(ddir)) if os.path.isdir(ddir) else []: + p = os.path.join(ddir, n) + if not n.endswith(".dat") or os.path.getsize(p) > 20_000_000: continue + try: gz, nom, rac = lire_nbt(p) + except Exception as e: print(f"[NBT] data/{n} illisible ({e}) ignoré"); continue + if compter_nbt(rac, src) == 0: continue + log = []; k = remplacer_nbt(rac, src, dst, n, log) + print(f"[NBT] data/{n} : {k} remplacement(s) ; occurrences restantes de la cible déjà présente : {compter_nbt(rac, dst) - k}") + for l in log: print(" " + l) + touches.append(p) + actions.append(lambda p=p, gz=gz, nom=nom, rac=rac: ecrire_nbt(p, gz, nom, rac)) + + # 3) fichiers par joueur : playerdata / advancements / stats / skinrestorer + for sous, ext in (("playerdata", ".dat"), ("playerdata", ".dat_old"), ("advancements", ".json"), ("stats", ".json"), ("skinrestorer", ".json")): + ps, pd = os.path.join(W, sous, src + ext), os.path.join(W, sous, dst + ext) + if not os.path.exists(ps): continue + cible_existe = os.path.exists(pd) + gagnant = "cible" if (a.garder == "cible" and cible_existe) else "source" + desc = f"[{sous}] {src}{ext} ({os.path.getsize(ps)} o, {time.strftime('%d/%m %H:%M', time.localtime(os.path.getmtime(ps)))})" + if cible_existe: + desc += f" vs cible existante ({os.path.getsize(pd)} o, {time.strftime('%d/%m %H:%M', time.localtime(os.path.getmtime(pd)))})" + print(f"{desc} -> gagnant : {gagnant}; ancienne(s) version(s) gardée(s) en .avant-migration") + touches += [ps] + ([pd] if cible_existe else []) + if not cible_existe: crees.append(pd) + def act(ps=ps, pd=pd, cible_existe=cible_existe, gagnant=gagnant, ext=ext): + if cible_existe and not os.path.exists(pd + ".avant-migration"): shutil.copy2(pd, pd + ".avant-migration") + if not os.path.exists(ps + ".avant-migration"): shutil.copy2(ps, ps + ".avant-migration") + if gagnant == "source": + shutil.copy2(ps, pd) + if ext.startswith(".dat"): # corriger un éventuel UUID interne + try: + gz, nom, rac = lire_nbt(pd); lg = [] + if remplacer_nbt(rac, src, dst, "", lg): ecrire_nbt(pd, gz, nom, rac) + except Exception: pass + os.remove(ps) # la source est conservée en .avant-migration + actions.append(act) + + if not actions: + print("== RIEN À FAIRE (déjà migré ? idempotent)"); return 0 + if not appliquer: + print(f"== À BLANC : {len(actions)} action(s), {len(touches)} fichier(s) seraient touchés. Rien écrit."); return 0 + + sv = os.path.join(D, "sauvegarde-migration-" + time.strftime("%Y%m%d-%H%M%S")) + for p in touches: + rel = os.path.relpath(p, D); os.makedirs(os.path.dirname(os.path.join(sv, rel)), exist_ok=True) + shutil.copy2(p, os.path.join(sv, rel)) + json.dump({"src": src, "dst": dst, "fichiers": [os.path.relpath(p, D) for p in touches], + "crees": [os.path.relpath(p, D) for p in crees]}, + open(os.path.join(sv, "MANIFESTE.json"), "w"), indent=2) + print(f"== sauvegarde : {sv} ({len(touches)} fichiers)") + for f in actions: f() + print("== APPLIQUÉ. Retour arrière : retour.sh " + sv) + return 0 + +if __name__ == "__main__": + sys.exit(main()) diff --git a/retour.sh b/retour.sh new file mode 100644 index 0000000..f0e9886 --- /dev/null +++ b/retour.sh @@ -0,0 +1,21 @@ +#!/usr/bin/env bash +# Retour arrière d'une migration : retour.sh +set -euo pipefail +D=$(realpath "$1"); S=$(realpath "$2") +[ -f "$S/MANIFESTE.json" ] || { echo "MANIFESTE.json absent dans $S"; exit 1; } +if docker ps --format '{{.Names}}' 2>/dev/null | grep -qx minecraft-neoforge && [ ! -f "$D/COPIE-MIGRATION" ]; then + echo "REFUS : serveur en ligne"; exit 1; fi +python3 - "$D" "$S" <<'PY' +import json,os,shutil,sys +D,S=sys.argv[1:]; m=json.load(open(os.path.join(S,"MANIFESTE.json"))) +for r in m.get("crees",[]): + p=os.path.join(D,r) + if os.path.exists(p): os.remove(p); print("supprimé (créé par migration)",r) +for r in m["fichiers"]: + shutil.copy2(os.path.join(S,r),os.path.join(D,r)); print("restauré",r) + if os.path.exists(os.path.join(D,r)+".avant-migration"): os.remove(os.path.join(D,r)+".avant-migration") +for r in m.get("crees",[]): + a=os.path.join(D,r)+".avant-migration" + if os.path.exists(a): os.remove(a) +PY +echo "Retour arrière terminé."