#!/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())