282 lignes
15 KiB
Python
282 lignes
15 KiB
Python
#!/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
|
|
<uuid>.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 <dossier>/sauvegarde-migration-<date>/.
|
|
"""
|
|
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())
|