#!/usr/bin/env python3 """Nexthosting: Messreihe zum belegten Speicher von Minecraft-Modpacks. Je Pack genau ein Testserver: ohne Netz und Port, 4 Effizienzkerne, 10 GB, eigener unprivilegierter Benutzer. Installation mit Netz nur fuer den Loader. Bricht ab und wartet, sobald der Rechner staerker ausgelastet ist. Veroeffentlichte Fassung: Pfade und interne Namen sind ersetzt, die Messlogik ist unveraendert. python3 messung.py packs.json [slug ...] """ import atexit, concurrent.futures, hashlib, io, json, os, re, shutil, signal, subprocess, sys, threading, time import urllib.parse, urllib.request, zipfile BASE = '/opt/mp-messung' RUN = BASE + '/run' LOGS = BASE + '/logs' RESULTS = BASE + '/ergebnisse.jsonl' STATE = BASE + '/status.txt' UA = 'modpack-measure/1.0' UID = '1000' # Benutzer "container" im Java-Image; ohne Namen liefert die JVM keine Messdaten CPUS = '16-19' MEM = '10g' HEAP = '8G' LABEL = 'nh-test=modpack' HOSTS = {'cdn.modrinth.com', 'github.com', 'raw.githubusercontent.com', 'gitlab.com'} # Eingriffe je Pack, nur fuer Packs, die ohne sie nicht messbar waren. Alle anderen Packs laufen unveraendert. # Die Texte stehen im Ergebnis jedes Packs im Feld "eingriffe". EINGRIFFE = { 'better-mc-forge-bmc4': { 'ergaenzen': [('temporal-api', '1.6.6')], 'texte': ['Fehlende Pflicht-Bibliothek TemporalAPI 1.6.6 von Modrinth ergänzt (Extra Compat verlangt 1.6.5 bis unter 1.7.0)'], }, 'the-horrors-in-the-fog': { 'entfernen': [r'^ReplayMod-'], 'texte': ['Client-Mod Replay Mod entfernt (Modrinth: server_side=unsupported)'], }, 'homestead': { 'properties': {'max-tick-time': '-1'}, 'texte': ['Watchdog abgeschaltet (max-tick-time=-1), weil der Server sonst beim Laden der 256 Chunks beendet wird'], }, 'zombie-storm-100-days': { 'entfernen': [r'^jecharacters-', r'^fogoverrides-'], 'texte': ['Client-Mod Just Enough Characters entfernt (lädt Client-Klassen, Absturz auf dem Server)', 'Client-Mod Fog Overrides entfernt (lädt Client-Klassen, Absturz auf dem Server)'], }, 'new-berks-dawn': { 'entfernen': [r'^torohealth-', r'^Fastquit-', r'^EnhancedBlockEntities-'], 'texte': ['Client-Mod ToroHealth entfernt (Modrinth: server_side=unsupported)', 'Client-Mod Fastquit entfernt (Modrinth: server_side=unsupported)', 'Client-Mod Enhanced Block Entities entfernt (Modrinth: server_side=unsupported)'], }, 'fom': { 'entfernen': [r'^reforgedplaymod-'], 'texte': ['Client-Mod ReForgedPlay entfernt (bringt die Client-Grafikbibliothek lwjgl-tinyexr mit, die den Serverstart abbricht)'], }, 'horizons1': { 'entfernen': [r'^DistantHorizons-'], 'texte': ['Distant Horizons 2.2.1 entfernt (Unterstützung für dedizierte Server gibt es laut Änderungsliste erst ab 2.3.0)'], }, 'animatecraft-lankeren': { 'entfernen': [r'completeconfig-2\.5\.0\.jar$'], 'ergaenzen': [('completeconfig', '2.5.2')], 'texte': ['Bibliothek CompleteConfig 2.5.0 durch 2.5.2 ersetzt (2.5.0 bricht auf dem Server mit NoSuchFieldError ab)'], }, 'winter-zombies': { 'chunks': 'forge', 'texte': ['Minecraft 1.12.2 kennt /forceload nicht: Chunks mit /forge generate erzeugt, die 256 Ziel-Chunks sind nachgezählt, bleiben aber nicht dauerhaft geladen'], }, } MAX_OTHER_BUSY = 85.0 # Auslastung der Kerne 0-15, auf denen die Kundenserver laufen MIN_AVAIL_GB = 35 MIN_DISK_GB = 40 PACK_TIMEOUT = 45 * 60 START_TIMEOUT = 20 * 60 DEADLINE = time.time() + 16 * 3600 current = {'name': None} class Guard(Exception): pass def log(msg): line = time.strftime('%F %T ') + msg print(line, flush=True) with open(STATE, 'a') as f: f.write(line + '\n') def sh(args, timeout=120, check=True): p = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=timeout, text=True, errors='replace') if check and p.returncode != 0: raise RuntimeError(f'{args[0]} {args[1] if len(args) > 1 else ""}: {p.stdout[-400:]}') return p.stdout def remove_containers(): try: ids = sh(['docker', 'ps', '-aq', '--filter', 'label=' + LABEL], check=False).split() if ids: sh(['docker', 'rm', '-f'] + ids, check=False, timeout=60) except Exception: pass def cleanup(*_): remove_containers() shutil.rmtree(RUN, ignore_errors=True) def on_signal(*_): log('Signal: raeume auf') cleanup() os._exit(1) def watchdog(): while time.time() < DEADLINE: time.sleep(30) log('Zeitlimit: raeume auf') cleanup() os._exit(2) def other_cores(): busy = total = 0 for line in open('/proc/stat'): m = re.match(r'cpu(\d+) (.*)', line) if not m or int(m.group(1)) > 15: continue v = [int(x) for x in m.group(2).split()] total += sum(v[:8]) busy += sum(v[:8]) - v[3] - v[4] return busy, total last_cpu = {'v': other_cores(), 't': time.time()} def other_busy(): """Auslastung der Kerne 0-15 seit der letzten Messung (mindestens 3 Sekunden Abstand).""" if time.time() - last_cpu['t'] < 3: time.sleep(3) now = other_cores() busy, total = now[0] - last_cpu['v'][0], now[1] - last_cpu['v'][1] last_cpu.update(v=now, t=time.time()) return 100.0 * busy / total if total > 0 else 0.0 def pressure(): avail = 0 for line in open('/proc/meminfo'): if line.startswith('MemAvailable:'): avail = int(line.split()[1]) / 1024 / 1024 st = os.statvfs('/') disk = st.f_bavail * st.f_frsize / 1024 ** 3 busy = other_busy() if busy > MAX_OTHER_BUSY: return f'kerne 0-15 zu {busy:.0f} % belegt' if avail < MIN_AVAIL_GB: return f'ram frei {avail:.0f} GB' if disk < MIN_DISK_GB: return f'platte frei {disk:.0f} GB' return None def wait_calm(): waited = False while True: why = pressure() if not why: if waited: log('Node wieder ruhig') return if not waited: log('Warte, Node ausgelastet: ' + why) waited = True time.sleep(30) def fetch(url, dest=None, tries=4, timeout=120): for attempt in range(tries): try: req = urllib.request.Request(url, headers={'User-Agent': UA}) with urllib.request.urlopen(req, timeout=timeout) as r: if dest is None: return r.read() with open(dest, 'wb') as f: shutil.copyfileobj(r, f, 1024 * 256) return dest except Exception: if attempt == tries - 1: raise time.sleep(2 + attempt * 3) def sha512(path): h = hashlib.sha512() with open(path, 'rb') as f: for chunk in iter(lambda: f.read(1024 * 1024), b''): h.update(chunk) return h.hexdigest() def safe_path(root, rel): rel = rel.replace('\\', '/') if not rel or rel.startswith('/') or '..' in rel.split('/'): raise RuntimeError('unsicherer Pfad im Pack: ' + rel) full = os.path.normpath(os.path.join(root, rel)) if not full.startswith(root + os.sep): raise RuntimeError('unsicherer Pfad im Pack: ' + rel) return full def read_ids(z, depth=0): """Mod-IDs, die eine Jar bereitstellt (auch eingebettete), und ihre Pflicht-Abhaengigkeiten.""" ids, deps = set(), set() names = set(z.namelist()) if 'fabric.mod.json' in names: raw = z.read('fabric.mod.json').decode('utf8', 'replace') try: meta = json.loads(raw, strict=False) ids.add(meta.get('id')) ids.update(p if isinstance(p, str) else p.get('id') for p in (meta.get('provides') or [])) deps.update((meta.get('depends') or {}).keys()) except (ValueError, AttributeError): m = re.search(r'"id"\s*:\s*"([^"]+)"', raw) if m: ids.add(m.group(1)) for toml in ('META-INF/mods.toml', 'META-INF/neoforge.mods.toml'): if toml not in names: continue for block in re.split(r'(?m)^\s*\[\[', z.read(toml).decode('utf8', 'replace')): mod = re.search(r'(?m)^\s*modId\s*=\s*"([^"]+)"', block) if not mod: continue if block.startswith('mods'): ids.add(mod.group(1)) elif block.startswith('dependencies'): side = re.search(r'(?mi)^\s*side\s*=\s*"(\w+)"', block) required = re.search(r'(?mi)^\s*mandatory\s*=\s*true', block) or re.search(r'(?mi)^\s*type\s*=\s*"required"', block) if required and not (side and side.group(1).upper() == 'CLIENT'): deps.add(mod.group(1)) if depth == 0: for name in names: if name.endswith('.jar') and (name.startswith('META-INF/jars/') or name.startswith('META-INF/jarjar/')): try: with zipfile.ZipFile(io.BytesIO(z.read(name))) as inner: ids |= read_ids(inner, 1)[0] except (zipfile.BadZipFile, KeyError, OSError): pass ids.discard(None) return ids, deps def prune_client_mods(d, client_paths): mods = os.path.join(d, 'mods') if not os.path.isdir(mods): return 0, 0 meta = {} for name in os.listdir(mods): path = os.path.join(mods, name) if name.endswith('.jar'): try: with zipfile.ZipFile(path) as z: meta[path] = read_ids(z) except (zipfile.BadZipFile, OSError): meta[path] = (set(), set()) # Der "Missing Mods Checker" liegt in manchen Packs direkt bei, oeffnet ein Fenster und bricht jeden Server ab client = {p for p in meta if p in client_paths or any(i.lower().startswith('missingmods') or i.lower() == 'citresewn' for i in meta[p][0])} kept = set(meta) - client provided = set().union(*[meta[p][0] for p in kept]) if kept else set() restored = 0 changed = True while changed: changed = False needed = set().union(*[meta[p][1] for p in kept]) - provided if kept else set() for p in sorted(client): if meta[p][0] & needed: client.discard(p) kept.add(p) provided |= meta[p][0] restored += 1 changed = True break for p in client: os.remove(p) return restored, len(client) def install_pack(pack, d, result): versions = json.loads(fetch(f"https://api.modrinth.com/v2/project/{pack['project_id']}/version")) version = next((v for v in versions if v.get('version_number') == pack['version']), None) if not version: raise RuntimeError('Pack-Version nicht gefunden') file = next((f for f in version['files'] if f.get('primary')), version['files'][0]) mrpack = os.path.join(d, '.pack.mrpack') fetch(file['url'], mrpack) if sha512(mrpack) != file['hashes']['sha512']: raise RuntimeError('Pack-Pruefsumme falsch') with zipfile.ZipFile(mrpack) as z: index = json.loads(z.read('modrinth.index.json')) # Dieselbe Regel wie der Panel-Installer: Client-Mods laut Modrinth-Projekt bleiben weg project_of = lambda f: (re.match(r'https://cdn\.modrinth\.com/data/([A-Za-z0-9]{6,12})/versions/', str((f.get('downloads') or [''])[0])) or [None, None])[1] ids = sorted({project_of(f) for f in index['files'] if project_of(f)}) sides = {} for i in range(0, len(ids), 400): query = urllib.parse.quote(json.dumps(ids[i:i + 400])) for project in json.loads(fetch(f'https://api.modrinth.com/v2/projects?ids={query}')): sides[project['id']] = project.get('server_side') # Erst alles laden. Danach fliegen Client-Mods raus, ausser eine Server-Mod braucht sie laut ihrer eigenen Mod-Datei. in_mods = lambda f: f['path'].replace('\\', '/').lstrip('/').startswith('mods/') env_client = lambda f: (f.get('env') or {}).get('server') == 'unsupported' is_client = lambda f: in_mods(f) and (env_client(f) or sides.get(project_of(f)) == 'unsupported') candidates = [f for f in index['files'] if not env_client(f) or in_mods(f)] client_paths = {safe_path(d, f['path']) for f in candidates if is_client(f)} jobs = [] for f in candidates: url = next((u for u in f['downloads'] if urllib.parse.urlparse(u).hostname in HOSTS), None) if not url: raise RuntimeError('Download-Host nicht erlaubt') jobs.append((url, safe_path(d, f['path']), f['hashes']['sha512'])) def get(job): url, dest, want = job os.makedirs(os.path.dirname(dest), exist_ok=True) fetch(url, dest) if sha512(dest) != want: raise RuntimeError('Mod-Pruefsumme falsch: ' + os.path.basename(dest)) with concurrent.futures.ThreadPoolExecutor(4) as ex: list(ex.map(get, jobs)) for prefix in ('overrides/', 'server-overrides/'): for info in z.infolist(): if info.is_dir() or not info.filename.startswith(prefix): continue dest = safe_path(d, info.filename[len(prefix):]) os.makedirs(os.path.dirname(dest), exist_ok=True) with z.open(info) as src, open(dest, 'wb') as out: shutil.copyfileobj(src, out) os.remove(mrpack) result['bibliotheken_behalten'], removed = prune_client_mods(d, client_paths) return len(jobs) - removed def apply_eingriffe(pack, d, res): e = EINGRIFFE.get(pack['slug']) if not e: return res['eingriffe'] = list(e['texte']) mods = os.path.join(d, 'mods') for muster in e.get('entfernen', []): hits = [f for f in os.listdir(mods) if re.search(muster, f)] if not hits: raise RuntimeError('Eingriff ohne Treffer: ' + muster) for f in hits: os.remove(os.path.join(mods, f)) for project, version in e.get('ergaenzen', []): versions = json.loads(fetch(f'https://api.modrinth.com/v2/project/{project}/version')) match = next((v for v in versions if v.get('version_number') == version and pack['loader'] in v['loaders'] and pack['minecraft'] in v['game_versions']), None) if not match: raise RuntimeError(f'Eingriff: {project} {version} nicht gefunden') file = next((f for f in match['files'] if f.get('primary')), match['files'][0]) dest = safe_path(d, 'mods/' + file['filename']) fetch(file['url'], dest) if sha512(dest) != file['hashes']['sha512']: raise RuntimeError('Mod-Pruefsumme falsch: ' + file['filename']) def box(pack, d, network, name=None): args = ['docker', 'run', '--label', LABEL, '--network', network, '--cpuset-cpus', CPUS, '--cpu-shares', '128', '--memory', MEM, '--memory-swap', MEM, '--pids-limit', '2048', '--cap-drop', 'ALL', '--security-opt', 'no-new-privileges', '--user', f'{UID}:{UID}', '-e', 'HOME=/home/container', '-v', f'{d}:/home/container', '-w', '/home/container'] if name: args += ['--name', name] return args def image(pack): return f"ghcr.io/pterodactyl/yolks:java_{pack['java']}" def install_loader(pack, d): mc, ver, loader = pack['minecraft'], pack['loader_version'], pack['loader'] jar = os.path.join(d, '.installer.jar') if loader == 'fabric': inst = next(v['version'] for v in json.loads(fetch('https://meta.fabricmc.net/v2/versions/installer')) if v.get('stable')) fetch(f'https://maven.fabricmc.net/net/fabricmc/fabric-installer/{inst}/fabric-installer-{inst}.jar', jar) cmd = ['-jar', '.installer.jar', 'server', '-mcversion', mc, '-loader', ver, '-downloadMinecraft'] elif loader == 'forge': fetch(f'https://maven.minecraftforge.net/net/minecraftforge/forge/{mc}-{ver}/forge-{mc}-{ver}-installer.jar', jar) cmd = ['-jar', '.installer.jar', '--installServer'] elif loader == 'neoforge': fetch(f'https://maven.neoforged.net/releases/net/neoforged/neoforge/{ver}/neoforge-{ver}-installer.jar', jar) cmd = ['-jar', '.installer.jar', '--installServer'] else: raise RuntimeError('Loader nicht unterstuetzt: ' + loader) sh(['chown', '-R', f'{UID}:{UID}', d]) out = sh(box(pack, d, 'bridge') + ['--rm', '--entrypoint', 'java', image(pack)] + cmd, timeout=900, check=False) if os.path.exists(jar): os.remove(jar) if loader == 'fabric': if not os.path.exists(os.path.join(d, 'fabric-server-launch.jar')): raise RuntimeError('Fabric-Installation fehlgeschlagen: ' + out[-200:]) return ['-jar', 'fabric-server-launch.jar'] for root, _, files in os.walk(os.path.join(d, 'libraries')): if 'unix_args.txt' in files: return ['@' + os.path.relpath(os.path.join(root, 'unix_args.txt'), d)] jars = [f for f in os.listdir(d) if re.match(r'(forge|neoforge)-.*\.jar$', f) and 'installer' not in f] if jars: return ['-jar', sorted(jars)[-1]] raise RuntimeError('Loader-Installation fehlgeschlagen: ' + out[-200:]) def write_config(d, launch, extra=None): with open(os.path.join(d, 'eula.txt'), 'w') as f: f.write('eula=true\n') wanted = {'level-seed': '20261121', 'online-mode': 'false', 'max-players': '20', 'view-distance': '10', 'simulation-distance': '8', 'spawn-protection': '0', 'level-name': 'world', 'server-port': '25565', 'enable-rcon': 'false', 'enable-query': 'false', 'sync-chunk-writes': 'false'} wanted.update(extra or {}) path = os.path.join(d, 'server.properties') lines = [] if os.path.exists(path): lines = [l.rstrip('\n') for l in open(path, errors='replace') if l.split('=')[0].strip() not in wanted] with open(path, 'w') as f: f.write('\n'.join(lines + [f'{k}={v}' for k, v in wanted.items()]) + '\n') jvm = f'-Xms1G -Xmx{HEAP} -XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -Dterminal.jline=false -Dterminal.ansi=false' with open(os.path.join(d, '.start.sh'), 'w') as f: f.write('#!/bin/sh\nrm -f .cmd\nmkfifo .cmd\nexec 3<>.cmd\n') f.write(f"java {jvm} {' '.join(launch)} nogui <&3 >.console.log 2>&1\n") sh(['chown', '-R', f'{UID}:{UID}', d]) def send(d, command): fd = os.open(os.path.join(d, '.cmd'), os.O_WRONLY | os.O_NONBLOCK) try: os.write(fd, (command + '\n').encode()) finally: os.close(fd) def console(d): try: with open(os.path.join(d, '.console.log'), errors='replace') as f: return f.read() except FileNotFoundError: return '' def running(name): return sh(['docker', 'inspect', '-f', '{{.State.Running}}', name], check=False).strip() == 'true' def anon_mb(cid): for path in (f'/sys/fs/cgroup/system.slice/docker-{cid}.scope/memory.stat', f'/sys/fs/cgroup/docker/{cid}/memory.stat'): try: for line in open(path): if line.startswith('anon '): return int(line.split()[1]) / 1024 / 1024 except OSError: continue return 0.0 def java_pid(name): out = sh(['docker', 'exec', '--user', UID, name, 'jcmd', '-l'], check=False) for line in out.splitlines(): parts = line.split() if parts and parts[0].isdigit() and 'JCmd' not in line: return parts[0] return None def heap_after_gc(name): pid = java_pid(name) if not pid: return None # Zweimal: Die erste Bereinigung gibt schwach referenzierte und finalisierbare Objekte oft erst fuer die zweite frei for _ in range(2): sh(['docker', 'exec', '--user', UID, name, 'jcmd', pid, 'GC.run'], check=False, timeout=120) time.sleep(4) # jstat gibt es in allen Java-Versionen (GC.heap_info fehlt in Java 8) out = sh(['docker', 'exec', '--user', UID, name, 'jstat', '-gc', pid], check=False, timeout=60).strip().splitlines() if len(out) < 2: return None row = dict(zip(out[-2].split(), out[-1].split())) try: heap_kb = sum(float(row[k].replace(',', '.')) for k in ('S0U', 'S1U', 'EU', 'OU')) meta_kb = float(row['MU'].replace(',', '.')) except (KeyError, ValueError): return None return {'heap_mb': round(heap_kb / 1024), 'metaspace_mb': round(meta_kb / 1024)} def dir_size(path): total = 0 for root, _, files in os.walk(path): for f in files: try: total += os.path.getsize(os.path.join(root, f)) except OSError: pass return total def crash_reason(d, text): """Kurze Ursache aus dem Absturzbericht oder der Konsole.""" folder = os.path.join(d, 'crash-reports') report = '' if os.path.isdir(folder): files = sorted(os.listdir(folder)) if files: with open(os.path.join(folder, files[-1]), errors='replace') as f: report = f.read() parts = [] for pattern in (r'Failure message: ([^\n]+)', r'Description: ([^\n]+)', r'Mod File: ([^\n]+)'): m = re.search(pattern, report) if m: parts.append(m.group(1).strip()[:90]) missing = re.findall(r"Mod '([^']+)' \([^)]*\) [^\n]*? requires [^\n]*? of ([\w.-]+), which is missing", text) if missing: parts.append('fehlende Abhaengigkeit: ' + ', '.join(f'{a} braucht {b}' for a, b in missing[:3])) if 'Missing Mods Checker' in text and 'HeadlessException' in text: parts.append('Missing Mods Checker meldet fehlende Mods') caused = re.findall(r'Caused by(?: \d+)?: ([^\n]+)', report or text) useful = [c for c in caused if 'UnknownHostException' not in c] if useful: parts.append(useful[-1].strip()[:110]) return ' | '.join(parts)[:280] or 'Ursache nicht erkannt' def count_target_chunks(world): """Zaehlt, wie viele der 256 Ziel-Chunks (x und z von -8 bis 7) wirklich in den Regionsdateien stehen.""" for region in (os.path.join(world, 'region'), os.path.join(world, 'dimensions', 'minecraft', 'overworld', 'region')): if os.path.isdir(region): break else: return 0 headers = {} found = 0 for x in range(-8, 8): for z in range(-8, 8): key = (x >> 5, z >> 5) if key not in headers: try: with open(os.path.join(region, f'r.{key[0]}.{key[1]}.mca'), 'rb') as f: headers[key] = f.read(4096) except OSError: headers[key] = b'' offset = 4 * ((x & 31) + (z & 31) * 32) entry = headers[key][offset:offset + 4] if len(entry) == 4 and entry != b'\0\0\0\0': found += 1 return found def mca_size(path): total = 0 for root, _, files in os.walk(path): if os.path.basename(root) != 'region': continue for f in files: if f.endswith('.mca'): try: total += os.path.getsize(os.path.join(root, f)) except OSError: pass return total def guard_sleep(seconds, name): end = time.time() + seconds while time.time() < end: time.sleep(min(5, max(0.2, end - time.time()))) if not running(name): raise RuntimeError('Server beendet') why = pressure() if why: time.sleep(10) why = pressure() if why: raise Guard(why) def measure(pack, d, res): name = 'NH-TEST-mp-' + re.sub(r'[^a-z0-9-]', '-', pack['slug'])[:40] current['name'] = name cid = sh(box(pack, d, 'none', name) + ['-d', '--entrypoint', 'sh', image(pack), '.start.sh']).strip() peak = {'mb': 0.0, 'stop': False} def sampler(): while not peak['stop']: peak['mb'] = max(peak['mb'], anon_mb(cid)) time.sleep(2) threading.Thread(target=sampler, daemon=True).start() try: started = time.time() done = None while time.time() - started < START_TIMEOUT: text = console(d) m = re.search(r'Done \(([0-9.,]+)s\)!', text) if m: done = float(m.group(1).replace(',', '.')) break if not running(name): raise RuntimeError('Absturz beim Start: ' + crash_reason(d, text)) # Manche Packs stuerzen ab, ohne dass Java sich beendet: nicht 20 Minuten darauf warten if re.search(r'Failed to start the minecraft server|This crash report has been saved|Crash report saved|Preparing crash report|Mod loading has failed', text): time.sleep(5) raise RuntimeError('Absturz beim Start: ' + crash_reason(d, console(d))) why = pressure() if why: time.sleep(10) why = pressure() if why: raise Guard(why) time.sleep(3) if done is None: raise RuntimeError('Start dauerte ueber 20 Minuten') res['start_s'] = round(time.time() - started, 1) res['start_server_s'] = done guard_sleep(60, name) # Startphase abklingen lassen, damit befristete Caches den Wert nicht aufblaehen boot = heap_after_gc(name) or {} res['boot_heap_mb'] = boot.get('heap_mb') res['boot_metaspace_mb'] = boot.get('metaspace_mb') res['boot_anon_mb'] = round(anon_mb(cid)) # 256 Chunks (Hoechstwert von /forceload) laden; fertig, wenn die gespeicherte Welt nicht mehr waechst world_dir = os.path.join(d, 'world') t0 = time.time() if EINGRIFFE.get(pack['slug'], {}).get('chunks') == 'forge': send(d, 'forge generate 0 64 0 289') # 17 x 17 Chunks um 0,0 decken die 256 Ziel-Chunks sicher ab else: send(d, 'forceload add -128 -128 127 127') res['forceload_bestaetigt'] = False for _ in range(12): guard_sleep(5, name) if re.search(r'Marked .*force.?loaded', console(d)): res['forceload_bestaetigt'] = True break # Fertig erst, wenn alle 256 Ziel-Chunks nachweislich in den Regionsdateien stehen (hoechstens 5 Minuten) chunks = 0 while time.time() - t0 < 300: send(d, 'save-all flush') guard_sleep(8, name) chunks = count_target_chunks(world_dir) if chunks >= 256: break res['chunks_gezaehlt'] = chunks res['chunks_stabil'] = chunks >= 256 res['chunks_s'] = round(time.time() - t0, 1) res['welt_mb'] = round(mca_size(world_dir) / 1024 / 1024, 1) guard_sleep(30, name) world = heap_after_gc(name) or {} res['world_heap_mb'] = world.get('heap_mb') res['world_metaspace_mb'] = world.get('metaspace_mb') res['world_anon_mb'] = round(anon_mb(cid)) res['peak_anon_mb'] = round(peak['mb']) res['status'] = 'ok' send(d, 'stop') for _ in range(20): if not running(name): break time.sleep(3) finally: peak['stop'] = True text = console(d) with open(os.path.join(LOGS, pack['slug'] + '.log'), 'w') as f: f.write('\n'.join(text.splitlines()[-80:]) + '\n') sh(['docker', 'rm', '-f', name], check=False, timeout=60) current['name'] = None def run_pack(pack): d = os.path.join(RUN, pack['slug']) shutil.rmtree(d, ignore_errors=True) os.makedirs(d) res = {k: pack.get(k) for k in ('slug', 'title', 'version', 'minecraft', 'loader', 'loader_version', 'java', 'mods', 'downloads')} res.update({'status': 'fehler', 'zeit': time.strftime('%FT%T')}) timer = threading.Timer(PACK_TIMEOUT, lambda: remove_containers()) timer.start() try: res['server_dateien'] = install_pack(pack, d, res) apply_eingriffe(pack, d, res) mods_dir = os.path.join(d, 'mods') res['mods_installiert'] = len([f for f in os.listdir(mods_dir) if f.endswith('.jar')]) if os.path.isdir(mods_dir) else 0 launch = install_loader(pack, d) write_config(d, launch, EINGRIFFE.get(pack['slug'], {}).get('properties')) measure(pack, d, res) except Guard as e: res['status'] = 'node-ausgelastet' res['grund'] = str(e) except Exception as e: res['grund'] = str(e)[:300] finally: timer.cancel() shutil.rmtree(d, ignore_errors=True) return res def main(): os.makedirs(RUN, exist_ok=True) os.makedirs(LOGS, exist_ok=True) atexit.register(cleanup) signal.signal(signal.SIGTERM, on_signal) signal.signal(signal.SIGINT, on_signal) threading.Thread(target=watchdog, daemon=True).start() remove_containers() packs = json.load(open(sys.argv[1])) if len(sys.argv) > 2: wanted = set(sys.argv[2:]) packs = [p for p in packs if p['slug'] in wanted] done = set() if os.path.exists(RESULTS): for line in open(RESULTS): r = json.loads(line) if r.get('status') in ('ok', 'fehler'): done.add(r['slug']) queue = [(p, 0) for p in packs if p['slug'] not in done] log(f'Start: {len(queue)} Packs') while queue: pack, tries = queue.pop(0) wait_calm() log(f"{pack['slug']}: laeuft") res = run_pack(pack) with open(RESULTS, 'a') as f: f.write(json.dumps(res, ensure_ascii=False) + '\n') log(f"{pack['slug']}: {res['status']} start={res.get('start_s')} boot={res.get('boot_heap_mb')} welt={res.get('world_heap_mb')} {res.get('grund', '')}") if res['status'] == 'node-ausgelastet' and tries < 2: queue.append((pack, tries + 1)) log('FERTIG') if __name__ == '__main__': main()